opencode-deepa 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,706 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/config-io.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+
+// src/cli/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getConfigJson() {
+  return join(getConfigDir(), "opencode.json");
+}
+function getConfigJsonc() {
+  return join(getConfigDir(), "opencode.jsonc");
+}
+function getLiteConfig() {
+  return join(getConfigDir(), "opencode-deepa.json");
+}
+function getExistingConfigPath() {
+  const jsonPath = getConfigJson();
+  if (existsSync(jsonPath))
+    return jsonPath;
+  const jsoncPath = getConfigJsonc();
+  if (existsSync(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  deepa: ["websearch", "context7", "grep_app", "gitingest", "deepaSummary", "filesystem"]
+};
+
+// src/skills/index.ts
+var RECOMMENDED_SKILLS = [
+  {
+    name: "simplify",
+    repo: "https://github.com/brianlovin/claude-config",
+    skillName: "simplify",
+    allowedAgents: ["deepa", "deepa-builder"],
+    description: "YAGNI code simplification expert"
+  },
+  {
+    name: "agent-browser",
+    repo: "https://github.com/vercel-labs/agent-browser",
+    skillName: "agent-browser",
+    allowedAgents: ["deepa", "deepa-planner", "deepa-builder"],
+    description: "High-performance browser automation",
+    postInstallCommands: [
+      "npm install -g agent-browser",
+      "agent-browser install"
+    ]
+  },
+  {
+    name: "ask-questions-if-underspecified",
+    repo: "https://github.com/smartfrog/opencode-froggy",
+    skillName: "ask-questions-if-underspecified",
+    allowedAgents: ["deepa", "deepa-planner", "deepa-builder"],
+    description: "Clarify requirements before implementing. Use when serious doubts arise."
+  }
+];
+function installSkill(skill) {
+  console.log(`Would install skill: ${skill.name} from ${skill.repo}`);
+  return true;
+}
+
+// src/cli/providers.ts
+function generateLiteConfig(installConfig) {
+  const config = {
+    preset: "openai",
+    presets: {}
+  };
+  const createAgentConfig = (agentName, modelInfo) => {
+    const isOrchestrator = agentName === "deepa";
+    const skills = isOrchestrator ? ["*"] : RECOMMENDED_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.skillName);
+    let agentSkills = skills;
+    if (agentName === "deepa-planner") {
+      agentSkills = [...new Set([...skills, "ask-questions-if-underspecified"])];
+    } else if (agentName === "deepa-builder") {
+      agentSkills = [...new Set([...skills, "simplify"])];
+    }
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant,
+      skills: agentSkills,
+      mcps: DEFAULT_AGENT_MCPS[agentName] ?? []
+    };
+  };
+  config.presets.openai = {
+    deepa: createAgentConfig("deepa", {}),
+    deepa_planner: createAgentConfig("deepa-planner", {}),
+    deepa_builder: createAgentConfig("deepa-builder", {})
+  };
+  config.presets.kimi = {
+    deepa: createAgentConfig("deepa", {}),
+    deepa_planner: createAgentConfig("deepa-planner", {}),
+    deepa_builder: createAgentConfig("deepa-builder", {})
+  };
+  config.presets.copilot = {
+    deepa: createAgentConfig("deepa", {}),
+    deepa_planner: createAgentConfig("deepa-planner", {}),
+    deepa_builder: createAgentConfig("deepa-builder", {})
+  };
+  config.presets["zai-plan"] = {
+    deepa: createAgentConfig("deepa", {}),
+    deepa_planner: createAgentConfig("deepa-planner", {}),
+    deepa_builder: createAgentConfig("deepa-builder", {})
+  };
+  if (installConfig.hasTmux) {
+    config.tmux = {
+      enabled: true,
+      layout: "main-vertical",
+      main_pane_size: 60
+    };
+  }
+  return config;
+}
+
+// src/cli/config-io.ts
+var PACKAGE_NAME = "opencode-deepa";
+function stripJsonComments(json) {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+  return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
+}
+function parseConfigFile(path) {
+  try {
+    if (!existsSync2(path))
+      return { config: null };
+    const stat = statSync(path);
+    if (stat.size === 0)
+      return { config: null };
+    const content = readFileSync(path, "utf-8");
+    if (content.trim().length === 0)
+      return { config: null };
+    return { config: JSON.parse(stripJsonComments(content)) };
+  } catch (err) {
+    return { config: null, error: String(err) };
+  }
+}
+function parseConfig(path) {
+  const result = parseConfigFile(path);
+  if (result.config || result.error)
+    return result;
+  if (path.endsWith(".json")) {
+    const jsoncPath = path.replace(/\.json$/, ".jsonc");
+    return parseConfigFile(jsoncPath);
+  }
+  return { config: null };
+}
+function writeConfig(configPath, config) {
+  if (configPath.endsWith(".jsonc")) {
+    console.warn("[config-manager] Writing to .jsonc file - comments will not be preserved");
+  }
+  const tmpPath = `${configPath}.tmp`;
+  const bakPath = `${configPath}.bak`;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  if (existsSync2(configPath)) {
+    copyFileSync(configPath, bakPath);
+  }
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
+}
+async function addPluginToOpenCodeConfig() {
+  try {
+    ensureConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath: getConfigDir(),
+      error: `Failed to create config directory: ${err}`
+    };
+  }
+  const configPath = getExistingConfigPath();
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = config.plugin ?? [];
+    const filteredPlugins = plugins.filter((p) => p !== PACKAGE_NAME && !p.startsWith(`${PACKAGE_NAME}@`));
+    filteredPlugins.push(PACKAGE_NAME);
+    config.plugin = filteredPlugins;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode config: ${err}`
+    };
+  }
+}
+function writeLiteConfig(installConfig) {
+  const configPath = getLiteConfig();
+  try {
+    ensureConfigDir();
+    const config = generateLiteConfig(installConfig);
+    const tmpPath = `${configPath}.tmp`;
+    const bakPath = `${configPath}.bak`;
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    if (existsSync2(configPath)) {
+      copyFileSync(configPath, bakPath);
+    }
+    writeFileSync(tmpPath, content);
+    renameSync(tmpPath, configPath);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to write lite config: ${err}`
+    };
+  }
+}
+function disableDefaultAgents() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const agent = config.agent ?? {};
+    agent.explore = { disable: true };
+    agent.general = { disable: true };
+    config.agent = agent;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to disable default agents: ${err}`
+    };
+  }
+}
+function detectCurrentConfig() {
+  const result = {
+    isInstalled: false,
+    hasKimi: false,
+    hasOpenAI: false,
+    hasAnthropic: false,
+    hasCopilot: false,
+    hasZaiPlan: false,
+    hasAntigravity: false,
+    hasChutes: false,
+    hasOpencodeZen: false,
+    hasTmux: false
+  };
+  const { config } = parseConfig(getExistingConfigPath());
+  if (!config)
+    return result;
+  const plugins = config.plugin ?? [];
+  result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  result.hasAntigravity = plugins.some((p) => p.startsWith("opencode-antigravity-auth"));
+  const providers = config.provider;
+  result.hasKimi = !!providers?.kimi;
+  result.hasAnthropic = !!providers?.anthropic;
+  result.hasCopilot = !!providers?.["github-copilot"];
+  result.hasZaiPlan = !!providers?.["zai-coding-plan"];
+  result.hasChutes = !!providers?.chutes;
+  if (providers?.google)
+    result.hasAntigravity = true;
+  const { config: liteConfig } = parseConfig(getLiteConfig());
+  if (liteConfig && typeof liteConfig === "object") {
+    const configObj = liteConfig;
+    const presetName = configObj.preset;
+    const presets = configObj.presets;
+    const agents = presets?.[presetName];
+    if (agents) {
+      const models = Object.values(agents).map((a) => a?.model).filter(Boolean);
+      result.hasOpenAI = models.some((m) => m?.startsWith("openai/"));
+      result.hasAnthropic = models.some((m) => m?.startsWith("anthropic/"));
+      result.hasCopilot = models.some((m) => m?.startsWith("github-copilot/"));
+      result.hasZaiPlan = models.some((m) => m?.startsWith("zai-coding-plan/"));
+      result.hasOpencodeZen = models.some((m) => m?.startsWith("opencode/"));
+      if (models.some((m) => m?.startsWith("google/"))) {
+        result.hasAntigravity = true;
+      }
+      if (models.some((m) => m?.startsWith("chutes/"))) {
+        result.hasChutes = true;
+      }
+    }
+    if (configObj.tmux && typeof configObj.tmux === "object") {
+      const tmuxConfig = configObj.tmux;
+      result.hasTmux = tmuxConfig.enabled === true;
+    }
+  }
+  return result;
+}
+// src/cli/system.ts
+import { statSync as statSync2 } from "fs";
+var cachedOpenCodePath = null;
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    "opencode",
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    `${home}/.cargo/bin/opencode`,
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    `${home}/.yarn/bin/opencode`,
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode")
+      continue;
+    try {
+      const stat = statSync2(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {}
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const proc = Bun.spawn([opencodePath, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = Bun.spawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {}
+  return null;
+}
+function getOpenCodePath() {
+  const path = resolveOpenCodePath();
+  return path === "opencode" ? null : path;
+}
+// src/cli/custom-skills.ts
+var CUSTOM_SKILLS = [
+  {
+    name: "deepa-planning",
+    repo: "https://github.com/yourusername/opencode-deepa",
+    skillName: "deepa-planning",
+    allowedAgents: ["deepa"],
+    description: "Strategic planning and task decomposition for complex coding tasks"
+  }
+];
+function installCustomSkill(skill) {
+  const args = [
+    "skills",
+    "add",
+    skill.repo,
+    "--skill",
+    skill.skillName,
+    "-a",
+    "opencode",
+    "-y",
+    "--global"
+  ];
+  try {
+    const result = Bun.spawnSync(["npx", ...args]);
+    if (result.exitCode !== 0) {
+      return false;
+    }
+    if (skill.postInstallCommands && skill.postInstallCommands.length > 0) {
+      console.log(`Running post-install commands for ${skill.name}...`);
+      for (const cmd of skill.postInstallCommands) {
+        console.log(`> ${cmd}`);
+        const [command, ...cmdArgs] = cmd.split(" ");
+        const cmdResult = Bun.spawnSync([command, ...cmdArgs]);
+        if (cmdResult.exitCode !== 0) {
+          console.warn(`Post-install command failed: ${cmd}`);
+        }
+      }
+    }
+    return true;
+  } catch (error) {
+    console.error(`Failed to install skill: ${skill.name}`, error);
+    return false;
+  }
+}
+
+// src/cli/install.ts
+var GREEN = "\x1B[32m";
+var BLUE = "\x1B[34m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var SYMBOLS = {
+  check: `${GREEN}\u2713${RESET}`,
+  cross: `${RED}\u2717${RESET}`,
+  arrow: `${BLUE}\u2192${RESET}`,
+  bullet: `${DIM}\u2022${RESET}`,
+  info: `${BLUE}\u2139${RESET}`,
+  warn: `${YELLOW}\u26A0${RESET}`,
+  star: `${YELLOW}\u2605${RESET}`
+};
+function printHeader(isUpdate) {
+  console.log();
+  console.log(`${BOLD}opencode-deepa ${isUpdate ? "Update" : "Install"}${RESET}`);
+  console.log("=".repeat(30));
+  console.log();
+}
+function printStep(step, total, message) {
+  console.log(`${DIM}[${step}/${total}]${RESET} ${message}`);
+}
+function printSuccess(message) {
+  console.log(`${SYMBOLS.check} ${message}`);
+}
+function printError(message) {
+  console.log(`${SYMBOLS.cross} ${RED}${message}${RESET}`);
+}
+function printInfo(message) {
+  console.log(`${SYMBOLS.info} ${message}`);
+}
+async function checkOpenCodeInstalled() {
+  const installed = await isOpenCodeInstalled();
+  if (!installed) {
+    printError("OpenCode is not installed on this system.");
+    printInfo("Install it with:");
+    console.log(`     ${BLUE}curl -fsSL https://opencode.ai/install | bash${RESET}`);
+    console.log();
+    printInfo("Or if already installed, add it to your PATH:");
+    console.log(`     ${BLUE}export PATH="$HOME/.local/bin:$PATH"${RESET}`);
+    console.log(`     ${BLUE}export PATH="$HOME/.opencode/bin:$PATH"${RESET}`);
+    return { ok: false };
+  }
+  const version = await getOpenCodeVersion();
+  const path = getOpenCodePath();
+  printSuccess(`OpenCode ${version ?? ""} detected${path ? ` (${DIM}${path}${RESET})` : ""}`);
+  return { ok: true, version: version ?? undefined, path: path ?? undefined };
+}
+function handleStepResult(result, successMsg) {
+  if (!result.success) {
+    printError(`Failed: ${result.error}`);
+    return false;
+  }
+  printSuccess(`${successMsg} ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`);
+  return true;
+}
+function formatConfigSummary() {
+  const lines = [];
+  lines.push(`${BOLD}Configuration Summary${RESET}`);
+  lines.push("");
+  lines.push(`  ${BOLD}Preset:${RESET} ${BLUE}openai${RESET}`);
+  lines.push(`  ${SYMBOLS.check} OpenAI (default)`);
+  lines.push(`  ${DIM}\u25CB Kimi \u2014 see docs/provider-configurations.md${RESET}`);
+  lines.push(`  ${DIM}\u25CB GitHub Copilot \u2014 see docs/provider-configurations.md${RESET}`);
+  lines.push(`  ${DIM}\u25CB ZAI Coding Plan \u2014 see docs/provider-configurations.md${RESET}`);
+  return lines.join(`
+`);
+}
+async function runInstall(config) {
+  const detected = detectCurrentConfig();
+  const isUpdate = detected.isInstalled;
+  printHeader(isUpdate);
+  let totalSteps = 4;
+  if (config.installSkills)
+    totalSteps += 1;
+  if (config.installCustomSkills)
+    totalSteps += 1;
+  let step = 1;
+  printStep(step++, totalSteps, "Checking OpenCode installation...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping OpenCode check");
+  } else {
+    const { ok } = await checkOpenCodeInstalled();
+    if (!ok)
+      return 1;
+  }
+  {
+    printStep(step++, totalSteps, "Adding opencode-deepa plugin...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - skipping plugin installation");
+    } else {
+      const pluginResult = await addPluginToOpenCodeConfig();
+      if (!handleStepResult(pluginResult, "Plugin added"))
+        return 1;
+    }
+  }
+  {
+    printStep(step++, totalSteps, "Disabling OpenCode default agents...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - skipping agent disabling");
+    } else {
+      const agentResult = disableDefaultAgents();
+      if (!handleStepResult(agentResult, "Default agents disabled"))
+        return 1;
+    }
+  }
+  printStep(step++, totalSteps, "Writing opencode-deepa configuration...");
+  if (config.dryRun) {
+    const liteConfig = generateLiteConfig(config);
+    printInfo("Dry run mode - configuration that would be written:");
+    console.log(`
+${JSON.stringify(liteConfig, null, 2)}
+`);
+  } else {
+    const liteResult = writeLiteConfig(config);
+    if (!handleStepResult(liteResult, "Config written"))
+      return 1;
+  }
+  if (config.installSkills) {
+    printStep(step++, totalSteps, "Installing recommended skills...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - would install skills:");
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      let skillsInstalled = 0;
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`Installing ${skill.name}...`);
+        if (installSkill(skill)) {
+          printSuccess(`Installed: ${skill.name}`);
+          skillsInstalled++;
+        } else {
+          printInfo(`Skipped: ${skill.name} (already installed)`);
+        }
+      }
+      printSuccess(`${skillsInstalled}/${RECOMMENDED_SKILLS.length} skills processed`);
+    }
+  }
+  if (config.installCustomSkills) {
+    printStep(step++, totalSteps, "Installing custom skills...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - would install custom skills:");
+      for (const skill of CUSTOM_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      let customSkillsInstalled = 0;
+      for (const skill of CUSTOM_SKILLS) {
+        printInfo(`Installing ${skill.name}...`);
+        if (installCustomSkill(skill)) {
+          printSuccess(`Installed: ${skill.name}`);
+          customSkillsInstalled++;
+        } else {
+          printInfo(`Skipped: ${skill.name} (already installed)`);
+        }
+      }
+      printSuccess(`${customSkillsInstalled}/${CUSTOM_SKILLS.length} custom skills processed`);
+    }
+  }
+  console.log();
+  console.log(formatConfigSummary());
+  console.log();
+  console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${isUpdate ? "Configuration updated!" : "Installation complete!"}${RESET}`);
+  console.log();
+  console.log(`${BOLD}Next steps:${RESET}`);
+  console.log();
+  console.log(`  1. Start OpenCode:`);
+  console.log(`     ${BLUE}$ opencode${RESET}`);
+  console.log();
+  console.log(`${BOLD}Default configuration uses OpenAI models (gpt-5.4 / gpt-5-codex).${RESET}`);
+  console.log(`${BOLD}For alternative providers (Kimi, GitHub Copilot, ZAI Coding Plan), see:${RESET}`);
+  console.log(`  ${BLUE}https://github.com/yourusername/opencode-deepa/blob/main/docs/provider-configurations.md${RESET}`);
+  console.log();
+  return 0;
+}
+async function install(args) {
+  const config = {
+    hasTmux: args.tmux === "yes",
+    installSkills: args.skills === "yes",
+    installCustomSkills: args.skills === "yes",
+    dryRun: args.dryRun
+  };
+  return runInstall(config);
+}
+
+// src/cli/index.ts
+function parseArgs(args) {
+  const result = {
+    tui: true
+  };
+  for (const arg of args) {
+    if (arg === "--no-tui") {
+      result.tui = false;
+    } else if (arg.startsWith("--tmux=")) {
+      result.tmux = arg.split("=")[1];
+    } else if (arg.startsWith("--skills=")) {
+      result.skills = arg.split("=")[1];
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`
+opencode-deepa installer
+
+Usage: bunx opencode-deepa install [OPTIONS]
+
+Options:
+  --tmux=yes|no          Enable tmux integration (yes/no)
+  --skills=yes|no        Install recommended skills (yes/no)
+  --no-tui               Non-interactive mode
+  --dry-run              Simulate install without writing files
+  -h, --help             Show this help message
+
+The installer generates an OpenAI configuration by default.
+For alternative providers, see docs/provider-configurations.md.
+
+Examples:
+  bunx opencode-deepa install
+  bunx opencode-deepa install --no-tui --tmux=no --skills=yes
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "install") {
+    const hasSubcommand = args[0] === "install";
+    const installArgs = parseArgs(args.slice(hasSubcommand ? 1 : 0));
+    const exitCode = await install(installArgs);
+    process.exit(exitCode);
+  } else if (args[0] === "-h" || args[0] === "--help") {
+    printHelp();
+    process.exit(0);
+  } else {
+    console.error(`Unknown command: ${args[0]}`);
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/cli/install.d.ts

@@ -0,0 +1,3 @@
+import type { InstallArgs } from './types';
+export declare function install(args: InstallArgs): Promise<number>;
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/cli/install.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAqB,WAAW,EAAiB,MAAM,SAAS,CAAC;AAwO7E,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAShE"}