autohand-cli 0.7.14 → 0.8.0

package/dist/registry-WQLWHOLY.js

@@ -0,0 +1,1828 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-EGFT4PGW.js";
+import "./chunk-JSBRDJBE.js";
+
+// src/import/importers/ClaudeImporter.ts
+import path2 from "path";
+import fse2 from "fs-extra";
+
+// src/import/importers/BaseImporter.ts
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+import fse from "fs-extra";
+var BaseImporter = class {
+  // ---------------------------------------------------------------
+  // Resolved home path
+  // ---------------------------------------------------------------
+  /**
+   * Expands a `~/` prefix to the user's home directory.
+   * Returns absolute paths unchanged.
+   */
+  get resolvedHomePath() {
+    if (this.homePath.startsWith("~/") || this.homePath === "~") {
+      return path.join(os.homedir(), this.homePath.slice(2));
+    }
+    return this.homePath;
+  }
+  // ---------------------------------------------------------------
+  // Detection
+  // ---------------------------------------------------------------
+  /**
+   * Checks whether this agent's data directory exists on disk.
+   */
+  async detect() {
+    return fse.pathExists(this.resolvedHomePath);
+  }
+  // ---------------------------------------------------------------
+  // JSONL reader
+  // ---------------------------------------------------------------
+  /**
+   * Reads a JSONL file and returns an array of parsed records.
+   * Blank lines and malformed JSON lines are silently skipped.
+   */
+  async readJsonlFile(filePath) {
+    const content = await fse.readFile(filePath, "utf-8");
+    const records = [];
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        records.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return records;
+  }
+  // ---------------------------------------------------------------
+  // Retry with exponential backoff
+  // ---------------------------------------------------------------
+  /**
+   * Retries `fn` up to `maxRetries` times with exponential backoff.
+   * Throws the last error if all retries are exhausted.
+   */
+  async withRetry(fn, maxRetries = 3, baseDelay = 1e3) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries - 1) {
+          await this.delay(baseDelay * Math.pow(2, attempt));
+        }
+      }
+    }
+    throw lastError;
+  }
+  // ---------------------------------------------------------------
+  // Session writing
+  // ---------------------------------------------------------------
+  /**
+   * Creates a new Autohand session directory with metadata and conversation data.
+   * Returns the generated session ID, or `null` if the session was already imported
+   * (deduplication by source + originalId).
+   */
+  async writeAutohandSession(opts) {
+    if (await this.isAlreadyImported(opts.source, opts.originalId)) {
+      return null;
+    }
+    const timestamp = Date.now();
+    const uuid = crypto.randomUUID();
+    const sessionId = `${uuid}-${timestamp}`;
+    const sessionDir = path.join(AUTOHAND_PATHS.sessions, sessionId);
+    await fse.ensureDir(sessionDir);
+    const metadata = {
+      sessionId,
+      createdAt: opts.createdAt,
+      lastActiveAt: opts.closedAt ?? opts.createdAt,
+      closedAt: opts.closedAt,
+      projectPath: opts.projectPath,
+      projectName: opts.projectName,
+      model: opts.model,
+      messageCount: opts.messages.length,
+      summary: opts.summary,
+      status: opts.status ?? "completed",
+      importedFrom: {
+        source: opts.source,
+        originalId: opts.originalId,
+        importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    await fse.writeJson(path.join(sessionDir, "metadata.json"), metadata, { spaces: 2 });
+    const jsonl = opts.messages.map((msg) => JSON.stringify(msg)).join("\n") + "\n";
+    await fse.writeFile(path.join(sessionDir, "conversation.jsonl"), jsonl, "utf-8");
+    await this.updateSessionIndex(metadata);
+    return sessionId;
+  }
+  /**
+   * Checks whether a session from `source` with `originalId` was already imported.
+   * Uses the session index for O(n) lookup with `importedFrom` field.
+   */
+  async isAlreadyImported(source, originalId) {
+    const indexPath = path.join(AUTOHAND_PATHS.sessions, "index.json");
+    if (!await fse.pathExists(indexPath)) {
+      return false;
+    }
+    try {
+      const loaded = await fse.readJson(indexPath);
+      if (!loaded || !Array.isArray(loaded.sessions)) return false;
+      return loaded.sessions.some(
+        (s) => s.importedFrom?.source === source && s.importedFrom?.originalId === originalId
+      );
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------
+  // Session index management
+  // ---------------------------------------------------------------
+  /**
+   * Adds a session entry to `~/.autohand/sessions/index.json`.
+   * Creates the file if it does not exist.
+   */
+  async updateSessionIndex(metadata) {
+    const indexPath = path.join(AUTOHAND_PATHS.sessions, "index.json");
+    let index = { sessions: [], byProject: {} };
+    if (await fse.pathExists(indexPath)) {
+      try {
+        const loaded = await fse.readJson(indexPath);
+        if (loaded && typeof loaded === "object" && Array.isArray(loaded.sessions) && loaded.byProject && typeof loaded.byProject === "object") {
+          index = loaded;
+        }
+      } catch {
+      }
+    }
+    const entry = {
+      id: metadata.sessionId,
+      projectPath: metadata.projectPath,
+      createdAt: metadata.createdAt,
+      summary: metadata.summary
+    };
+    if (metadata.importedFrom) {
+      entry.importedFrom = {
+        source: metadata.importedFrom.source,
+        originalId: metadata.importedFrom.originalId
+      };
+    }
+    index.sessions.push(entry);
+    if (!index.byProject[metadata.projectPath]) {
+      index.byProject[metadata.projectPath] = [];
+    }
+    index.byProject[metadata.projectPath].push(metadata.sessionId);
+    await fse.ensureDir(AUTOHAND_PATHS.sessions);
+    await fse.writeJson(indexPath, index, { spaces: 2 });
+  }
+  // ---------------------------------------------------------------
+  // Utility
+  // ---------------------------------------------------------------
+  /**
+   * Safely read and parse a JSON file with pre-validation.
+   * Returns the parsed data, or throws with a descriptive error message.
+   * Handles empty files, corrupted JSON, and non-object content gracefully.
+   */
+  async safeReadJson(filePath) {
+    const content = await fse.readFile(filePath, "utf-8");
+    if (!content.trim()) {
+      throw new Error(`File is empty: ${path.basename(filePath)}`);
+    }
+    try {
+      const parsed = JSON.parse(content);
+      return parsed;
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON in ${path.basename(filePath)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  /**
+   * Simple promise-based delay.
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/import/importers/ClaudeImporter.ts
+var ClaudeImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "claude";
+    this.displayName = "Claude Code";
+    this.homePath = "~/.claude";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse2.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const projectsDir = path2.join(home, "projects");
+    let sessionCount = 0;
+    let memoryCount = 0;
+    if (await fse2.pathExists(projectsDir)) {
+      const entries = await fse2.readdir(projectsDir, { withFileTypes: true });
+      const projectDirs = entries.filter((e) => e.isDirectory());
+      for (const dir of projectDirs) {
+        const projectDir = path2.join(projectsDir, dir.name);
+        const projectEntries = await fse2.readdir(projectDir, { withFileTypes: true });
+        const jsonlFiles = projectEntries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+        sessionCount += jsonlFiles.length;
+        const hasMemoryDir = await fse2.pathExists(path2.join(projectDir, "memory"));
+        const hasClaudeMd = await fse2.pathExists(path2.join(projectDir, "CLAUDE.md"));
+        if (hasMemoryDir || hasClaudeMd) {
+          memoryCount++;
+        }
+      }
+    }
+    if (sessionCount > 0) {
+      available.set("sessions", {
+        count: sessionCount,
+        description: `${sessionCount} session file${sessionCount !== 1 ? "s" : ""} across project directories`
+      });
+    }
+    const settingsPath = path2.join(home, "settings.json");
+    if (await fse2.pathExists(settingsPath)) {
+      available.set("settings", { count: 1, description: "Claude Code settings.json" });
+    }
+    const skillsDir = path2.join(home, "skills");
+    if (await fse2.pathExists(skillsDir)) {
+      const skillEntries = await fse2.readdir(skillsDir, { withFileTypes: true });
+      const skillFiles = skillEntries.filter((e) => e.isFile());
+      if (skillFiles.length > 0) {
+        available.set("skills", {
+          count: skillFiles.length,
+          description: `${skillFiles.length} skill file${skillFiles.length !== 1 ? "s" : ""}`
+        });
+      }
+    }
+    if (memoryCount > 0) {
+      available.set("memory", {
+        count: memoryCount,
+        description: `${memoryCount} project${memoryCount !== 1 ? "s" : ""} with memory data`
+      });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  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 "skills":
+          await this.importSkills(imported, errors, onProgress);
+          break;
+        case "memory":
+          await this.importMemory(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Sessions
+  // ---------------------------------------------------------------
+  async importSessions(imported, errors, onProgress) {
+    const home = this.resolvedHomePath;
+    const projectsDir = path2.join(home, "projects");
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    const skipReasons = {};
+    const trackSkip = (reason) => {
+      skipped++;
+      skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+    };
+    if (!await fse2.pathExists(projectsDir)) {
+      imported.set("sessions", { success: 0, failed: 0, skipped: 0 });
+      return;
+    }
+    const projectEntries = await fse2.readdir(projectsDir, { withFileTypes: true });
+    const projectDirs = projectEntries.filter((e) => e.isDirectory());
+    const allSessionFiles = [];
+    for (const dir of projectDirs) {
+      const projectDir = path2.join(projectsDir, dir.name);
+      const entries = await fse2.readdir(projectDir, { withFileTypes: true });
+      const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+      for (const f of jsonlFiles) {
+        allSessionFiles.push({
+          filePath: path2.join(projectDir, f.name),
+          projectDirName: dir.name
+        });
+      }
+    }
+    const total = allSessionFiles.length;
+    for (let i = 0; i < allSessionFiles.length; i++) {
+      const { filePath, projectDirName } = allSessionFiles[i];
+      onProgress?.({
+        category: "sessions",
+        current: i + 1,
+        total,
+        item: path2.basename(filePath),
+        status: "importing"
+      });
+      try {
+        const fileContent = await fse2.readFile(filePath, "utf-8");
+        if (!fileContent.trim()) {
+          trackSkip("empty file");
+          continue;
+        }
+        const records = await this.readJsonlFile(filePath);
+        if (records.length === 0) {
+          trackSkip("no valid JSON records");
+          continue;
+        }
+        const events = records;
+        const relevantEvents = events.filter(
+          (e) => (e.type === "user" || e.type === "assistant") && !e.isMeta && e.message
+        );
+        if (relevantEvents.length === 0) {
+          trackSkip("no user/assistant messages");
+          continue;
+        }
+        const sessionGroups = /* @__PURE__ */ new Map();
+        for (const event of relevantEvents) {
+          const sid = event.sessionId ?? "unknown";
+          if (!sessionGroups.has(sid)) {
+            sessionGroups.set(sid, []);
+          }
+          sessionGroups.get(sid).push(event);
+        }
+        for (const [sessionId, sessionEvents] of sessionGroups) {
+          const messages = sessionEvents.map((e) => ({
+            role: e.message.role,
+            content: this.extractContent(e.message.content),
+            timestamp: e.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          const firstEvent = sessionEvents[0];
+          const cwd = firstEvent.cwd ?? this.projectDirNameToPath(projectDirName);
+          const model = this.extractModel(sessionEvents) ?? "unknown";
+          const projectName = path2.basename(cwd);
+          const result = await this.writeAutohandSession({
+            projectPath: cwd,
+            projectName,
+            model,
+            messages,
+            source: this.name,
+            originalId: sessionId,
+            createdAt: messages[0].timestamp,
+            closedAt: messages[messages.length - 1].timestamp,
+            summary: this.buildSummary(messages),
+            status: "completed"
+          });
+          if (result === null) {
+            trackSkip("already imported");
+          } else {
+            success++;
+          }
+        }
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "sessions",
+          item: path2.basename(filePath),
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("sessions", {
+      success,
+      failed,
+      skipped,
+      ...Object.keys(skipReasons).length > 0 ? { skipReasons } : {}
+    });
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const settingsPath = path2.join(this.resolvedHomePath, "settings.json");
+    if (!await fse2.pathExists(settingsPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "settings.json",
+      status: "importing"
+    });
+    try {
+      const settings = await this.safeReadJson(settingsPath);
+      const permissions = settings.permissions;
+      if (permissions?.allow) {
+        const configDir = AUTOHAND_PATHS.config;
+        await fse2.ensureDir(configDir);
+        const importedSettingsPath = path2.join(configDir, "imported-claude-settings.json");
+        await fse2.writeJson(importedSettingsPath, {
+          importedFrom: "claude",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          permissions: permissions.allow,
+          raw: settings
+        }, { spaces: 2 });
+      }
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "settings.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "settings.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Skills
+  // ---------------------------------------------------------------
+  async importSkills(imported, errors, onProgress) {
+    const skillsDir = path2.join(this.resolvedHomePath, "skills");
+    if (!await fse2.pathExists(skillsDir)) {
+      imported.set("skills", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    const entries = await fse2.readdir(skillsDir, { withFileTypes: true });
+    const skillFiles = entries.filter((e) => e.isFile());
+    let success = 0;
+    let failed = 0;
+    const total = skillFiles.length;
+    const destDir = path2.join(AUTOHAND_PATHS.skills, "imported-claude");
+    for (let i = 0; i < skillFiles.length; i++) {
+      const file = skillFiles[i];
+      const src = path2.join(skillsDir, file.name);
+      const dest = path2.join(destDir, file.name);
+      onProgress?.({
+        category: "skills",
+        current: i + 1,
+        total,
+        item: file.name,
+        status: "importing"
+      });
+      try {
+        await fse2.ensureDir(destDir);
+        await fse2.copy(src, dest);
+        success++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "skills",
+          item: file.name,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("skills", { success, failed, skipped: 0 });
+  }
+  // ---------------------------------------------------------------
+  // Memory
+  // ---------------------------------------------------------------
+  async importMemory(imported, errors, onProgress) {
+    const projectsDir = path2.join(this.resolvedHomePath, "projects");
+    let success = 0;
+    let failed = 0;
+    if (!await fse2.pathExists(projectsDir)) {
+      imported.set("memory", { success: 0, failed: 0, skipped: 0 });
+      return;
+    }
+    const entries = await fse2.readdir(projectsDir, { withFileTypes: true });
+    const projectDirs = entries.filter((e) => e.isDirectory());
+    const total = projectDirs.length;
+    for (let i = 0; i < projectDirs.length; i++) {
+      const dir = projectDirs[i];
+      const projectDir = path2.join(projectsDir, dir.name);
+      const hasMemoryDir = await fse2.pathExists(path2.join(projectDir, "memory"));
+      const hasClaudeMd = await fse2.pathExists(path2.join(projectDir, "CLAUDE.md"));
+      if (!hasMemoryDir && !hasClaudeMd) {
+        continue;
+      }
+      onProgress?.({
+        category: "memory",
+        current: i + 1,
+        total,
+        item: dir.name,
+        status: "importing"
+      });
+      try {
+        const projectHash = dir.name.replace(/[^a-zA-Z0-9-]/g, "_");
+        const destDir = path2.join(AUTOHAND_PATHS.projects, projectHash, "imported-claude");
+        await fse2.ensureDir(destDir);
+        if (hasMemoryDir) {
+          await fse2.copy(path2.join(projectDir, "memory"), path2.join(destDir, "memory"));
+        }
+        if (hasClaudeMd) {
+          await fse2.copy(path2.join(projectDir, "CLAUDE.md"), path2.join(destDir, "CLAUDE.md"));
+        }
+        success++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "memory",
+          item: dir.name,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("memory", { success, failed, skipped: 0 });
+  }
+  // ---------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------
+  /**
+   * Extract text content from a Claude message content field.
+   * Content can be a string or an array of content blocks.
+   */
+  extractContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.filter((block) => block.type === "text" && block.text).map((block) => block.text).join("");
+    }
+    return "";
+  }
+  /**
+   * Extract the model name from session events. Takes the first found model.
+   */
+  extractModel(events) {
+    for (const event of events) {
+      if (event.message?.model) {
+        return event.message.model;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Convert a project directory name (e.g. "-Users-me-project") to a path.
+   */
+  projectDirNameToPath(dirName) {
+    return "/" + dirName.replace(/^-/, "").replace(/-/g, "/");
+  }
+  /**
+   * Build a brief summary from the first real user message.
+   * Skips system-injected context (XML tags, CLAUDE.md, etc.)
+   */
+  buildSummary(messages) {
+    for (const msg of messages) {
+      if (msg.role !== "user") continue;
+      const cleaned = this.stripSystemContent(msg.content);
+      if (cleaned.length > 0) {
+        const text = cleaned.slice(0, 100);
+        return text.length < cleaned.length ? `${text}...` : text;
+      }
+    }
+    return "Imported Claude session";
+  }
+  /**
+   * Strip system-injected XML tags and their content from a message,
+   * returning only the actual user text.
+   */
+  stripSystemContent(text) {
+    let cleaned = text;
+    const systemTags = [
+      "local-command-caveat",
+      "system-reminder",
+      "user_instructions",
+      "environment_context",
+      "context",
+      "automatic_reminders",
+      "user_request",
+      "bash-input",
+      "bash-stdout",
+      "bash-stderr"
+    ];
+    for (const tag of systemTags) {
+      const pattern = new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`, "g");
+      cleaned = cleaned.replace(pattern, "");
+    }
+    return cleaned.trim();
+  }
+};
+
+// src/import/importers/CodexImporter.ts
+import path3 from "path";
+import fse3 from "fs-extra";
+var CodexImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "codex";
+    this.displayName = "OpenAI Codex";
+    this.homePath = "~/.codex";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse3.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const sessionsDir = path3.join(home, "sessions");
+    if (await fse3.pathExists(sessionsDir)) {
+      const sessionFiles = await this.walkJsonlFiles(sessionsDir);
+      if (sessionFiles.length > 0) {
+        available.set("sessions", {
+          count: sessionFiles.length,
+          description: `${sessionFiles.length} session file${sessionFiles.length !== 1 ? "s" : ""}`
+        });
+      }
+    }
+    if (await fse3.pathExists(path3.join(home, "config.toml"))) {
+      available.set("settings", { count: 1, description: "Codex config.toml" });
+    }
+    const skillsDir = path3.join(home, "skills");
+    if (await fse3.pathExists(skillsDir)) {
+      const skillEntries = await fse3.readdir(skillsDir, { withFileTypes: true });
+      const skillFiles = skillEntries.filter((e) => e.isFile());
+      if (skillFiles.length > 0) {
+        available.set("skills", {
+          count: skillFiles.length,
+          description: `${skillFiles.length} skill file${skillFiles.length !== 1 ? "s" : ""}`
+        });
+      }
+    }
+    const rulesDir = path3.join(home, "rules");
+    if (await fse3.pathExists(rulesDir)) {
+      const ruleEntries = await fse3.readdir(rulesDir, { withFileTypes: true });
+      const ruleFiles = ruleEntries.filter((e) => e.isFile());
+      if (ruleFiles.length > 0) {
+        available.set("memory", {
+          count: ruleFiles.length,
+          description: `${ruleFiles.length} rule file${ruleFiles.length !== 1 ? "s" : ""}`
+        });
+      }
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  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 "skills":
+          await this.importSkills(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Sessions
+  // ---------------------------------------------------------------
+  async importSessions(imported, errors, onProgress) {
+    const sessionsDir = path3.join(this.resolvedHomePath, "sessions");
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    const skipReasons = {};
+    const trackSkip = (reason) => {
+      skipped++;
+      skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+    };
+    if (!await fse3.pathExists(sessionsDir)) {
+      imported.set("sessions", { success: 0, failed: 0, skipped: 0 });
+      return;
+    }
+    const sessionFiles = await this.walkJsonlFiles(sessionsDir);
+    const total = sessionFiles.length;
+    for (let i = 0; i < sessionFiles.length; i++) {
+      const filePath = sessionFiles[i];
+      onProgress?.({
+        category: "sessions",
+        current: i + 1,
+        total,
+        item: path3.basename(filePath),
+        status: "importing"
+      });
+      try {
+        const fileContent = await fse3.readFile(filePath, "utf-8");
+        if (!fileContent.trim()) {
+          trackSkip("empty file");
+          continue;
+        }
+        const records = await this.readJsonlFile(filePath);
+        if (records.length === 0) {
+          trackSkip("no valid JSON records");
+          continue;
+        }
+        const events = records;
+        const metaEvent = events.find((e) => e.type === "session_meta");
+        const sessionId = metaEvent?.payload?.id ?? path3.basename(filePath, ".jsonl");
+        const cwd = metaEvent?.payload?.cwd ?? "/unknown";
+        const messages = [];
+        for (const event of events) {
+          if (event.type === "response_item") {
+            const payload = event.payload;
+            if (payload.type === "message" && payload.role && payload.content) {
+              const text = payload.content.filter((c) => (c.type === "input_text" || c.type === "output_text") && c.text).map((c) => c.text).join("");
+              if (text && !this.isSystemMessage(text)) {
+                messages.push({
+                  role: payload.role,
+                  content: text,
+                  timestamp: event.timestamp
+                });
+              }
+            }
+          } else if (event.type === "event_msg") {
+            const payload = event.payload;
+            if (payload.type === "agent_message" && payload.message) {
+              messages.push({
+                role: "assistant",
+                content: payload.message,
+                timestamp: event.timestamp
+              });
+            }
+          }
+        }
+        if (messages.length === 0) {
+          trackSkip("no user messages (only system content)");
+          continue;
+        }
+        const projectName = path3.basename(cwd);
+        const result = await this.writeAutohandSession({
+          projectPath: cwd,
+          projectName,
+          model: "codex",
+          messages,
+          source: this.name,
+          originalId: sessionId,
+          createdAt: messages[0].timestamp,
+          closedAt: messages[messages.length - 1].timestamp,
+          summary: this.buildSummary(messages),
+          status: "completed"
+        });
+        if (result === null) {
+          trackSkip("already imported");
+        } else {
+          success++;
+        }
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "sessions",
+          item: path3.basename(filePath),
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("sessions", {
+      success,
+      failed,
+      skipped,
+      ...Object.keys(skipReasons).length > 0 ? { skipReasons } : {}
+    });
+  }
+  // ---------------------------------------------------------------
+  // Settings (TOML)
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const configPath = path3.join(this.resolvedHomePath, "config.toml");
+    if (!await fse3.pathExists(configPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "config.toml",
+      status: "importing"
+    });
+    try {
+      const tomlContent = await fse3.readFile(configPath, "utf-8");
+      const parsed = this.parseToml(tomlContent);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse3.ensureDir(configDir);
+      await fse3.writeJson(
+        path3.join(configDir, "imported-codex-settings.json"),
+        {
+          importedFrom: "codex",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          parsed,
+          raw: tomlContent
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "config.toml",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "config.toml",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Skills
+  // ---------------------------------------------------------------
+  async importSkills(imported, errors, onProgress) {
+    const skillsDir = path3.join(this.resolvedHomePath, "skills");
+    if (!await fse3.pathExists(skillsDir)) {
+      imported.set("skills", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    const entries = await fse3.readdir(skillsDir, { withFileTypes: true });
+    const skillFiles = entries.filter((e) => e.isFile());
+    let success = 0;
+    let failed = 0;
+    const total = skillFiles.length;
+    const destDir = path3.join(AUTOHAND_PATHS.skills, "imported-codex");
+    for (let i = 0; i < skillFiles.length; i++) {
+      const file = skillFiles[i];
+      const src = path3.join(skillsDir, file.name);
+      const dest = path3.join(destDir, file.name);
+      onProgress?.({
+        category: "skills",
+        current: i + 1,
+        total,
+        item: file.name,
+        status: "importing"
+      });
+      try {
+        await fse3.ensureDir(destDir);
+        await fse3.copy(src, dest);
+        success++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          category: "skills",
+          item: file.name,
+          error: err instanceof Error ? err.message : String(err),
+          retriable: true
+        });
+      }
+    }
+    imported.set("skills", { success, failed, skipped: 0 });
+  }
+  // ---------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------
+  /**
+   * Recursively walk a directory tree and collect all .jsonl file paths.
+   */
+  async walkJsonlFiles(dir) {
+    const results = [];
+    const entries = await fse3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await this.walkJsonlFiles(fullPath);
+        results.push(...nested);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+  /**
+   * Simple TOML parser. Handles:
+   * - `key = "value"` (quoted strings)
+   * - `key = value` (unquoted – numbers, booleans, bare strings)
+   * - `[section]` and `[section.subsection]` headers
+   * - `# comments`
+   * - blank lines
+   *
+   * Returns a flat object with dotted keys for sections
+   * (e.g. `{ "section.key": "value" }`).
+   */
+  parseToml(content) {
+    const result = {};
+    let currentSection = "";
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line || 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;
+  }
+  /**
+   * Detect system-injected context messages that should not be imported.
+   * These are Codex CLI-generated system prompts, environment info, etc.
+   */
+  isSystemMessage(text) {
+    const trimmed = text.trimStart();
+    return trimmed.startsWith("<user_instructions>") || trimmed.startsWith("<environment_context>") || trimmed.startsWith("<user_request>") || trimmed.startsWith("<automatic_reminders>") || trimmed.startsWith("<system-reminder>") || trimmed.startsWith("<context>") || trimmed.startsWith("# Agents Guidance\n");
+  }
+  /**
+   * Build a brief summary from the first real user message.
+   */
+  buildSummary(messages) {
+    const firstUser = messages.find((m) => m.role === "user");
+    if (!firstUser) return "Imported Codex session";
+    const text = firstUser.content.trim().slice(0, 100);
+    return text.length < firstUser.content.trim().length ? `${text}...` : text;
+  }
+};
+
+// src/import/importers/GeminiImporter.ts
+import path4 from "path";
+import fse4 from "fs-extra";
+var GeminiImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "gemini";
+    this.displayName = "Google Gemini";
+    this.homePath = "~/.gemini";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse4.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const settingsPath = path4.join(home, "settings.json");
+    const hasSettings = await fse4.pathExists(settingsPath);
+    if (hasSettings) {
+      available.set("settings", { count: 1, description: "Gemini settings.json" });
+      try {
+        const settings = await this.safeReadJson(settingsPath);
+        const hooks = settings.hooks;
+        if (hooks) {
+          const hookSections = Object.keys(hooks).filter(
+            (k) => Array.isArray(hooks[k]) && hooks[k].length > 0
+          );
+          if (hookSections.length > 0) {
+            available.set("hooks", {
+              count: hookSections.length,
+              description: `${hookSections.length} hook section${hookSections.length !== 1 ? "s" : ""} (${hookSections.join(", ")})`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    const geminiMdPath = path4.join(home, "GEMINI.md");
+    if (await fse4.pathExists(geminiMdPath)) {
+      available.set("memory", { count: 1, description: "GEMINI.md project memory" });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        case "hooks":
+          await this.importHooks(imported, errors, onProgress);
+          break;
+        case "memory":
+          await this.importMemory(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const settingsPath = path4.join(this.resolvedHomePath, "settings.json");
+    if (!await fse4.pathExists(settingsPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "settings.json",
+      status: "importing"
+    });
+    try {
+      const settings = await this.safeReadJson(settingsPath);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse4.ensureDir(configDir);
+      await fse4.writeJson(
+        path4.join(configDir, "imported-gemini-settings.json"),
+        {
+          importedFrom: "gemini",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: settings
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "settings.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "settings.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Hooks
+  // ---------------------------------------------------------------
+  async importHooks(imported, errors, onProgress) {
+    const settingsPath = path4.join(this.resolvedHomePath, "settings.json");
+    if (!await fse4.pathExists(settingsPath)) {
+      imported.set("hooks", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "hooks",
+      current: 1,
+      total: 1,
+      item: "hooks from settings.json",
+      status: "importing"
+    });
+    try {
+      const settings = await this.safeReadJson(settingsPath);
+      const hooks = settings.hooks;
+      if (!hooks || Object.keys(hooks).length === 0) {
+        imported.set("hooks", { success: 0, failed: 0, skipped: 1 });
+        return;
+      }
+      const configDir = AUTOHAND_PATHS.config;
+      await fse4.ensureDir(configDir);
+      await fse4.writeJson(
+        path4.join(configDir, "imported-gemini-hooks.json"),
+        {
+          importedFrom: "gemini",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          hooks
+        },
+        { spaces: 2 }
+      );
+      imported.set("hooks", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "hooks",
+        current: 1,
+        total: 1,
+        item: "hooks from settings.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("hooks", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "hooks",
+        item: "hooks from settings.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Memory
+  // ---------------------------------------------------------------
+  async importMemory(imported, errors, onProgress) {
+    const geminiMdPath = path4.join(this.resolvedHomePath, "GEMINI.md");
+    if (!await fse4.pathExists(geminiMdPath)) {
+      imported.set("memory", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "memory",
+      current: 1,
+      total: 1,
+      item: "GEMINI.md",
+      status: "importing"
+    });
+    try {
+      const destDir = path4.join(AUTOHAND_PATHS.memory, "imported-gemini");
+      await fse4.ensureDir(destDir);
+      await fse4.copy(geminiMdPath, path4.join(destDir, "GEMINI.md"));
+      imported.set("memory", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "memory",
+        current: 1,
+        total: 1,
+        item: "GEMINI.md",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("memory", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "memory",
+        item: "GEMINI.md",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: true
+      });
+    }
+  }
+};
+
+// src/import/importers/CursorImporter.ts
+import path5 from "path";
+import fse5 from "fs-extra";
+var CursorImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "cursor";
+    this.displayName = "Cursor";
+    this.homePath = "~/.cursor";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse5.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const hooksPath = path5.join(home, "hooks.json");
+    if (await fse5.pathExists(hooksPath)) {
+      available.set("settings", { count: 1, description: "Cursor hooks.json preferences" });
+      available.set("hooks", { count: 1, description: "Cursor hook configurations" });
+    }
+    const mcpPath = path5.join(home, "mcp.json");
+    if (await fse5.pathExists(mcpPath)) {
+      available.set("mcp", { count: 1, description: "Cursor MCP server configurations" });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        case "hooks":
+          await this.importHooks(imported, errors, onProgress);
+          break;
+        case "mcp":
+          await this.importMcp(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const hooksPath = path5.join(this.resolvedHomePath, "hooks.json");
+    if (!await fse5.pathExists(hooksPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "hooks.json",
+      status: "importing"
+    });
+    try {
+      const hooksData = await this.safeReadJson(hooksPath);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse5.ensureDir(configDir);
+      await fse5.writeJson(
+        path5.join(configDir, "imported-cursor-settings.json"),
+        {
+          importedFrom: "cursor",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: hooksData
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "hooks.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "hooks.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Hooks
+  // ---------------------------------------------------------------
+  async importHooks(imported, errors, onProgress) {
+    const hooksPath = path5.join(this.resolvedHomePath, "hooks.json");
+    if (!await fse5.pathExists(hooksPath)) {
+      imported.set("hooks", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "hooks",
+      current: 1,
+      total: 1,
+      item: "hooks.json",
+      status: "importing"
+    });
+    try {
+      const hooksData = await this.safeReadJson(hooksPath);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse5.ensureDir(configDir);
+      await fse5.writeJson(
+        path5.join(configDir, "imported-cursor-hooks.json"),
+        {
+          importedFrom: "cursor",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          hooks: hooksData.hooks ?? hooksData
+        },
+        { spaces: 2 }
+      );
+      imported.set("hooks", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "hooks",
+        current: 1,
+        total: 1,
+        item: "hooks.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("hooks", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "hooks",
+        item: "hooks.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // MCP
+  // ---------------------------------------------------------------
+  async importMcp(imported, errors, onProgress) {
+    const mcpPath = path5.join(this.resolvedHomePath, "mcp.json");
+    if (!await fse5.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);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse5.ensureDir(configDir);
+      await fse5.writeJson(
+        path5.join(configDir, "imported-cursor-mcp.json"),
+        {
+          importedFrom: "cursor",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          mcpServers: mcpData.mcpServers ?? 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
+      });
+    }
+  }
+};
+
+// src/import/importers/ClineImporter.ts
+import path6 from "path";
+import fse6 from "fs-extra";
+var ClineImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "cline";
+    this.displayName = "Cline";
+    this.homePath = "~/.cline";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse6.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const globalStatePath = path6.join(home, "data", "globalState.json");
+    if (await fse6.pathExists(globalStatePath)) {
+      available.set("settings", {
+        count: 1,
+        description: "Cline global state (model preferences, auto-approval, browser settings)"
+      });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const globalStatePath = path6.join(this.resolvedHomePath, "data", "globalState.json");
+    if (!await fse6.pathExists(globalStatePath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "globalState.json",
+      status: "importing"
+    });
+    try {
+      const state = await this.safeReadJson(globalStatePath);
+      const extracted = {};
+      if (state.apiModelId) extracted.model = state.apiModelId;
+      if (state.autoApprovalSettings) extracted.autoApproval = state.autoApprovalSettings;
+      if (state.browserSettings) extracted.browser = state.browserSettings;
+      if (state.workspaceRoots) extracted.workspaceRoots = state.workspaceRoots;
+      const configDir = AUTOHAND_PATHS.config;
+      await fse6.ensureDir(configDir);
+      await fse6.writeJson(
+        path6.join(configDir, "imported-cline-settings.json"),
+        {
+          importedFrom: "cline",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...extracted,
+          raw: state
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "globalState.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "globalState.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+};
+
+// src/import/importers/ContinueImporter.ts
+import path7 from "path";
+import fse7 from "fs-extra";
+var ContinueImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "continue";
+    this.displayName = "Continue.dev";
+    this.homePath = "~/.continue";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse7.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const configPath = path7.join(home, "config.json");
+    if (await fse7.pathExists(configPath)) {
+      available.set("settings", {
+        count: 1,
+        description: "Continue.dev config (models, context providers, slash commands, embeddings)"
+      });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const configPath = path7.join(this.resolvedHomePath, "config.json");
+    if (!await fse7.pathExists(configPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "config.json",
+      status: "importing"
+    });
+    try {
+      const config = await this.safeReadJson(configPath);
+      const extracted = {
+        importedFrom: "continue",
+        importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (config.models) extracted.models = config.models;
+      if (config.contextProviders) extracted.contextProviders = config.contextProviders;
+      if (config.slashCommands) extracted.slashCommands = config.slashCommands;
+      if (config.embeddingsProvider) extracted.embeddingsProvider = config.embeddingsProvider;
+      const configDir = AUTOHAND_PATHS.config;
+      await fse7.ensureDir(configDir);
+      await fse7.writeJson(
+        path7.join(configDir, "imported-continue-settings.json"),
+        extracted,
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "config.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "config.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+};
+
+// src/import/importers/AugmentImporter.ts
+import path8 from "path";
+import fse8 from "fs-extra";
+var AugmentImporter = class extends BaseImporter {
+  constructor() {
+    super(...arguments);
+    this.name = "augment";
+    this.displayName = "Augment";
+    this.homePath = "~/.augment";
+  }
+  // ---------------------------------------------------------------
+  // scan()
+  // ---------------------------------------------------------------
+  async scan() {
+    const available = /* @__PURE__ */ new Map();
+    const home = this.resolvedHomePath;
+    if (!await fse8.pathExists(home)) {
+      return { source: this.name, available };
+    }
+    const mcpPath = path8.join(home, "mcp.json");
+    if (await fse8.pathExists(mcpPath)) {
+      available.set("mcp", { count: 1, description: "Augment MCP server configurations" });
+    }
+    const settingsPath = path8.join(home, "settings.json");
+    if (await fse8.pathExists(settingsPath)) {
+      available.set("settings", { count: 1, description: "Augment settings" });
+    }
+    return { source: this.name, available };
+  }
+  // ---------------------------------------------------------------
+  // import()
+  // ---------------------------------------------------------------
+  async import(categories, onProgress) {
+    const start = Date.now();
+    const imported = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const category of categories) {
+      switch (category) {
+        case "mcp":
+          await this.importMcp(imported, errors, onProgress);
+          break;
+        case "settings":
+          await this.importSettings(imported, errors, onProgress);
+          break;
+        default:
+          break;
+      }
+    }
+    return {
+      source: this.name,
+      imported,
+      errors,
+      duration: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------
+  // MCP
+  // ---------------------------------------------------------------
+  async importMcp(imported, errors, onProgress) {
+    const mcpPath = path8.join(this.resolvedHomePath, "mcp.json");
+    if (!await fse8.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);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse8.ensureDir(configDir);
+      await fse8.writeJson(
+        path8.join(configDir, "imported-augment-mcp.json"),
+        {
+          importedFrom: "augment",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          mcpServers: mcpData.mcpServers ?? 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
+      });
+    }
+  }
+  // ---------------------------------------------------------------
+  // Settings
+  // ---------------------------------------------------------------
+  async importSettings(imported, errors, onProgress) {
+    const settingsPath = path8.join(this.resolvedHomePath, "settings.json");
+    if (!await fse8.pathExists(settingsPath)) {
+      imported.set("settings", { success: 0, failed: 0, skipped: 1 });
+      return;
+    }
+    onProgress?.({
+      category: "settings",
+      current: 1,
+      total: 1,
+      item: "settings.json",
+      status: "importing"
+    });
+    try {
+      const settings = await this.safeReadJson(settingsPath);
+      const configDir = AUTOHAND_PATHS.config;
+      await fse8.ensureDir(configDir);
+      await fse8.writeJson(
+        path8.join(configDir, "imported-augment-settings.json"),
+        {
+          importedFrom: "augment",
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: settings
+        },
+        { spaces: 2 }
+      );
+      imported.set("settings", { success: 1, failed: 0, skipped: 0 });
+      onProgress?.({
+        category: "settings",
+        current: 1,
+        total: 1,
+        item: "settings.json",
+        status: "done"
+      });
+    } catch (err) {
+      imported.set("settings", { success: 0, failed: 1, skipped: 0 });
+      errors.push({
+        category: "settings",
+        item: "settings.json",
+        error: err instanceof Error ? err.message : String(err),
+        retriable: false
+      });
+    }
+  }
+};
+
+// src/import/registry.ts
+var ImporterRegistry = class {
+  constructor() {
+    this.importers = /* @__PURE__ */ new Map();
+    this.register(new ClaudeImporter());
+    this.register(new CodexImporter());
+    this.register(new GeminiImporter());
+    this.register(new CursorImporter());
+    this.register(new ClineImporter());
+    this.register(new ContinueImporter());
+    this.register(new AugmentImporter());
+  }
+  /**
+   * Register an importer instance by its source name.
+   */
+  register(importer) {
+    this.importers.set(importer.name, importer);
+  }
+  /**
+   * Get an importer by its source name.
+   * Returns undefined if the source is not registered.
+   */
+  get(name) {
+    return this.importers.get(name);
+  }
+  /**
+   * Get all registered importers.
+   */
+  getAll() {
+    return Array.from(this.importers.values());
+  }
+  /**
+   * Detect which agent data directories exist on disk.
+   * Runs all detect() calls in parallel for speed.
+   */
+  async detectAvailable() {
+    const results = await Promise.all(
+      this.getAll().map(async (importer) => ({
+        importer,
+        exists: await importer.detect()
+      }))
+    );
+    return results.filter((r) => r.exists).map((r) => r.importer);
+  }
+};
+export {
+  ImporterRegistry
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */