feat(kilo-vscode): migrate legacy sessions into new extension

packages/kilo-vscode/src/KiloProvider.ts

@@ -2802,6 +2802,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
       set migrationCheckInFlight(val) {
         self.migrationCheckInFlight = val
       },
+      refreshSessions: () => this.refreshSessions(),
       disposeGlobal: () => this.disposeGlobal(),
       broadcastComplete: () => this.connectionService.notifyMigrationComplete(),
     }

packages/kilo-vscode/src/kilo-provider/handlers/migration.ts

@@ -28,6 +28,7 @@ export interface MigrationContext {
   readonly client: KiloClient | null
   readonly extensionContext: MigrationExtensionContext | undefined
   postMessage(msg: unknown): void
+  refreshSessions(): void
   cachedLegacyData: LegacyMigrationData | null
   migrationCheckInFlight: boolean
   disposeGlobal(): Promise<void>
@@ -69,6 +70,7 @@ export async function checkAndShowMigrationWizard(ctx: MigrationContext): Promis
       providers: data.providers,
       mcpServers: data.mcpServers,
       customModes: data.customModes,
+      sessions: data.sessions,
       defaultModel: data.defaultModel,
       settings: data.settings,
     },
@@ -88,6 +90,7 @@ export async function handleRequestLegacyMigrationData(ctx: MigrationContext): P
       providers: data.providers,
       mcpServers: data.mcpServers,
       customModes: data.customModes,
+      sessions: data.sessions,
       defaultModel: data.defaultModel,
       settings: data.settings,
     },
@@ -125,6 +128,7 @@ export async function handleStartLegacyMigration(
         "completed",
       )
       ctx.broadcastComplete()
+      ctx.refreshSessions()
     }
 
     ctx.postMessage({ type: "legacyMigrationComplete", results })

packages/kilo-vscode/src/legacy-migration/legacy-types.ts

@@ -288,6 +288,7 @@ export interface LegacyMigrationData {
   providers: MigrationProviderInfo[]
   mcpServers: MigrationMcpServerInfo[]
   customModes: MigrationCustomModeInfo[]
+  sessions?: string[]
   defaultModel?: { provider: string; model: string }
   settings?: LegacySettings
   hasData: boolean
@@ -318,13 +319,14 @@ export interface MigrationSelections {
   providers: string[]
   mcpServers: string[]
   customModes: string[]
+  sessions?: string[]
   defaultModel: boolean
   settings: MigrationSettingsSelections
 }
 
 export interface MigrationResultItem {
   item: string
-  category: "provider" | "mcpServer" | "customMode" | "defaultModel" | "settings"
+  category: "provider" | "mcpServer" | "customMode" | "defaultModel" | "settings" | "session"
   status: "success" | "warning" | "error"
   message?: string
 }

packages/kilo-vscode/src/legacy-migration/migration-service.ts

@@ -32,6 +32,7 @@ import type {
   MigrationCustomModeInfo,
   MigrationResultItem,
 } from "./legacy-types"
+import { migrate as migrateSession } from "./sessions/migrate"
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -68,6 +69,7 @@ export async function detectLegacyData(context: vscode.ExtensionContext): Promis
   const mcpSettings = await readLegacyMcpSettings(context)
   const customModes = await readLegacyCustomModes(context)
   const settings = readLegacySettings(context)
+  const sessions = await readSessionsInGlobalStorage(context)
 
   const oauthProviders = new Set<string>()
   const codexRaw = await context.secrets.get(CODEX_OAUTH_SECRET_KEY)
@@ -92,18 +94,29 @@ export async function detectLegacyData(context: vscode.ExtensionContext): Promis
     Boolean(settings.language) ||
     Boolean(settings.autocomplete)
 
-  const hasData = providers.length > 0 || mcpServers.length > 0 || modes.length > 0 || hasSettings
+  const hasData =
+    providers.length > 0 || mcpServers.length > 0 || modes.length > 0 || hasSettings || sessions.length > 0
 
   return {
     providers,
     mcpServers,
     customModes: modes,
+    sessions: sessions.length > 0 ? sessions : undefined,
     defaultModel,
     settings: hasSettings ? settings : undefined,
     hasData,
   }
 }
 
+async function readSessionsInGlobalStorage(context: vscode.ExtensionContext) {
+  const dir = vscode.Uri.joinPath(context.globalStorageUri, "tasks")
+  const items = await vscode.workspace.fs.readDirectory(dir).then(
+    (items) => items,
+    () => [] as [string, vscode.FileType][],
+  )
+  return items.filter(([, type]) => type === vscode.FileType.Directory).map(([name]) => name)
+}
+
 // ---------------------------------------------------------------------------
 // Migration
 // ---------------------------------------------------------------------------
@@ -197,6 +210,24 @@ export async function migrate(
     }
   }
 
+  if (selections.sessions?.length) {
+    for (const id of selections.sessions) {
+      onProgress("Chat sessions", "migrating")
+      const result = await migrateSession(id, context, client)
+      results.push({
+        item: id,
+        category: "session",
+        status: result.ok ? "success" : "error",
+        message: result.ok ? "Session migrated" : "Session migration failed",
+      })
+      onProgress(
+        "Chat sessions",
+        result.ok ? "success" : "error",
+        result.ok ? "Session migrated" : "Session migration failed",
+      )
+    }
+  }
+
   // Migrate default model
   if (selections.defaultModel && profiles) {
     const activeName = profiles.currentApiConfigName

packages/kilo-vscode/src/legacy-migration/sessions/lib/ids.ts

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto"
+
+export function createProjectID(worktree?: string) {
+  return hash(worktree ?? "")
+}
+
+export function createSessionID(id: string) {
+  return prefixed("ses", id)
+}
+
+export function createMessageID(id: string, index: number) {
+  return prefixed("msg", `${id}:${index}`)
+}
+
+export function createPartID(id: string, index: number, part: number) {
+  return prefixed("prt", `${id}:${index}:${part}`)
+}
+
+export function createExtraPartID(id: string, index: number, kind: string) {
+  return prefixed("prt", `${id}:${index}:${kind}`)
+}
+
+function prefixed(prefix: string, value: string) {
+  return `${prefix}_migrated_${hash(value).slice(0, 26)}`
+}
+
+function hash(value: string) {
+  return createHash("sha1").update(value).digest("hex")
+}

packages/kilo-vscode/src/legacy-migration/sessions/lib/legacy-conversation.ts

@@ -0,0 +1,17 @@
+import * as path from "node:path"
+import * as vscode from "vscode"
+import type { LegacyApiMessage } from "./legacy-types"
+
+export async function getApiConversationHistory(id: string, dir: string) {
+  const file = path.join(dir, id, "api_conversation_history.json")
+  return vscode.workspace.fs.readFile(vscode.Uri.file(file))
+}
+
+export function parseFile(file: Uint8Array): LegacyApiMessage[] {
+  const text = Buffer.from(file).toString("utf8")
+  const json = JSON.parse(text) as unknown
+  if (!Array.isArray(json)) {
+    throw new Error("Legacy conversation history must be a JSON array")
+  }
+  return json.filter((entry): entry is LegacyApiMessage => Boolean(entry && typeof entry === "object"))
+}

packages/kilo-vscode/src/legacy-migration/sessions/lib/legacy-types.ts

@@ -0,0 +1,28 @@
+import type { Anthropic } from "@anthropic-ai/sdk"
+
+export interface LegacyHistoryItem {
+  id: string
+  rootTaskId?: string
+  parentTaskId?: string
+  ts?: number
+  task?: string
+  workspace?: string
+  mode?: string
+}
+
+export type LegacyApiMessage = Anthropic.MessageParam & {
+  ts?: number
+  isSummary?: boolean
+  id?: string
+  type?: "reasoning"
+  summary?: unknown[]
+  encrypted_content?: string
+  text?: string
+  reasoning_details?: unknown[]
+  reasoning_content?: string
+  condenseId?: string
+  condenseParent?: string
+  truncationId?: string
+  truncationParent?: string
+  isTruncationMarker?: boolean
+}

packages/kilo-vscode/src/legacy-migration/sessions/lib/messages.ts

@@ -0,0 +1,82 @@
+import type { KilocodeSessionImportMessageData as Message } from "@kilocode/sdk/v2"
+import type { LegacyApiMessage, LegacyHistoryItem } from "./legacy-types"
+import { createMessageID, createSessionID } from "./ids"
+
+type Body = NonNullable<Message["body"]>
+type Data = Body["data"]
+type User = Extract<Data, { role: "user" }>
+type Assistant = Extract<Data, { role: "assistant" }>
+
+export function parseMessagesFromConversation(
+  conversation: LegacyApiMessage[],
+  id: string,
+  item?: LegacyHistoryItem,
+): Array<NonNullable<Message["body"]>> {
+  return conversation
+    .filter((entry) => entry.role === "user" || entry.role === "assistant")
+    .map((entry, index) => parseMessage(entry, index, id, item))
+    .filter((message): message is NonNullable<Message["body"]> => Boolean(message))
+}
+
+function parseMessage(
+  entry: LegacyApiMessage,
+  index: number,
+  id: string,
+  item?: LegacyHistoryItem,
+): NonNullable<Message["body"]> | undefined {
+  const created = entry.ts ?? item?.ts ?? 0
+
+  if (entry.role === "user") {
+    const data: User = {
+      role: "user",
+      time: { created },
+      agent: "user",
+      model: {
+        providerID: "legacy",
+        modelID: "legacy",
+      },
+    }
+
+    return {
+      id: createMessageID(id, index),
+      sessionID: createSessionID(id),
+      timeCreated: created,
+      data,
+    }
+  }
+
+  if (entry.role === "assistant") {
+    const data: Assistant = {
+      role: "assistant",
+      time: { created, completed: created },
+      parentID: index > 0 ? createMessageID(id, index - 1) : createMessageID(id, index),
+      modelID: "legacy",
+      providerID: "legacy",
+      mode: item?.mode ?? "code",
+      agent: "main",
+      path: {
+        cwd: item?.workspace ?? "",
+        root: item?.workspace ?? "",
+      },
+      cost: 0,
+      tokens: {
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cache: {
+          read: 0,
+          write: 0,
+        },
+      },
+    }
+
+    return {
+      id: createMessageID(id, index),
+      sessionID: createSessionID(id),
+      timeCreated: created,
+      data,
+    }
+  }
+
+  return undefined
+}

packages/kilo-vscode/src/legacy-migration/sessions/lib/parts/merge-tools.ts

@@ -0,0 +1,66 @@
+import type { KilocodeSessionImportPartData as Part } from "@kilocode/sdk/v2"
+import type { LegacyApiMessage } from "../legacy-types"
+import { getText, getToolUse, isToolResult, record } from "./parts-util"
+
+type Body = NonNullable<Part["body"]>
+type Data = Body["data"]
+type Tool = Extract<Data, { type: "tool" }>
+type ToolCompleted = Extract<Tool["state"], { status: "completed" }>
+
+// This takes the "tool started" half and the matching "tool finished" half,
+// and merges both so the migrated session keeps one complete tool action.
+export function mergeToolUseAndResult(
+  partID: string,
+  messageID: string,
+  sessionID: string,
+  created: number,
+  conversation: LegacyApiMessage[],
+  result: { type?: string; tool_use_id?: string; content?: unknown },
+): NonNullable<Part["body"]> | undefined {
+  const tool = getToolUseFromConversation(conversation, result.tool_use_id)
+  if (!tool) return undefined
+  const callID = typeof tool.id === "string" ? tool.id : partID
+  const name = typeof tool.name === "string" ? tool.name : "unknown"
+  const output = getText(result.content) ?? name
+  const state: ToolCompleted = {
+    status: "completed",
+    input: record(tool.input),
+    output,
+    title: name,
+    metadata: {},
+    time: {
+      start: created,
+      end: created,
+    },
+  }
+
+  const data: Tool = {
+    type: "tool",
+    callID,
+    tool: name,
+    state,
+  }
+
+  return {
+    id: partID,
+    messageID,
+    sessionID,
+    timeCreated: created,
+    data,
+  }
+}
+
+export function thereIsNoToolResult(conversation: LegacyApiMessage[], id: string | undefined) {
+  return !conversation.some(
+    (entry) =>
+      Array.isArray(entry.content) && entry.content.some((part) => isToolResult(part) && part.tool_use_id === id),
+  )
+}
+
+function getToolUseFromConversation(conversation: LegacyApiMessage[], id: string | undefined) {
+  for (const entry of conversation) {
+    const tool = getToolUse(entry, id)
+    if (tool) return tool
+  }
+  return undefined
+}