@laivc/laicode 0.1.0 → 0.2.1

package/lib/adapters.js

@@ -0,0 +1,666 @@
+"use strict"
+
+const fs = require("fs")
+const fsp = require("fs/promises")
+const os = require("os")
+const path = require("path")
+
+const DEFAULT_API_BASE = "https://api.lai.vc/v1"
+const DEFAULT_MODEL = "gpt-5.5"
+
+const TOOL_PACKAGES = {
+  claude: {
+    packageName: "@anthropic-ai/claude-code",
+    binary: "claude",
+    name: "Claude Code",
+    installNotes: ["官方支持 native installer、Homebrew、WinGet、npm；Laicode 默认使用 npm 全局安装。"],
+  },
+  codex: {
+    packageName: "@openai/codex",
+    binary: "codex",
+    name: "Codex CLI",
+    installNotes: ["官方支持 standalone、npm、Homebrew；Laicode 默认使用 npm 全局安装，便于卸载和重装。"],
+  },
+  opencode: {
+    packageName: "opencode-ai",
+    binary: "opencode",
+    name: "OpenCode",
+    installNotes: ["OpenCode 官方支持 install script、npm、Bun、pnpm、Yarn、Homebrew、Chocolatey、Scoop；Laicode 默认使用 npm 全局安装。"],
+  },
+  continue: {
+    packageName: "@continuedev/cli",
+    binary: "cn",
+    name: "Continue CLI",
+    installNotes: ["Continue CLI 安装后提供 `cn` 命令；IDE 扩展仍需要在对应编辑器内安装。"],
+  },
+}
+
+function homeDir(env = process.env) {
+  return env.HOME || env.USERPROFILE || os.homedir()
+}
+
+function expandHome(value, env = process.env) {
+  if (!value) return value
+  if (value === "~") return homeDir(env)
+  if (value.startsWith("~/")) return path.join(homeDir(env), value.slice(2))
+  return value
+}
+
+function exists(file) {
+  try {
+    fs.accessSync(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function commandExists(cmd, env = process.env) {
+  const pathEnv = String(env.PATH || "")
+  const dirs = pathEnv.split(path.delimiter).filter(Boolean)
+  const exts =
+    process.platform === "win32"
+      ? String(env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")
+      : [""]
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      if (exists(path.join(dir, cmd + ext))) return true
+    }
+  }
+  return false
+}
+
+function codexHome(env = process.env) {
+  return env.CODEX_HOME ? expandHome(env.CODEX_HOME, env) : path.join(homeDir(env), ".codex")
+}
+
+function continueHome(env = process.env) {
+  return path.join(homeDir(env), ".continue")
+}
+
+function claudeHome(env = process.env) {
+  return path.join(homeDir(env), ".claude")
+}
+
+function opencodeHome(env = process.env) {
+  return path.join(env.XDG_CONFIG_HOME || path.join(homeDir(env), ".config"), "opencode")
+}
+
+function platformConfigDir(appName, env = process.env) {
+  if (process.platform === "darwin") return path.join(homeDir(env), "Library", "Application Support", appName)
+  if (process.platform === "win32") return path.join(env.APPDATA || path.join(homeDir(env), "AppData", "Roaming"), appName)
+  return path.join(env.XDG_CONFIG_HOME || path.join(homeDir(env), ".config"), appName)
+}
+
+function detectTools(opts = {}) {
+  const env = opts.env || process.env
+  const codexDir = codexHome(env)
+  const continueDir = continueHome(env)
+  const claudeDir = claudeHome(env)
+  const opencodeDir = opencodeHome(env)
+  const cursorDir = platformConfigDir("Cursor", env)
+  const codeDir = platformConfigDir("Code", env)
+  const vscodeExtensions = path.join(homeDir(env), ".vscode", "extensions")
+
+  const continueYaml = path.join(continueDir, "config.yaml")
+  const continueJson = path.join(continueDir, "config.json")
+  const clineDetected =
+    exists(path.join(codeDir, "User", "globalStorage", "saoudrizwan.claude-dev")) ||
+    exists(path.join(codeDir, "User", "globalStorage", "cline.cline")) ||
+    (exists(vscodeExtensions) &&
+      fs.readdirSync(vscodeExtensions).some((name) => /(^|\.)(cline|claude-dev)/i.test(name)))
+
+  return [
+    {
+      id: "claude",
+      name: "Claude Code",
+      detected: commandExists("claude", env) || commandExists("ant", env) || exists(claudeDir) || exists(path.join(homeDir(env), ".claude.json")),
+      support: "blocked",
+      status: commandExists("claude", env) ? "已安装，接入待 Anthropic 网关" : "可安装，接入待 Anthropic 网关",
+      configPath: path.join(claudeDir, "settings.json"),
+      next: "laicode init --tool claude",
+    },
+    {
+      id: "codex",
+      name: "Codex CLI",
+      detected: commandExists("codex", env) || exists(codexDir),
+      support: "auto",
+      status: exists(path.join(codexDir, "laicode.config.toml")) ? "已接入 profile" : "可一键接入",
+      configPath: path.join(codexDir, "laicode.config.toml"),
+      next: "laicode init --tool codex --apply",
+    },
+    {
+      id: "vscode",
+      name: "VS Code",
+      detected: commandExists("code", env) || exists(codeDir),
+      support: "guide",
+      status: commandExists("code", env) || exists(codeDir) ? "编辑器已发现，请选择具体 AI 扩展接入" : "未检测到",
+      configPath: path.join(codeDir, "User"),
+      next: "laicode init --tool vscode",
+    },
+    {
+      id: "cursor",
+      name: "Cursor",
+      detected: exists(cursorDir) || commandExists("cursor", env),
+      support: "guide",
+      status: exists(cursorDir) || commandExists("cursor", env) ? "密钥在安全存储，暂不脚本写入" : "未检测到",
+      configPath: path.join(cursorDir, "User"),
+      next: "laicode init --tool cursor",
+    },
+    {
+      id: "opencode",
+      name: "OpenCode",
+      detected: commandExists("opencode", env) || exists(opencodeDir),
+      support: "auto",
+      status: exists(path.join(opencodeDir, "opencode.json")) ? "可合并 Lai.vc provider" : "可创建 Lai.vc provider",
+      configPath: path.join(opencodeDir, "opencode.json"),
+      next: "laicode init --tool opencode --apply",
+    },
+    {
+      id: "continue",
+      name: "Continue",
+      detected: exists(continueDir),
+      support: exists(continueYaml) || exists(continueJson) ? "manual-merge" : "auto-new",
+      status: exists(continueYaml) || exists(continueJson) ? "检测到现有配置，先预览手动合并" : "可创建新配置",
+      configPath: exists(continueYaml) ? continueYaml : exists(continueJson) ? continueJson : continueYaml,
+      next: "laicode init --tool continue --apply",
+    },
+    {
+      id: "cline",
+      name: "Cline",
+      detected: clineDetected,
+      support: "guide",
+      status: clineDetected ? "需在扩展 UI 中选择 OpenAI Compatible" : "未检测到",
+      configPath: path.join(codeDir, "User"),
+      next: "laicode init --tool cline",
+    },
+  ]
+}
+
+function normalizeToolId(tool) {
+  const value = String(tool || "codex").toLowerCase()
+  if (value === "claude-code" || value === "claudecli") return "claude"
+  if (value === "continue-cli") return "continue"
+  if (value === "open-code" || value === "opencode-ai") return "opencode"
+  if (value === "code" || value === "visual-studio-code") return "vscode"
+  return value
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value))
+}
+
+function yamlString(value) {
+  return JSON.stringify(String(value))
+}
+
+function plainObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {}
+}
+
+function codexProfileContent(ctx) {
+  const model = ctx.model || DEFAULT_MODEL
+  const apiBaseUrl = ctx.apiBaseUrl || DEFAULT_API_BASE
+  return [
+    "# Created by Laicode. Remove this file or run `laicode rollback` to undo.",
+    `model = ${tomlString(model)}`,
+    'model_provider = "laivc"',
+    "",
+    "[model_providers.laivc]",
+    'name = "Lai.vc"',
+    `base_url = ${tomlString(apiBaseUrl)}`,
+    "",
+    "[model_providers.laivc.auth]",
+    `command = ${tomlString(ctx.commandName || "laicode")}`,
+    'args = ["credential", "api-key"]',
+    "timeout_ms = 5000",
+    "refresh_interval_ms = 300000",
+    "",
+  ].join("\n")
+}
+
+function continueConfigContent(ctx) {
+  const model = ctx.model || DEFAULT_MODEL
+  const apiBaseUrl = ctx.apiBaseUrl || DEFAULT_API_BASE
+  const apiKey = ctx.apiKey || "sk-..."
+  return [
+    "name: LaiCode",
+    "version: 0.0.1",
+    "schema: v1",
+    "models:",
+    `  - name: ${yamlString(`Lai.vc ${model}`)}`,
+    "    provider: openai",
+    `    model: ${yamlString(model)}`,
+    `    apiBase: ${yamlString(apiBaseUrl)}`,
+    `    apiKey: ${yamlString(apiKey)}`,
+    "    useResponsesApi: false",
+    "",
+  ].join("\n")
+}
+
+function opencodeConfigContent(ctx, existing = {}) {
+  const model = ctx.model || DEFAULT_MODEL
+  const apiBaseUrl = ctx.apiBaseUrl || DEFAULT_API_BASE
+  const apiKey = ctx.apiKey || "sk-..."
+  const existingProviders = plainObject(existing.provider)
+  const existingLaivc = plainObject(existingProviders.laivc)
+  const existingOptions = plainObject(existingLaivc.options)
+  const existingModels = plainObject(existingLaivc.models)
+  const existingModel = plainObject(existingModels[model])
+  const next = {
+    "$schema": "https://opencode.ai/config.json",
+    ...existing,
+    provider: {
+      ...existingProviders,
+      laivc: {
+        ...existingLaivc,
+        npm: "@ai-sdk/openai-compatible",
+        name: "Lai.vc",
+        options: {
+          ...existingOptions,
+          baseURL: apiBaseUrl,
+          apiKey,
+        },
+        models: {
+          ...existingModels,
+          [model]: {
+            ...existingModel,
+            name: model,
+          },
+        },
+      },
+    },
+    model: `laivc/${model}`,
+  }
+  return JSON.stringify(next, null, 2) + "\n"
+}
+
+function manualPlan(tool, ctx, reason, instructions) {
+  return {
+    tool,
+    ok: false,
+    mode: "manual",
+    reason,
+    instructions,
+    operations: [],
+    apiBaseUrl: ctx.apiBaseUrl || DEFAULT_API_BASE,
+    model: ctx.model || DEFAULT_MODEL,
+  }
+}
+
+function buildInitPlan(tool, ctx = {}) {
+  const env = ctx.env || process.env
+  const normalized = normalizeToolId(tool)
+  const apiBaseUrl = ctx.apiBaseUrl || DEFAULT_API_BASE
+  const model = ctx.model || DEFAULT_MODEL
+
+  if (normalized === "codex") {
+    const target = path.join(codexHome(env), "laicode.config.toml")
+    return {
+      tool: "codex",
+      ok: true,
+      mode: "profile",
+      summary: "创建 Codex 独立 profile，不改主配置和官方登录态。",
+      apiBaseUrl,
+      model,
+      runCommand: "codex --profile laicode",
+      operations: [
+        {
+          action: "write",
+          path: target,
+          mode: 0o600,
+          description: "Codex Lai.vc profile",
+          content: codexProfileContent({ ...ctx, apiBaseUrl, model }),
+        },
+      ],
+    }
+  }
+
+  if (normalized === "continue") {
+    const target = path.join(continueHome(env), "config.yaml")
+    const existingYaml = exists(target)
+    const existingJson = exists(path.join(continueHome(env), "config.json"))
+    if ((existingYaml || existingJson) && !ctx.force) {
+      return manualPlan("continue", { ...ctx, apiBaseUrl, model }, "检测到 Continue 现有配置，当前版本不自动合并 YAML/JSON。", [
+        "打开 Continue 配置文件。",
+        `新增 provider=openai, apiBase=${apiBaseUrl}, model=${model}, useResponsesApi=false。`,
+        "后续版本会在引入结构化 YAML 合并后支持自动 patch。",
+      ])
+    }
+    return {
+      tool: "continue",
+      ok: true,
+      mode: "new-config",
+      summary: "创建 Continue config.yaml，使用 OpenAI compatible provider。",
+      apiBaseUrl,
+      model,
+      operations: [
+        {
+          action: "write",
+          path: target,
+          mode: 0o600,
+          description: "Continue Lai.vc config",
+          content: continueConfigContent({ ...ctx, apiBaseUrl, model }),
+        },
+      ],
+    }
+  }
+
+  if (normalized === "opencode") {
+    const target = path.join(opencodeHome(env), "opencode.json")
+    let existing = {}
+    if (exists(target)) {
+      try {
+        existing = JSON.parse(fs.readFileSync(target, "utf8"))
+      } catch {
+        return manualPlan("opencode", { ...ctx, apiBaseUrl, model }, "检测到 OpenCode 配置，但不是有效 JSON，当前版本不自动覆盖。", [
+          `打开 ${target}。`,
+          "按 OpenCode provider 文档新增 `laivc` provider。",
+          `baseURL 填 ${apiBaseUrl}，npm adapter 使用 @ai-sdk/openai-compatible。`,
+        ])
+      }
+    }
+    return {
+      tool: "opencode",
+      ok: true,
+      mode: exists(target) ? "json-merge" : "new-config",
+      summary: "创建或合并 OpenCode Lai.vc provider。",
+      apiBaseUrl,
+      model,
+      runCommand: "opencode",
+      operations: [
+        {
+          action: "write",
+          path: target,
+          mode: 0o600,
+          description: "OpenCode Lai.vc provider",
+          content: opencodeConfigContent({ ...ctx, apiBaseUrl, model }, existing),
+        },
+      ],
+    }
+  }
+
+  if (normalized === "claude") {
+    return manualPlan("claude", { ...ctx, apiBaseUrl, model }, "Claude Code 使用 Anthropic Messages API；当前 Lai.vc 只提供 OpenAI compatible /v1，不能直接接入。", [
+      "等待 Lai.vc 主站提供 Anthropic `/v1/messages` 兼容端点或官方代理决策。",
+      "届时可配置 `ANTHROPIC_BASE_URL` 指向 Lai.vc 的 Anthropic-compatible 网关。",
+      "认证可使用 `ANTHROPIC_AUTH_TOKEN` 或 `ANTHROPIC_API_KEY`，具体以主站契约为准。",
+      "当前请使用 Codex、Continue、Cursor 或 Cline 的 OpenAI compatible 接入路径测试 Lai.vc。",
+    ])
+  }
+
+  if (normalized === "vscode") {
+    return manualPlan("vscode", { ...ctx, apiBaseUrl, model }, "VS Code 是编辑器宿主，本身没有统一的 OpenAI-compatible 网关配置；请选择具体扩展接入。", [
+      "优先使用 Codex CLI/扩展时，运行 `laicode init --tool codex` 创建独立 Codex profile。",
+      "使用 Continue 扩展时，运行 `laicode init --tool continue` 预览 Continue 配置。",
+      "使用 Cline 扩展时，在 Cline 设置中选择 OpenAI Compatible，并填入 Lai.vc base URL 和 API Key。",
+      "Laicode 后续会按扩展稳定配置契约逐个自动化，不直接改 VS Code 安全存储。",
+    ])
+  }
+
+  if (normalized === "cline") {
+    return manualPlan("cline", { ...ctx, apiBaseUrl, model }, "Cline 设置目前由 VS Code 扩展 UI 管理，先提供可靠指引。", [
+      "打开 Cline 设置。",
+      "API Provider 选择 OpenAI Compatible。",
+      `Base URL 填 ${apiBaseUrl}。`,
+      "API Key 使用 `laicode keys --show` 显式查看后粘贴。",
+      `Model ID 填 ${model}。`,
+    ])
+  }
+
+  if (normalized === "cursor") {
+    return manualPlan("cursor", { ...ctx, apiBaseUrl, model }, "Cursor API Key 存在安全存储中，当前不支持可靠脚本写入。", [
+      "打开 Cursor Settings -> Models。",
+      "添加 OpenAI API Key。",
+      `启用 Override OpenAI Base URL 并填写 ${apiBaseUrl}。`,
+      `添加并启用自定义模型 ${model}。`,
+    ])
+  }
+
+  return manualPlan(normalized, { ...ctx, apiBaseUrl, model }, `暂不支持工具: ${normalized}`, ["运行 `laicode tools` 查看当前支持矩阵。"])
+}
+
+function commandPlan(command, args) {
+  return {
+    command,
+    args,
+    display: [command, ...args].join(" "),
+  }
+}
+
+function buildToolActionPlan(tool, action, ctx = {}) {
+  const normalized = normalizeToolId(tool)
+  const normalizedAction = String(action || "scan").toLowerCase()
+  const meta = TOOL_PACKAGES[normalized]
+  const env = ctx.env || process.env
+
+  if (normalizedAction === "configure") {
+    return buildInitPlan(normalized, ctx)
+  }
+
+  if (!["install", "uninstall", "reinstall"].includes(normalizedAction)) {
+    return manualPlan(normalized, ctx, `暂不支持动作: ${normalizedAction}`, [
+      "支持动作: install、uninstall、reinstall、configure。",
+      "运行 `laicode tools` 查看工具状态。",
+    ])
+  }
+
+  if (!meta) {
+    return manualPlan(normalized, ctx, "当前工具没有安全的自动安装/卸载策略。", [
+      "请按工具官方文档安装。",
+      "安装后运行 `laicode tools` 重新检测。",
+    ])
+  }
+
+  const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm"
+  const hasNpm = commandExists(npmCommand, env) || commandExists("npm", env)
+  const commands = []
+  if (normalizedAction === "install") commands.push(commandPlan(npmCommand, ["install", "-g", meta.packageName]))
+  if (normalizedAction === "uninstall") commands.push(commandPlan(npmCommand, ["uninstall", "-g", meta.packageName]))
+  if (normalizedAction === "reinstall") {
+    commands.push(commandPlan(npmCommand, ["uninstall", "-g", meta.packageName]))
+    commands.push(commandPlan(npmCommand, ["install", "-g", meta.packageName]))
+  }
+
+  const postSteps = []
+  if (normalized === "codex") {
+    postSteps.push("运行 `laicode init --tool codex` 预览接入 profile。")
+    postSteps.push("应用后使用 `codex --profile laicode` 测试 Lai.vc。")
+  } else if (normalized === "continue") {
+    postSteps.push("运行 `laicode init --tool continue` 预览 Continue 配置。")
+    postSteps.push("IDE 扩展仍需在 Cursor/VS Code 扩展市场安装。")
+  } else if (normalized === "claude") {
+    postSteps.push("当前只能安装 Claude Code；接入 Lai.vc 需等待 Anthropic Messages 兼容端点。")
+  } else if (normalized === "opencode") {
+    postSteps.push("运行 `laicode init --tool opencode` 预览 OpenCode provider。")
+    postSteps.push("应用后使用 `opencode` 测试 Lai.vc。")
+  }
+
+  return {
+    tool: normalized,
+    action: normalizedAction,
+    ok: hasNpm,
+    mode: "command",
+    summary: `${meta.name} ${normalizedAction} 计划`,
+    reason: hasNpm ? "" : "未找到 npm，无法自动执行安装/卸载命令。",
+    commands,
+    warnings: [
+      "默认只预览命令；传 `--apply` 才会执行。",
+      "卸载/重装只覆盖 npm 全局安装的包；通过 Homebrew、WinGet 或官方安装器安装的版本需用对应工具管理。",
+      ...meta.installNotes,
+    ],
+    postSteps,
+  }
+}
+
+function runCommand(command, args, opts = {}) {
+  const { spawnSync } = require("child_process")
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: opts.stdio || "pipe",
+    env: opts.env || process.env,
+  })
+  return {
+    command,
+    args,
+    status: result.status,
+    ok: result.status === 0,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? result.error.message : null,
+  }
+}
+
+async function applyToolActionPlan(plan, opts = {}) {
+  if (!plan.ok || !plan.commands?.length) {
+    throw new Error(plan.reason || "No commands to apply")
+  }
+  const results = []
+  for (const command of plan.commands) {
+    const result = runCommand(command.command, command.args, {
+      stdio: opts.stdio || "inherit",
+      env: opts.env || process.env,
+    })
+    results.push(result)
+    if (!result.ok) {
+      const err = new Error(`Command failed: ${command.display}`)
+      err.result = result
+      err.results = results
+      throw err
+    }
+  }
+  return {
+    tool: plan.tool,
+    action: plan.action,
+    appliedAt: new Date().toISOString(),
+    commands: plan.commands,
+    results,
+    postSteps: plan.postSteps || [],
+  }
+}
+
+function redactText(value, secrets = []) {
+  let out = String(value || "")
+  for (const secret of secrets.filter(Boolean)) {
+    out = out.split(secret).join(maskSecret(secret))
+  }
+  return out
+}
+
+function maskSecret(value) {
+  if (!value || value.length <= 16) return "***"
+  return `${value.slice(0, 8)}...${value.slice(-4)}`
+}
+
+function safePlan(plan, secrets = []) {
+  return {
+    ...plan,
+    operations: (plan.operations || []).map((op) => ({
+      action: op.action,
+      path: op.path,
+      mode: op.mode,
+      description: op.description,
+      preview: redactText(op.content, secrets),
+      exists: exists(op.path),
+    })),
+  }
+}
+
+function backupName(file) {
+  return Buffer.from(file).toString("base64url")
+}
+
+async function writeFileAtomic(file, content, mode = 0o600) {
+  await fsp.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+  const tmp = `${file}.${process.pid}.tmp`
+  await fsp.writeFile(tmp, content, { mode })
+  try {
+    await fsp.chmod(tmp, mode)
+  } catch {
+    // Best effort for non-POSIX filesystems.
+  }
+  await fsp.rename(tmp, file)
+}
+
+async function applyInitPlan(plan, opts = {}) {
+  if (!plan.ok || !plan.operations?.length) {
+    throw new Error(plan.reason || "No operations to apply")
+  }
+  const stateDir = opts.stateDir || path.join(homeDir(), ".laicode")
+  const id = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupDir = path.join(stateDir, "backups", id)
+  const applied = []
+
+  await fsp.mkdir(backupDir, { recursive: true, mode: 0o700 })
+  for (const op of plan.operations) {
+    if (op.action !== "write") throw new Error(`Unsupported operation: ${op.action}`)
+    const existed = exists(op.path)
+    const backupPath = path.join(backupDir, backupName(op.path))
+    if (existed) {
+      await fsp.mkdir(path.dirname(backupPath), { recursive: true })
+      await fsp.copyFile(op.path, backupPath)
+    }
+    await writeFileAtomic(op.path, op.content, op.mode || 0o600)
+    applied.push({
+      action: op.action,
+      path: op.path,
+      description: op.description,
+      existed,
+      backupPath: existed ? backupPath : null,
+      mode: op.mode || 0o600,
+    })
+  }
+
+  const manifest = {
+    id,
+    createdAt: new Date().toISOString(),
+    tool: plan.tool,
+    mode: plan.mode,
+    operations: applied,
+  }
+  await writeFileAtomic(path.join(backupDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", 0o600)
+  return manifest
+}
+
+async function rollbackLatest(opts = {}) {
+  const stateDir = opts.stateDir || path.join(homeDir(), ".laicode")
+  const backupsDir = path.join(stateDir, "backups")
+  let entries
+  try {
+    entries = await fsp.readdir(backupsDir, { withFileTypes: true })
+  } catch (err) {
+    if (err.code === "ENOENT") return null
+    throw err
+  }
+  const ids = entries
+    .filter((entry) => entry.isDirectory() && !entry.name.endsWith(".rolled-back"))
+    .map((entry) => entry.name)
+    .sort()
+  const id = ids[ids.length - 1]
+  if (!id) return null
+
+  const backupDir = path.join(backupsDir, id)
+  const manifest = JSON.parse(await fsp.readFile(path.join(backupDir, "manifest.json"), "utf8"))
+  for (const op of [...manifest.operations].reverse()) {
+    if (op.existed && op.backupPath) {
+      await fsp.mkdir(path.dirname(op.path), { recursive: true, mode: 0o700 })
+      await fsp.copyFile(op.backupPath, op.path)
+    } else if (!op.existed) {
+      await fsp.rm(op.path, { force: true })
+    }
+  }
+  await fsp.rename(backupDir, `${backupDir}.rolled-back`)
+  return manifest
+}
+
+module.exports = {
+  DEFAULT_API_BASE,
+  DEFAULT_MODEL,
+  applyInitPlan,
+  applyToolActionPlan,
+  buildInitPlan,
+  buildToolActionPlan,
+  detectTools,
+  rollbackLatest,
+  safePlan,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laivc/laicode",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Official Lai.vc CLI for configuring developer tools.",
   "license": "MIT",
   "homepage": "https://lai.vc",
@@ -27,6 +27,7 @@
   },
   "files": [
     "bin",
+    "lib",
     "README.md",
     "scripts"
   ],