autohand-cli 0.9.1 → 0.9.2

package/dist/{registry-4DXUDKJN.js → registry-EZ4V4TUQ.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-SHRLFX6F.js";
+} from "./chunk-PG2JIU5M.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/import/importers/ClaudeImporter.ts
@@ -1024,6 +1024,13 @@ var GeminiImporter = class extends BaseImporter {
             });
           }
         }
+        const mcpServers = this.extractMcpServers(settings);
+        if (mcpServers && Object.keys(mcpServers).length > 0) {
+          available.set("mcp", {
+            count: Object.keys(mcpServers).length,
+            description: `${Object.keys(mcpServers).length} Gemini MCP server${Object.keys(mcpServers).length !== 1 ? "s" : ""}`
+          });
+        }
       } catch {
       }
     }
@@ -1048,6 +1055,9 @@ var GeminiImporter = class extends BaseImporter {
         case "hooks":
           await this.importHooks(imported, errors, onProgress);
           break;
+        case "mcp":
+          await this.importMcp(imported, errors, onProgress);
+          break;
         case "memory":
           await this.importMemory(imported, errors, onProgress);
           break;
@@ -1162,6 +1172,58 @@ var GeminiImporter = class extends BaseImporter {
     }
   }
   // ---------------------------------------------------------------
+  // MCP
+  // ---------------------------------------------------------------
+  async importMcp(imported, errors, onProgress) {
+    const settingsPath = path4.join(this.resolvedHomePath, "settings.json");
+    if (!await fse4.pathExists(settingsPath)) {
+      imported.set("mcp", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "mcp",
+      current: 1,
+      total: 1,
+      item: "mcpServers from settings.json",
+      status: "importing"
+    });
+    try {
+      const settings = await this.safeReadJson(settingsPath);
+      const mcpServers = this.extractMcpServers(settings);
+      if (!mcpServers || Object.keys(mcpServers).length === 0) {
+        imported.set("mcp", { success: 0, failed: 0, skipped: 1 });
+        return;
+      }
+      const configDir = AUTOHAND_PATHS.config;
+      await fse4.ensureDir(configDir);
+      await fse4.writeJson(
+        path4.join(configDir, "imported-gemini-mcp.json"),
+        {
+          importedFrom: "gemini",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          mcpServers
+        },
+        { spaces: 2 }
+      );
+      imported.set("mcp", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "mcp",
+        current: 1,
+        total: 1,
+        item: "mcpServers from settings.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("mcp", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "mcp",
+        item: "mcpServers from settings.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
   // Memory
   // ---------------------------------------------------------------
   async importMemory(imported, errors, onProgress) {
@@ -1199,6 +1261,20 @@ var GeminiImporter = class extends BaseImporter {
       });
     }
   }
+  extractMcpServers(settings) {
+    const direct = settings.mcpServers;
+    if (direct && typeof direct === "object" && !Array.isArray(direct)) {
+      return direct;
+    }
+    const mcp = settings.mcp;
+    if (mcp && typeof mcp === "object" && !Array.isArray(mcp)) {
+      const maybeServers = mcp.servers ?? mcp.mcpServers;
+      if (maybeServers && typeof maybeServers === "object" && !Array.isArray(maybeServers)) {
+        return maybeServers;
+      }
+    }
+    return void 0;
+  }
 };
 
 // src/import/importers/CursorImporter.ts
@@ -2037,6 +2113,1266 @@ var AugmentImporter = class extends BaseImporter {
   }
 };
 
+// src/import/importers/OpencodeImporter.ts
+import os2 from "os";
+import path9 from "path";
+import fse9 from "fs-extra";
+var OpencodeImporter = class extends BaseImporter {
+  name = "opencode";
+  displayName = "OpenCode";
+  homePath = "~/.config/opencode";
+  get dataHome() {
+    return path9.join(os2.homedir(), ".local", "share", "opencode");
+  }
+  async detect() {
+    if (await fse9.pathExists(this.resolvedHomePath)) return true;
+    if (await fse9.pathExists(this.dataHome)) return true;
+    for (const config of this.globalConfigCandidates()) {
+      if (await fse9.pathExists(config.path)) return true;
+    }
+    return false;
+  }
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    if (!await this.detect()) {
+      return { source: this.name, available };
+    }
+    const settings = await this.existingConfigFiles();
+    if (settings.length > 0) {
+      available.set("settings", {
+        count: settings.length,
+        description: "OpenCode config and TUI settings"
+      });
+    }
+    const mcp = await this.collectMcpServers(settings);
+    if (Object.keys(mcp).length > 0) {
+      available.set("mcp", {
+        count: Object.keys(mcp).length,
+        description: `${Object.keys(mcp).length} OpenCode MCP server${Object.keys(mcp).length !== 1 ? "s" : ""}`
+      });
+    }
+    if (await fse9.pathExists(path9.join(this.resolvedHomePath, "AGENTS.md"))) {
+      available.set("memory", { count: 1, description: "OpenCode global AGENTS.md rules" });
+    }
+    const skills = await this.discoverSkillDirs();
+    if (skills.length > 0) {
+      available.set("skills", {
+        count: skills.length,
+        description: `${skills.length} OpenCode skill${skills.length !== 1 ? "s" : ""}`
+      });
+    }
+    const sessionFiles = await this.discoverJsonSessionFiles();
+    const sqlitePath = path9.join(this.dataHome, "opencode.db");
+    const hasSqlite = await fse9.pathExists(sqlitePath);
+    if (sessionFiles.length > 0 || hasSqlite) {
+      available.set("sessions", {
+        count: sessionFiles.length + (hasSqlite ? 1 : 0),
+        description: hasSqlite ? "OpenCode session database and JSON session files" : `${sessionFiles.length} OpenCode JSON session${sessionFiles.length !== 1 ? "s" : ""}`
+      });
+    }
+    return { source: this.name, available };
+  }
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "sessions":
+          await this.importSessions(imported, errors, onProgress);
+          break;
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        case "mcp":
+          await this.importMcp(imported, errors, onProgress);
+          break;
+        case "memory":
+          await this.importMemory(imported, errors, onProgress);
+          break;
+        case "skills":
+          await this.importSkills(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  async importSettings(imported, errors, onProgress) {
+    const files = await this.existingConfigFiles();
+    if (files.length === 0) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "OpenCode config files",
+      status: "importing"
+    });
+    try {
+      const importedFiles = [];
+      for (const file of files) {
+        const raw = await fse9.readFile(file.path, "utf-8");
+        const parsed = this.parseJsonc(raw);
+        importedFiles.push({
+          file: file.file,
+          raw,
+          ...parsed ? { parsed } : {}
+        });
+      }
+      await fse9.ensureDir(AUTOHAND_PATHS.config);
+      await fse9.writeJson(
+        path9.join(AUTOHAND_PATHS.config, "imported-opencode-settings.json"),
+        {
+          importedFrom: "opencode",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          files: importedFiles
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "OpenCode config files",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "OpenCode config files",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  async importMcp(imported, errors, onProgress) {
+    const files = await this.existingConfigFiles();
+    if (files.length === 0) {
+      imported.set("mcp", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "mcp",
+      current: 1,
+      total: 1,
+      item: "mcp from opencode config",
+      status: "importing"
+    });
+    try {
+      const mcpServers = await this.collectMcpServers(files);
+      if (Object.keys(mcpServers).length === 0) {
+        imported.set("mcp", { success: 0, failed: 0, skipped: 1 });
+        return;
+      }
+      await fse9.ensureDir(AUTOHAND_PATHS.config);
+      await fse9.writeJson(
+        path9.join(AUTOHAND_PATHS.config, "imported-opencode-mcp.json"),
+        {
+          importedFrom: "opencode",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          mcpServers
+        },
+        { spaces: 2 }
+      );
+      imported.set("mcp", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "mcp",
+        current: 1,
+        total: 1,
+        item: "mcp from opencode config",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("mcp", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "mcp",
+        item: "mcp from opencode config",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  async importMemory(imported, errors, onProgress) {
+    const agentsPath = path9.join(this.resolvedHomePath, "AGENTS.md");
+    if (!await fse9.pathExists(agentsPath)) {
+      imported.set("memory", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "memory",
+      current: 1,
+      total: 1,
+      item: "AGENTS.md",
+      status: "importing"
+    });
+    try {
+      const destDir = path9.join(AUTOHAND_PATHS.memory, "imported-opencode");
+      await fse9.ensureDir(destDir);
+      await fse9.copy(agentsPath, path9.join(destDir, "AGENTS.md"));
+      imported.set("memory", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "memory",
+        current: 1,
+        total: 1,
+        item: "AGENTS.md",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("memory", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "memory",
+        item: "AGENTS.md",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: true
+      });
+    }
+  }
+  async importSkills(imported, errors, onProgress) {
+    const skills = await this.discoverSkillDirs();
+    if (skills.length === 0) {
+      imported.set("skills", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    const destBase = path9.join(AUTOHAND_PATHS.skills, "imported-opencode");
+    let success = 0;
+    let failed = 0;
+    for (let i = 0; i < skills.length; i++) {
+      const skill = skills[i];
+      onProgress?.({
+        category: "skills",
+        current: i + 1,
+        total: skills.length,
+        item: skill.name,
+        status: "importing"
+      });
+      try {
+        await fse9.ensureDir(destBase);
+        await fse9.copy(skill.path, path9.join(destBase, skill.name));
+        success++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "skills",
+          item: skill.name,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("skills", { success, failed, skipped: 0 });
+  }
+  async importSessions(imported, errors, onProgress) {
+    const jsonSessions = await this.discoverJsonSessionFiles();
+    const sqlitePath = path9.join(this.dataHome, "opencode.db");
+    const hasSqlite = await fse9.pathExists(sqlitePath);
+    if (jsonSessions.length === 0 && !hasSqlite) {
+      imported.set("sessions", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    const skipReasons = {};
+    const trackSkip = (reason) => {
+      skipped++;
+      skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+    };
+    const total = jsonSessions.length + (hasSqlite ? 1 : 0);
+    for (let i = 0; i < jsonSessions.length; i++) {
+      const sessionFile = jsonSessions[i];
+      onProgress?.({
+        category: "sessions",
+        current: i + 1,
+        total,
+        item: sessionFile.sessionId,
+        status: "importing"
+      });
+      try {
+        const session = await this.readJsonSession(sessionFile);
+        if (!session || session.messages.length === 0) {
+          trackSkip("no user/assistant messages");
+          continue;
+        }
+        const result = await this.writeAutohandSession({
+          projectPath: session.projectPath,
+          projectName: path9.basename(session.projectPath),
+          model: session.model,
+          messages: session.messages,
+          source: this.name,
+          originalId: session.originalId,
+          createdAt: session.messages[0].timestamp,
+          closedAt: session.messages[session.messages.length - 1].timestamp,
+          summary: session.summary,
+          status: "completed"
+        });
+        if (result === null) {
+          trackSkip("already imported");
+        } else {
+          success++;
+        }
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "sessions",
+          item: sessionFile.sessionId,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    if (hasSqlite) {
+      onProgress?.({
+        category: "sessions",
+        current: jsonSessions.length + 1,
+        total,
+        item: "opencode.db",
+        status: "importing"
+      });
+      try {
+        const sqliteResult = await this.importSqliteSessions(sqlitePath);
+        success += sqliteResult.success;
+        failed += sqliteResult.failed;
+        skipped += sqliteResult.skipped;
+        for (const [reason, count] of Object.entries(sqliteResult.skipReasons)) {
+          skipReasons[reason] = (skipReasons[reason] ?? 0) + count;
+        }
+        errors.push(...sqliteResult.errors);
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "sessions",
+          item: "opencode.db",
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("sessions", {
+      success,
+      failed,
+      skipped,
+      ...Object.keys(skipReasons).length > 0 ? { skipReasons } : {}
+    });
+  }
+  async readJsonSession(sessionFile) {
+    const sessionData = this.asRecord(await fse9.readJson(sessionFile.path));
+    const originalId = this.readString(sessionData, "id") ?? sessionFile.sessionId;
+    const projectPath = this.readString(sessionData, "directory") ?? this.readString(this.asRecord(sessionData.path), "cwd") ?? this.readString(this.asRecord(sessionData.path), "root") ?? process.cwd();
+    const model = this.extractModel(sessionData);
+    const summary = this.readString(sessionData, "title") ?? "Imported OpenCode session";
+    const rawMessages = await this.readJsonMessages(originalId);
+    const messages = rawMessages.map((message) => this.convertStoredMessage(message)).filter((message) => message !== null);
+    if (messages.length === 0) return null;
+    return {
+      originalId,
+      projectPath,
+      model,
+      summary,
+      messages
+    };
+  }
+  async readJsonMessages(sessionId) {
+    const messageDirs = [
+      path9.join(this.dataHome, "storage", "message", sessionId),
+      path9.join(this.dataHome, "storage", "session", "message", sessionId)
+    ];
+    const messages = [];
+    for (const messageDir of messageDirs) {
+      if (!await fse9.pathExists(messageDir)) continue;
+      const entries = await this.readDir(messageDir);
+      for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".json"))) {
+        const messagePath = path9.join(messageDir, entry.name);
+        const messageData = this.asRecord(await fse9.readJson(messagePath));
+        const messageId = this.readString(messageData, "id") ?? path9.basename(entry.name, ".json");
+        const role = this.normalizeRole(
+          this.readString(messageData, "role") ?? this.readString(this.asRecord(messageData.data), "role") ?? this.readString(this.asRecord(messageData.info), "role")
+        );
+        if (!role) continue;
+        const parts = await this.readJsonParts(sessionId, messageId);
+        const content = parts.join("") || this.readString(messageData, "content") || this.readString(this.asRecord(messageData.data), "content") || this.readString(messageData, "text");
+        messages.push({
+          id: messageId,
+          role,
+          timestamp: this.toIsoTimestamp(
+            this.asRecord(messageData.time).created ?? messageData.time_created ?? this.asRecord(messageData.data).time_created
+          ),
+          content
+        });
+      }
+    }
+    return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  async readJsonParts(sessionId, messageId) {
+    const partDirs = [
+      path9.join(this.dataHome, "storage", "part", messageId),
+      path9.join(this.dataHome, "storage", "session", "part", sessionId, messageId)
+    ];
+    const parts = [];
+    for (const partDir of partDirs) {
+      if (!await fse9.pathExists(partDir)) continue;
+      const entries = await this.readDir(partDir);
+      for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".json"))) {
+        const partData = this.asRecord(await fse9.readJson(path9.join(partDir, entry.name)));
+        const text = this.extractPartText(partData);
+        if (text) parts.push(text);
+      }
+    }
+    return parts;
+  }
+  async importSqliteSessions(sqlitePath) {
+    let DatabaseSync;
+    try {
+      ({ DatabaseSync } = await import("sqlite"));
+    } catch {
+      return {
+        success: 0,
+        failed: 0,
+        skipped: 1,
+        skipReasons: { "node:sqlite unavailable": 1 },
+        errors: []
+      };
+    }
+    const db = new DatabaseSync(sqlitePath, { readOnly: true });
+    const errors = [];
+    const skipReasons = {};
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    const trackSkip = (reason) => {
+      skipped++;
+      skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+    };
+    try {
+      const sessions = db.prepare(
+        "SELECT id, directory, title, model, time_created, time_updated FROM session ORDER BY time_created ASC"
+      ).all();
+      for (const sessionRow of sessions) {
+        const originalId = this.readString(sessionRow, "id");
+        if (!originalId) {
+          trackSkip("missing session id");
+          continue;
+        }
+        try {
+          const messages = this.readSqliteMessages(db, originalId);
+          if (messages.length === 0) {
+            trackSkip("no user/assistant messages");
+            continue;
+          }
+          const projectPath = this.readString(sessionRow, "directory") ?? process.cwd();
+          const result = await this.writeAutohandSession({
+            projectPath,
+            projectName: path9.basename(projectPath),
+            model: this.extractModel(sessionRow),
+            messages,
+            source: this.name,
+            originalId,
+            createdAt: messages[0].timestamp,
+            closedAt: messages[messages.length - 1].timestamp,
+            summary: this.readString(sessionRow, "title") ?? this.buildSummary(messages),
+            status: "completed"
+          });
+          if (result === null) {
+            trackSkip("already imported");
+          } else {
+            success++;
+          }
+        } catch (err) {
+          failed++;
+          errors.push({
+            category: "sessions",
+            item: originalId,
+            error: err instanceof Error ? err.message : String(err),
+            retriable: true
+          });
+        }
+      }
+    } finally {
+      db.close();
+    }
+    return { success, failed, skipped, skipReasons, errors };
+  }
+  readSqliteMessages(db, sessionId) {
+    const messages = db.prepare(
+      "SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC"
+    ).all(sessionId);
+    const converted = [];
+    for (const messageRow of messages) {
+      const data = this.parseStoredJson(messageRow.data);
+      const role = this.normalizeRole(this.readString(data, "role"));
+      if (!role) continue;
+      const messageId = this.readString(messageRow, "id");
+      if (!messageId) continue;
+      const parts = db.prepare(
+        "SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC, id ASC"
+      ).all(messageId);
+      const content = parts.map((part) => this.extractPartText(this.parseStoredJson(part.data))).filter(Boolean).join("") || this.readString(data, "content") || this.readString(data, "text") || "";
+      if (!content.trim()) continue;
+      converted.push({
+        role,
+        content,
+        timestamp: this.toIsoTimestamp(messageRow.time_created)
+      });
+    }
+    return converted;
+  }
+  async discoverJsonSessionFiles() {
+    const sessionRoot = path9.join(this.dataHome, "storage", "session");
+    if (!await fse9.pathExists(sessionRoot)) return [];
+    const projectDirs = await this.readDir(sessionRoot);
+    const files = [];
+    for (const projectDir of projectDirs.filter((entry) => entry.isDirectory())) {
+      if (projectDir.name === "message" || projectDir.name === "part" || projectDir.name === "info") {
+        continue;
+      }
+      const dir = path9.join(sessionRoot, projectDir.name);
+      const entries = await this.readDir(dir);
+      for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".json"))) {
+        files.push({
+          path: path9.join(dir, entry.name),
+          projectId: projectDir.name,
+          sessionId: path9.basename(entry.name, ".json")
+        });
+      }
+    }
+    return files;
+  }
+  async existingConfigFiles() {
+    const existing = [];
+    for (const candidate of this.globalConfigCandidates()) {
+      if (await fse9.pathExists(candidate.path)) {
+        existing.push(candidate);
+      }
+    }
+    return existing;
+  }
+  globalConfigCandidates() {
+    return [
+      { path: path9.join(this.resolvedHomePath, "opencode.json"), file: "opencode.json" },
+      { path: path9.join(this.resolvedHomePath, "opencode.jsonc"), file: "opencode.jsonc" },
+      { path: path9.join(this.resolvedHomePath, "tui.json"), file: "tui.json" },
+      { path: path9.join(this.resolvedHomePath, "tui.jsonc"), file: "tui.jsonc" },
+      { path: path9.join(this.dataHome, "opencode.json"), file: "legacy-data/opencode.json" },
+      { path: path9.join(this.dataHome, "opencode.jsonc"), file: "legacy-data/opencode.jsonc" },
+      { path: path9.join(os2.homedir(), ".opencode.json"), file: "~/.opencode.json" },
+      { path: path9.join(os2.homedir(), ".opencode.jsonc"), file: "~/.opencode.jsonc" }
+    ];
+  }
+  async discoverSkillDirs() {
+    const skillsDir = path9.join(this.resolvedHomePath, "skills");
+    if (!await fse9.pathExists(skillsDir)) return [];
+    const entries = await this.readDir(skillsDir);
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+      name: entry.name,
+      path: path9.join(skillsDir, entry.name)
+    }));
+  }
+  async collectMcpServers(files) {
+    const combined = {};
+    for (const file of files) {
+      try {
+        const raw = await fse9.readFile(file.path, "utf-8");
+        const parsed = this.parseJsonc(raw);
+        const mcp = parsed ? this.asRecord(parsed.mcp) : {};
+        Object.assign(combined, mcp);
+      } catch {
+      }
+    }
+    return combined;
+  }
+  parseJsonc(content) {
+    try {
+      return this.asRecord(JSON.parse(this.removeTrailingCommas(this.stripJsonComments(content))));
+    } catch {
+      return void 0;
+    }
+  }
+  stripJsonComments(content) {
+    let output = "";
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < content.length; i++) {
+      const char = content[i];
+      const next = content[i + 1];
+      if (inString) {
+        output += char;
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        output += char;
+        continue;
+      }
+      if (char === "/" && next === "/") {
+        while (i < content.length && content[i] !== "\n") i++;
+        output += "\n";
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        i += 2;
+        while (i < content.length && !(content[i] === "*" && content[i + 1] === "/")) i++;
+        i++;
+        continue;
+      }
+      output += char;
+    }
+    return output;
+  }
+  removeTrailingCommas(content) {
+    return content.replace(/,\s*([}\]])/g, "$1");
+  }
+  async readDir(dir) {
+    return await fse9.readdir(dir, { withFileTypes: true });
+  }
+  convertStoredMessage(message) {
+    if (!message.content?.trim()) return null;
+    return {
+      role: message.role,
+      content: message.content,
+      timestamp: message.timestamp
+    };
+  }
+  normalizeRole(role) {
+    if (role === "user" || role === "assistant" || role === "tool" || role === "system") {
+      return role;
+    }
+    return null;
+  }
+  extractPartText(part) {
+    const type = this.readString(part, "type");
+    if (type && !["text", "reasoning"].includes(type)) return "";
+    const text = this.readString(part, "text") ?? this.readString(this.asRecord(part.data), "text");
+    return text ?? "";
+  }
+  extractModel(record) {
+    const direct = this.readString(record, "model");
+    if (direct) return direct;
+    const model = this.parseStoredJson(record.model);
+    const providerId = this.readString(model, "providerID") ?? this.readString(model, "provider_id");
+    const modelId = this.readString(model, "id") ?? this.readString(model, "model");
+    if (providerId && modelId) return `${providerId}/${modelId}`;
+    if (modelId) return modelId;
+    return "opencode";
+  }
+  parseStoredJson(value) {
+    if (typeof value === "string") {
+      try {
+        return this.asRecord(JSON.parse(value));
+      } catch {
+        return {};
+      }
+    }
+    return this.asRecord(value);
+  }
+  toIsoTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const milliseconds = value > 1e10 ? value : value * 1e3;
+      return new Date(milliseconds).toISOString();
+    }
+    if (typeof value === "string" && value.trim()) {
+      const time = Date.parse(value);
+      return Number.isNaN(time) ? (/* @__PURE__ */ new Date()).toISOString() : new Date(time).toISOString();
+    }
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  buildSummary(messages) {
+    const firstUser = messages.find((message) => message.role === "user");
+    if (!firstUser) return "Imported OpenCode session";
+    const text = firstUser.content.trim().slice(0, 100);
+    return text.length < firstUser.content.trim().length ? `${text}...` : text;
+  }
+  readString(record, key) {
+    const obj = this.asRecord(record);
+    const value = obj[key];
+    return typeof value === "string" ? value : void 0;
+  }
+  asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return {};
+  }
+};
+
+// src/import/importers/KimiImporter.ts
+import path10 from "path";
+import fse10 from "fs-extra";
+var KimiImporter = class extends BaseImporter {
+  name = "kimi";
+  displayName = "Kimi CLI";
+  homePath = "~/.kimi";
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse10.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const configPath = path10.join(home, "config.toml");
+    const metadataPath = path10.join(home, "kimi.json");
+    const settingsCount = await this.countExisting([configPath, metadataPath]);
+    if (settingsCount > 0) {
+      available.set("settings", {
+        count: settingsCount,
+        description: "Kimi config.toml and runtime metadata"
+      });
+    }
+    if (await fse10.pathExists(path10.join(home, "mcp.json"))) {
+      available.set("mcp", { count: 1, description: "Kimi MCP server configuration" });
+    }
+    if (await fse10.pathExists(path10.join(home, "AGENTS.md"))) {
+      available.set("memory", { count: 1, description: "Kimi global AGENTS.md instructions" });
+    }
+    const skills = await this.discoverSkillDirs();
+    if (skills.length > 0) {
+      available.set("skills", {
+        count: skills.length,
+        description: `${skills.length} Kimi skill${skills.length !== 1 ? "s" : ""}`
+      });
+    }
+    const sessions = await this.discoverSessionDirs();
+    if (sessions.length > 0) {
+      available.set("sessions", {
+        count: sessions.length,
+        description: `${sessions.length} Kimi session${sessions.length !== 1 ? "s" : ""}`
+      });
+    }
+    if (await fse10.pathExists(configPath)) {
+      try {
+        const config = await fse10.readFile(configPath, "utf-8");
+        const hooks = this.extractTomlArraySections(config, "hooks");
+        if (hooks.length > 0) {
+          available.set("hooks", {
+            count: hooks.length,
+            description: `${hooks.length} Kimi hook${hooks.length !== 1 ? "s" : ""}`
+          });
+        }
+      } catch {
+      }
+    }
+    return { source: this.name, available };
+  }
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "sessions":
+          await this.importSessions(imported, errors, onProgress);
+          break;
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        case "mcp":
+          await this.importMcp(imported, errors, onProgress);
+          break;
+        case "memory":
+          await this.importMemory(imported, errors, onProgress);
+          break;
+        case "skills":
+          await this.importSkills(imported, errors, onProgress);
+          break;
+        case "hooks":
+          await this.importHooks(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  async importSettings(imported, errors, onProgress) {
+    const configPath = path10.join(this.resolvedHomePath, "config.toml");
+    const metadataPath = path10.join(this.resolvedHomePath, "kimi.json");
+    const hasConfig = await fse10.pathExists(configPath);
+    const hasMetadata = await fse10.pathExists(metadataPath);
+    if (!hasConfig && !hasMetadata) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "config.toml / kimi.json",
+      status: "importing"
+    });
+    try {
+      const output = {
+        importedFrom: "kimi",
+        importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (hasConfig) {
+        const raw = await fse10.readFile(configPath, "utf-8");
+        output.configToml = raw;
+        output.parsed = this.parseToml(raw);
+      }
+      if (hasMetadata) {
+        output.metadata = await this.safeReadJson(metadataPath);
+      }
+      await fse10.ensureDir(AUTOHAND_PATHS.config);
+      await fse10.writeJson(path10.join(AUTOHAND_PATHS.config, "imported-kimi-settings.json"), output, {
+        spaces: 2
+      });
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "config.toml / kimi.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "config.toml / kimi.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  async importMcp(imported, errors, onProgress) {
+    const mcpPath = path10.join(this.resolvedHomePath, "mcp.json");
+    if (!await fse10.pathExists(mcpPath)) {
+      imported.set("mcp", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "mcp",
+      current: 1,
+      total: 1,
+      item: "mcp.json",
+      status: "importing"
+    });
+    try {
+      const mcpData = await this.safeReadJson(mcpPath);
+      await fse10.ensureDir(AUTOHAND_PATHS.config);
+      await fse10.writeJson(
+        path10.join(AUTOHAND_PATHS.config, "imported-kimi-mcp.json"),
+        {
+          importedFrom: "kimi",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          mcpServers: this.extractMcpServers(mcpData) ?? mcpData
+        },
+        { spaces: 2 }
+      );
+      imported.set("mcp", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "mcp",
+        current: 1,
+        total: 1,
+        item: "mcp.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("mcp", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "mcp",
+        item: "mcp.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  async importMemory(imported, errors, onProgress) {
+    const agentsPath = path10.join(this.resolvedHomePath, "AGENTS.md");
+    if (!await fse10.pathExists(agentsPath)) {
+      imported.set("memory", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "memory",
+      current: 1,
+      total: 1,
+      item: "AGENTS.md",
+      status: "importing"
+    });
+    try {
+      const destDir = path10.join(AUTOHAND_PATHS.memory, "imported-kimi");
+      await fse10.ensureDir(destDir);
+      await fse10.copy(agentsPath, path10.join(destDir, "AGENTS.md"));
+      imported.set("memory", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "memory",
+        current: 1,
+        total: 1,
+        item: "AGENTS.md",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("memory", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "memory",
+        item: "AGENTS.md",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: true
+      });
+    }
+  }
+  async importSkills(imported, errors, onProgress) {
+    const skills = await this.discoverSkillDirs();
+    if (skills.length === 0) {
+      imported.set("skills", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    const destBase = path10.join(AUTOHAND_PATHS.skills, "imported-kimi");
+    let success = 0;
+    let failed = 0;
+    for (let i = 0; i < skills.length; i++) {
+      const skill = skills[i];
+      onProgress?.({
+        category: "skills",
+        current: i + 1,
+        total: skills.length,
+        item: skill.name,
+        status: "importing"
+      });
+      try {
+        await fse10.ensureDir(destBase);
+        await fse10.copy(skill.path, path10.join(destBase, skill.name));
+        success++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "skills",
+          item: skill.name,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("skills", { success, failed, skipped: 0 });
+  }
+  async importHooks(imported, errors, onProgress) {
+    const configPath = path10.join(this.resolvedHomePath, "config.toml");
+    if (!await fse10.pathExists(configPath)) {
+      imported.set("hooks", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "hooks",
+      current: 1,
+      total: 1,
+      item: "hooks from config.toml",
+      status: "importing"
+    });
+    try {
+      const config = await fse10.readFile(configPath, "utf-8");
+      const hooks = this.extractTomlArraySections(config, "hooks");
+      if (hooks.length === 0) {
+        imported.set("hooks", { success: 0, failed: 0, skipped: 1 });
+        return;
+      }
+      await fse10.ensureDir(AUTOHAND_PATHS.config);
+      await fse10.writeJson(
+        path10.join(AUTOHAND_PATHS.config, "imported-kimi-hooks.json"),
+        {
+          importedFrom: "kimi",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          hooksToml: hooks.join("\n\n")
+        },
+        { spaces: 2 }
+      );
+      imported.set("hooks", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "hooks",
+        current: 1,
+        total: 1,
+        item: "hooks from config.toml",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("hooks", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "hooks",
+        item: "hooks from config.toml",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  async importSessions(imported, errors, onProgress) {
+    const sessions = await this.discoverSessionDirs();
+    if (sessions.length === 0) {
+      imported.set("sessions", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    const skipReasons = {};
+    const trackSkip = (reason) => {
+      skipped++;
+      skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+    };
+    for (let i = 0; i < sessions.length; i++) {
+      const session = sessions[i];
+      onProgress?.({
+        category: "sessions",
+        current: i + 1,
+        total: sessions.length,
+        item: session.sessionId,
+        status: "importing"
+      });
+      try {
+        const importedSession = await this.readKimiSession(session);
+        if (!importedSession || importedSession.messages.length === 0) {
+          trackSkip("no user/assistant messages");
+          continue;
+        }
+        const result = await this.writeAutohandSession({
+          projectPath: importedSession.projectPath,
+          projectName: path10.basename(importedSession.projectPath),
+          model: importedSession.model,
+          messages: importedSession.messages,
+          source: this.name,
+          originalId: session.sessionId,
+          createdAt: importedSession.messages[0].timestamp,
+          closedAt: importedSession.messages[importedSession.messages.length - 1].timestamp,
+          summary: importedSession.summary,
+          status: "completed"
+        });
+        if (result === null) {
+          trackSkip("already imported");
+        } else {
+          success++;
+        }
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "sessions",
+          item: session.sessionId,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("sessions", {
+      success,
+      failed,
+      skipped,
+      ...Object.keys(skipReasons).length > 0 ? { skipReasons } : {}
+    });
+  }
+  async readKimiSession(session) {
+    const contextPath = path10.join(session.dir, "context.jsonl");
+    const records = await this.readJsonlFile(contextPath);
+    const state = await this.readOptionalJson(path10.join(session.dir, "state.json"));
+    const config = await this.readOptionalConfig();
+    const messages = [];
+    for (const record of records) {
+      const role = this.normalizeRole(this.readString(record, "role"));
+      if (!role) continue;
+      const content = this.extractMessageContent(record.content ?? record.message);
+      if (!content.trim()) continue;
+      messages.push({
+        role,
+        content,
+        timestamp: this.toIsoTimestamp(record.timestamp ?? record.time ?? record.created_at)
+      });
+    }
+    if (messages.length === 0) return null;
+    const projectPath = this.readString(state, "cwd") ?? this.readString(state, "work_dir") ?? this.readString(state, "workDir") ?? this.readString(state, "directory") ?? this.readString(state, "projectPath") ?? process.cwd();
+    const title = this.readString(state, "title");
+    const model = this.readString(state, "model") ?? this.readString(config, "default_model") ?? "kimi";
+    return {
+      projectPath,
+      model,
+      summary: title?.trim() || this.buildSummary(messages),
+      messages
+    };
+  }
+  async discoverSessionDirs() {
+    const sessionsDir = path10.join(this.resolvedHomePath, "sessions");
+    if (!await fse10.pathExists(sessionsDir)) return [];
+    const workDirs = await this.readDir(sessionsDir);
+    const sessions = [];
+    for (const workDir of workDirs.filter((entry) => entry.isDirectory())) {
+      const workDirPath = path10.join(sessionsDir, workDir.name);
+      const sessionDirs = await this.readDir(workDirPath);
+      for (const sessionDir of sessionDirs.filter((entry) => entry.isDirectory())) {
+        const dir = path10.join(workDirPath, sessionDir.name);
+        if (await fse10.pathExists(path10.join(dir, "context.jsonl"))) {
+          sessions.push({ dir, workDirHash: workDir.name, sessionId: sessionDir.name });
+        }
+      }
+    }
+    return sessions;
+  }
+  async discoverSkillDirs() {
+    const skillsDir = path10.join(this.resolvedHomePath, "skills");
+    if (!await fse10.pathExists(skillsDir)) return [];
+    const entries = await this.readDir(skillsDir);
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+      name: entry.name,
+      path: path10.join(skillsDir, entry.name)
+    }));
+  }
+  async readDir(dir) {
+    return await fse10.readdir(dir, { withFileTypes: true });
+  }
+  async countExisting(paths) {
+    let count = 0;
+    for (const candidate of paths) {
+      if (await fse10.pathExists(candidate)) count++;
+    }
+    return count;
+  }
+  async readOptionalJson(filePath) {
+    if (!await fse10.pathExists(filePath)) return {};
+    try {
+      const json = await fse10.readJson(filePath);
+      return this.asRecord(json);
+    } catch {
+      return {};
+    }
+  }
+  async readOptionalConfig() {
+    const configPath = path10.join(this.resolvedHomePath, "config.toml");
+    if (!await fse10.pathExists(configPath)) return {};
+    try {
+      const raw = await fse10.readFile(configPath, "utf-8");
+      return this.parseToml(raw);
+    } catch {
+      return {};
+    }
+  }
+  parseToml(content) {
+    const result = {};
+    let currentSection = "";
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#") || line.startsWith("[[")) continue;
+      const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+      if (sectionMatch) {
+        currentSection = sectionMatch[1];
+        continue;
+      }
+      const kvMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*=\s*(.+)$/);
+      if (!kvMatch) continue;
+      const key = currentSection ? `${currentSection}.${kvMatch[1]}` : kvMatch[1];
+      let value = kvMatch[2].trim();
+      const inlineComment = value.indexOf(" #");
+      if (inlineComment > 0) {
+        value = value.slice(0, inlineComment).trim();
+      }
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        result[key] = value.slice(1, -1);
+      } else if (value === "true") {
+        result[key] = true;
+      } else if (value === "false") {
+        result[key] = false;
+      } else if (/^-?\d+(\.\d+)?$/.test(value)) {
+        result[key] = Number(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  extractTomlArraySections(content, sectionName) {
+    const header = `[[${sectionName}]]`;
+    const blocks = [];
+    let current = null;
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (line === header) {
+        if (current && current.length > 0) blocks.push(current.join("\n").trim());
+        current = [rawLine];
+        continue;
+      }
+      if (current) {
+        if (line.startsWith("[[") && line !== header) {
+          blocks.push(current.join("\n").trim());
+          current = null;
+        } else {
+          current.push(rawLine);
+        }
+      }
+    }
+    if (current && current.length > 0) blocks.push(current.join("\n").trim());
+    return blocks.filter((block) => block.length > 0);
+  }
+  extractMcpServers(data) {
+    const direct = data.mcpServers;
+    if (direct && typeof direct === "object" && !Array.isArray(direct)) {
+      return direct;
+    }
+    return void 0;
+  }
+  normalizeRole(role) {
+    if (!role || role.startsWith("_")) return null;
+    if (role === "model") return "assistant";
+    if (role === "user" || role === "assistant" || role === "tool" || role === "system") {
+      return role;
+    }
+    return null;
+  }
+  extractMessageContent(content) {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map((item) => this.extractMessageContent(item)).filter(Boolean).join("");
+    }
+    const record = this.asRecord(content);
+    if (record) {
+      const text = this.readString(record, "text") ?? this.readString(record, "content");
+      if (text) return text;
+    }
+    return "";
+  }
+  toIsoTimestamp(value) {
+    if (typeof value === "string" && value.trim()) {
+      const time = Date.parse(value);
+      return Number.isNaN(time) ? (/* @__PURE__ */ new Date()).toISOString() : new Date(time).toISOString();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const milliseconds = value > 1e10 ? value : value * 1e3;
+      return new Date(milliseconds).toISOString();
+    }
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  buildSummary(messages) {
+    const firstUser = messages.find((message) => message.role === "user");
+    if (!firstUser) return "Imported Kimi session";
+    const text = firstUser.content.trim().slice(0, 100);
+    return text.length < firstUser.content.trim().length ? `${text}...` : text;
+  }
+  readString(record, key) {
+    const obj = this.asRecord(record);
+    const value = obj?.[key];
+    return typeof value === "string" ? value : void 0;
+  }
+  asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return {};
+  }
+};
+
 // src/import/registry.ts
 var ImporterRegistry = class {
   importers;
@@ -2049,6 +3385,8 @@ var ImporterRegistry = class {
     this.register(new ClineImporter());
     this.register(new ContinueImporter());
     this.register(new AugmentImporter());
+    this.register(new OpencodeImporter());
+    this.register(new KimiImporter());
   }
   /**
    * Register an importer instance by its source name.