@zcy2nn/agent-forge 1.0.1

package/dist/cli/index.js

@@ -0,0 +1,1932 @@
+#!/usr/bin/env bun
+// @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/doctor.ts
+import * as fs2 from "node:fs";
+import { z as z3 } from "zod";
+
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/cli/config-io.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
+  readFileSync,
+  renameSync,
+  statSync as statSync2,
+  writeFileSync
+} from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
+
+// src/cli/paths.ts
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getCustomTuiConfigPath() {
+  const configPath = process.env.OPENCODE_TUI_CONFIG?.trim();
+  return configPath || undefined;
+}
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+function getConfigJson() {
+  return getOpenCodeConfigPaths()[0];
+}
+function getConfigJsonc() {
+  return getOpenCodeConfigPaths()[1];
+}
+function getLiteConfig() {
+  return join(getConfigDir(), "agent-forge.json");
+}
+function getLiteConfigJsonc() {
+  return join(getConfigDir(), "agent-forge.jsonc");
+}
+function getTuiConfig() {
+  const customConfigPath = getCustomTuiConfigPath();
+  if (customConfigPath)
+    return customConfigPath;
+  return join(getConfigDir(), "tui.json");
+}
+function getTuiConfigJsonc() {
+  return join(getConfigDir(), "tui.jsonc");
+}
+function getExistingLiteConfigPath() {
+  const jsonPath = getLiteConfig();
+  if (existsSync(jsonPath))
+    return jsonPath;
+  const jsoncPath = getLiteConfigJsonc();
+  if (existsSync(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+function getExistingTuiConfigPath() {
+  const customConfigPath = getCustomTuiConfigPath();
+  if (customConfigPath)
+    return customConfigPath;
+  const jsonPath = join(getConfigDir(), "tui.json");
+  if (existsSync(jsonPath))
+    return jsonPath;
+  const jsoncPath = getTuiConfigJsonc();
+  if (existsSync(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+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 });
+  }
+}
+function ensureTuiConfigDir() {
+  const configDir = dirname(getTuiConfig());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+function ensureOpenCodeConfigDir() {
+  const configDir = dirname(getConfigJson());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+// src/config/constants.ts
+var SUBAGENT_NAMES = [
+  "researcher",
+  "reviewer",
+  "implementer",
+  "council",
+  "councillor"
+];
+var ORCHESTRATOR_NAME = "orchestrator";
+var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var PROTECTED_AGENTS = new Set([
+  "orchestrator",
+  "researcher",
+  "reviewer",
+  "implementer",
+  "councillor"
+]);
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+var MAX_POLL_TIME_MS = 5 * 60 * 1000;
+// src/config/council-schema.ts
+import { z } from "zod";
+var ModelIdSchema = z.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.4-mini")');
+var CouncillorConfigSchema = z.object({
+  model: ModelIdSchema.describe('Model ID in provider/model format (e.g. "openai/gpt-5.4-mini")'),
+  variant: z.string().optional(),
+  prompt: z.string().optional().describe("Optional role/guidance injected into the councillor user prompt")
+});
+var CouncilPresetSchema = z.record(z.string(), z.record(z.string(), z.unknown())).transform((entries, ctx) => {
+  const councillors = {};
+  for (const [key, raw] of Object.entries(entries)) {
+    if (key === "master")
+      continue;
+    if (key === "councillors" && typeof raw === "object" && raw !== null) {
+      for (const [innerKey, innerRaw] of Object.entries(raw)) {
+        const innerParsed = CouncillorConfigSchema.safeParse(innerRaw);
+        if (!innerParsed.success) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Invalid councillor "${innerKey}" (nested under legacy "councillors" key): ${innerParsed.error.issues.map((i) => i.message).join(", ")}`
+          });
+          return z.NEVER;
+        }
+        councillors[innerKey] = innerParsed.data;
+      }
+      continue;
+    }
+    const parsed = CouncillorConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid councillor "${key}": ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      });
+      return z.NEVER;
+    }
+    councillors[key] = parsed.data;
+  }
+  return councillors;
+});
+var CouncillorExecutionModeSchema = z.enum(["parallel", "serial"]).default("parallel").describe('Execution mode for councillors. Use "serial" for single-model systems to avoid conflicts. ' + 'Use "parallel" for multi-model systems for faster execution.');
+var CouncilConfigSchema = z.object({
+  presets: z.record(z.string(), CouncilPresetSchema),
+  timeout: z.number().min(0).default(180000),
+  default_preset: z.string().default("default"),
+  councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
+  councillor_retries: z.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries."),
+  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly."),
+  master_timeout: z.unknown().optional().describe('DEPRECATED — ignored. Use "timeout" instead.'),
+  master_fallback: z.unknown().optional().describe("DEPRECATED — ignored. No separate master session.")
+}).transform((data) => {
+  const deprecated = [];
+  if (data.master !== undefined)
+    deprecated.push("master");
+  if (data.master_timeout !== undefined)
+    deprecated.push("master_timeout");
+  if (data.master_fallback !== undefined)
+    deprecated.push("master_fallback");
+  const legacyMasterModel = typeof data.master === "object" && data.master !== null && "model" in data.master && typeof data.master.model === "string" ? data.master.model : undefined;
+  return {
+    presets: data.presets,
+    timeout: data.timeout,
+    default_preset: data.default_preset,
+    councillor_execution_mode: data.councillor_execution_mode,
+    councillor_retries: data.councillor_retries,
+    _deprecated: deprecated.length > 0 ? deprecated : undefined,
+    _legacyMasterModel: legacyMasterModel
+  };
+});
+// src/config/schema.ts
+import { z as z2 } from "zod";
+var ProviderModelIdSchema = z2.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
+var ManualAgentPlanSchema = z2.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = z2.object({
+  orchestrator: ManualAgentPlanSchema,
+  researcher: ManualAgentPlanSchema,
+  reviewer: ManualAgentPlanSchema,
+  implementer: ManualAgentPlanSchema
+}).strict();
+var AgentModelChainSchema = z2.array(z2.string()).min(1);
+var FallbackChainsSchema = z2.object({
+  orchestrator: AgentModelChainSchema.optional(),
+  researcher: AgentModelChainSchema.optional(),
+  reviewer: AgentModelChainSchema.optional(),
+  implementer: AgentModelChainSchema.optional()
+}).catchall(AgentModelChainSchema);
+var AgentOverrideConfigSchema = z2.object({
+  model: z2.union([
+    z2.string(),
+    z2.array(z2.union([
+      z2.string(),
+      z2.object({
+        id: z2.string(),
+        variant: z2.string().optional()
+      })
+    ])).min(1)
+  ]).optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  variant: z2.string().optional().catch(undefined),
+  skills: z2.array(z2.string()).optional(),
+  mcps: z2.array(z2.string()).optional(),
+  prompt: z2.string().min(1).optional(),
+  orchestratorPrompt: z2.string().min(1).optional(),
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  displayName: z2.string().min(1).optional()
+}).strict();
+var MultiplexerTypeSchema = z2.enum(["auto", "tmux", "zellij", "none"]);
+var MultiplexerLayoutSchema = z2.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical"
+]);
+var TmuxLayoutSchema = MultiplexerLayoutSchema;
+var MultiplexerConfigSchema = z2.object({
+  type: MultiplexerTypeSchema.default("none"),
+  layout: MultiplexerLayoutSchema.default("main-vertical"),
+  main_pane_size: z2.number().min(20).max(80).default(60)
+});
+var TmuxConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  layout: TmuxLayoutSchema.default("main-vertical"),
+  main_pane_size: z2.number().min(20).max(80).default(60)
+});
+var PresetSchema = z2.record(z2.string(), AgentOverrideConfigSchema);
+var WebsearchConfigSchema = z2.object({
+  provider: z2.enum(["exa", "tavily"]).default("exa")
+});
+var McpNameSchema = z2.enum(["websearch", "context7", "grep_app"]);
+var InterviewConfigSchema = z2.object({
+  maxQuestions: z2.number().int().min(1).max(10).default(2),
+  outputFolder: z2.string().min(1).default("interview"),
+  autoOpenBrowser: z2.boolean().default(true).describe("Automatically open the interview UI in your default browser during interactive runs. Disabled automatically in tests and CI."),
+  port: z2.number().int().min(0).max(65535).default(0),
+  dashboard: z2.boolean().default(false)
+});
+var SessionManagerConfigSchema = z2.object({
+  maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
+  readContextMinLines: z2.number().int().min(0).max(1000).default(10),
+  readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
+});
+var DivoomConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  python: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/.venv/bin/python"),
+  script: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/tools/divoom_send.py"),
+  size: z2.number().int().min(1).max(1024).default(128),
+  fps: z2.number().int().min(1).max(60).default(8),
+  speed: z2.number().int().min(1).max(1e4).default(125),
+  maxFrames: z2.number().int().min(1).max(500).default(24),
+  posterizeBits: z2.number().int().min(1).max(8).default(3),
+  gifs: z2.record(z2.string(), z2.string().min(1)).optional()
+});
+var TodoContinuationConfigSchema = z2.object({
+  maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
+  cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
+  autoEnable: z2.boolean().default(false).describe("Automatically enable auto-continue when the orchestrator session has enough todos"),
+  autoEnableThreshold: z2.number().int().min(1).max(50).default(4).describe("Number of todos that triggers auto-enable (only used when autoEnable is true)")
+});
+var FailoverConfigSchema = z2.object({
+  enabled: z2.boolean().default(true),
+  timeoutMs: z2.number().min(0).default(15000),
+  retryDelayMs: z2.number().min(0).default(500),
+  chains: FallbackChainsSchema.default({}),
+  retry_on_empty: z2.boolean().default(true).describe("When true (default), empty provider responses are treated as failures, " + "triggering fallback/retry. Set to false to treat them as successes.")
+});
+function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
+  for (const [name, override] of Object.entries(overrides)) {
+    const isBuiltIn = ALL_AGENT_NAMES.includes(name);
+    if (!isBuiltIn) {
+      continue;
+    }
+    if (override.prompt !== undefined) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [...pathPrefix, name, "prompt"],
+        message: "prompt is only supported for custom agents"
+      });
+    }
+    if (override.orchestratorPrompt !== undefined) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [...pathPrefix, name, "orchestratorPrompt"],
+        message: "orchestratorPrompt is only supported for custom agents"
+      });
+    }
+  }
+}
+var PluginConfigSchema = z2.object({
+  preset: z2.string().optional(),
+  setDefaultAgent: z2.boolean().optional(),
+  scoringEngineVersion: z2.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: z2.boolean().optional(),
+  autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
+  manualPlan: ManualPlanSchema.optional(),
+  presets: z2.record(z2.string(), PresetSchema).optional(),
+  agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
+  disabled_agents: z2.array(z2.string()).optional().describe("Agent names to disable completely. " + "Disabled agents are not instantiated and cannot be delegated to. " + "Orchestrator, researcher, reviewer, implementer and council internal agents (councillor) cannot be disabled. " + "By default, only council is disabled."),
+  disabled_mcps: z2.array(z2.string()).optional(),
+  multiplexer: MultiplexerConfigSchema.optional(),
+  tmux: TmuxConfigSchema.optional(),
+  websearch: WebsearchConfigSchema.optional(),
+  interview: InterviewConfigSchema.optional(),
+  sessionManager: SessionManagerConfigSchema.optional(),
+  divoom: DivoomConfigSchema.optional(),
+  todoContinuation: TodoContinuationConfigSchema.optional(),
+  fallback: FailoverConfigSchema.optional(),
+  council: CouncilConfigSchema.optional()
+}).superRefine((value, ctx) => {
+  if (value.agents) {
+    validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
+  }
+  if (value.presets) {
+    for (const [presetName, preset] of Object.entries(value.presets)) {
+      validateCustomOnlyPromptFields(preset, ctx, ["presets", presetName]);
+    }
+  }
+});
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  orchestrator: ["*", "!context7"],
+  researcher: ["websearch", "context7", "grep_app"],
+  reviewer: [],
+  implementer: [],
+  council: [],
+  councillor: []
+};
+
+// src/cli/custom-skills.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  statSync
+} from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var CUSTOM_SKILLS = [
+  {
+    name: "simplify",
+    description: "Code simplification and readability-focused refactoring",
+    allowedAgents: ["reviewer"],
+    sourcePath: "src/skills/simplify"
+  },
+  {
+    name: "codemap",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/codemap"
+  },
+  {
+    name: "brainstorming",
+    description: "Turn ideas into designs through collaborative dialogue before implementation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/brainstorming"
+  },
+  {
+    name: "writing-plans",
+    description: "Create comprehensive implementation plans from specs before touching code",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/writing-plans"
+  },
+  {
+    name: "executing-plans",
+    description: "Execute written implementation plans with review checkpoints",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/executing-plans"
+  },
+  {
+    name: "subagent-driven-development",
+    description: "Execute plans by dispatching fresh subagent per task with two-stage review",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/subagent-driven-development"
+  },
+  {
+    name: "dispatching-parallel-agents",
+    description: "Dispatch parallel agents for independent tasks without shared state",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/dispatching-parallel-agents"
+  },
+  {
+    name: "using-git-worktrees",
+    description: "Create isolated git worktrees before executing implementation plans",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/using-git-worktrees"
+  },
+  {
+    name: "finishing-a-development-branch",
+    description: "Guide completion of development work with structured merge/PR options",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/finishing-a-development-branch"
+  },
+  {
+    name: "requesting-code-review",
+    description: "Dispatch code reviewer subagent to catch issues before merging",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/requesting-code-review"
+  },
+  {
+    name: "test-driven-development",
+    description: "Write failing tests first, then minimal code to pass, before any implementation",
+    allowedAgents: ["implementer"],
+    sourcePath: "src/skills/test-driven-development"
+  },
+  {
+    name: "verification-before-completion",
+    description: "Run verification commands and confirm output before claiming work is complete",
+    allowedAgents: ["implementer"],
+    sourcePath: "src/skills/verification-before-completion"
+  },
+  {
+    name: "systematic-debugging",
+    description: "Find root cause before attempting fixes for any bug or test failure",
+    allowedAgents: ["reviewer"],
+    sourcePath: "src/skills/systematic-debugging"
+  },
+  {
+    name: "receiving-code-review",
+    description: "Evaluate code review feedback with technical rigor before implementing suggestions",
+    allowedAgents: ["reviewer"],
+    sourcePath: "src/skills/receiving-code-review"
+  },
+  {
+    name: "writing-skills",
+    description: "Create and edit skills using TDD methodology for process documentation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/writing-skills"
+  }
+];
+function getCustomSkillsDir() {
+  return join2(getConfigDir(), "skills");
+}
+function copyDirRecursive(src, dest) {
+  if (!existsSync2(dest)) {
+    mkdirSync2(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join2(src, entry);
+    const destPath = join2(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname2(destPath);
+      if (!existsSync2(destDir)) {
+        mkdirSync2(destDir, { recursive: true });
+      }
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function installCustomSkill(skill) {
+  try {
+    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+    const sourcePath = join2(packageRoot, skill.sourcePath);
+    const targetPath = join2(getCustomSkillsDir(), skill.name);
+    if (!existsSync2(sourcePath)) {
+      console.error(`Custom skill source not found: ${sourcePath}`);
+      return false;
+    }
+    copyDirRecursive(sourcePath, targetPath);
+    return true;
+  } catch (error) {
+    console.error(`Failed to install custom skill: ${skill.name}`, error);
+    return false;
+  }
+}
+
+// src/cli/skills.ts
+import { spawnSync } from "node:child_process";
+var RECOMMENDED_SKILLS = [
+  {
+    name: "agent-browser",
+    repo: "https://github.com/vercel-labs/agent-browser",
+    skillName: "agent-browser",
+    allowedAgents: ["implementer"],
+    description: "High-performance browser automation",
+    postInstallCommands: [
+      "npm install -g agent-browser",
+      "agent-browser install"
+    ]
+  }
+];
+function installSkill(skill) {
+  const args = [
+    "skills",
+    "add",
+    skill.repo,
+    "--skill",
+    skill.skillName,
+    "-a",
+    "opencode",
+    "-y",
+    "--global"
+  ];
+  try {
+    const result = spawnSync("npx", args, { stdio: "inherit" });
+    if (result.status !== 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 = spawnSync(command, cmdArgs, { stdio: "inherit" });
+        if (cmdResult.status !== 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/providers.ts
+var SCHEMA_URL = "https://cnb.cool/zcyoop/ai-assistant/agent-forge/-/git/raw/master/agent-forge.schema.json";
+var GENERATED_PRESETS = ["openai", "opencode-go"];
+var MODEL_MAPPINGS = {
+  openai: {
+    orchestrator: { model: "openai/gpt-5.5" },
+    reviewer: { model: "openai/gpt-5.5", variant: "high" },
+    researcher: { model: "openai/gpt-5.4-mini", variant: "low" },
+    implementer: { model: "openai/gpt-5.4-mini", variant: "low" }
+  },
+  kimi: {
+    orchestrator: { model: "kimi-for-coding/k2p5" },
+    reviewer: { model: "kimi-for-coding/k2p5", variant: "high" },
+    researcher: { model: "kimi-for-coding/k2p5", variant: "low" },
+    implementer: { model: "kimi-for-coding/k2p5", variant: "low" }
+  },
+  copilot: {
+    orchestrator: { model: "github-copilot/claude-opus-4.6" },
+    reviewer: { model: "github-copilot/claude-opus-4.6", variant: "high" },
+    researcher: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    implementer: { model: "github-copilot/claude-sonnet-4.6", variant: "low" }
+  },
+  "zai-plan": {
+    orchestrator: { model: "zai-coding-plan/glm-5" },
+    reviewer: { model: "zai-coding-plan/glm-5", variant: "high" },
+    researcher: { model: "zai-coding-plan/glm-5", variant: "low" },
+    implementer: { model: "zai-coding-plan/glm-5", variant: "low" }
+  },
+  "opencode-go": {
+    orchestrator: { model: "opencode-go/glm-5.1" },
+    reviewer: { model: "opencode-go/deepseek-v4-pro", variant: "max" },
+    council: { model: "opencode-go/deepseek-v4-pro", variant: "high" },
+    researcher: { model: "opencode-go/minimax-m2.7" },
+    implementer: { model: "opencode-go/deepseek-v4-flash", variant: "high" }
+  }
+};
+function isGeneratedPresetName(value) {
+  return GENERATED_PRESETS.includes(value);
+}
+function getGeneratedPresetNames() {
+  return [...GENERATED_PRESETS];
+}
+function generateLiteConfig(installConfig) {
+  const preset = installConfig.preset ?? "openai";
+  if (!isGeneratedPresetName(preset)) {
+    throw new Error(`Unsupported preset "${preset}". Available generated presets: ${getGeneratedPresetNames().join(", ")}`);
+  }
+  const config = {
+    $schema: SCHEMA_URL,
+    preset,
+    presets: {}
+  };
+  if (preset === "opencode-go") {
+    config.disabled_agents = [];
+  }
+  const createAgentConfig = (agentName, modelInfo) => {
+    const isOrchestrator = agentName === "orchestrator";
+    const skills = isOrchestrator ? ["*"] : [
+      ...RECOMMENDED_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.skillName),
+      ...CUSTOM_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.name)
+    ];
+    if (agentName === "implementer" && !skills.includes("agent-browser")) {
+      skills.push("agent-browser");
+    }
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant,
+      skills,
+      mcps: DEFAULT_AGENT_MCPS[agentName] ?? []
+    };
+  };
+  const buildPreset = (mappingName) => {
+    const mapping = MODEL_MAPPINGS[mappingName];
+    return Object.fromEntries(Object.entries(mapping).map(([agentName, modelInfo]) => [
+      agentName,
+      createAgentConfig(agentName, modelInfo)
+    ]));
+  };
+  const presets = config.presets;
+  for (const presetName of GENERATED_PRESETS) {
+    presets[presetName] = buildPreset(presetName);
+  }
+  if (installConfig.hasTmux) {
+    config.tmux = {
+      enabled: true,
+      layout: "main-vertical",
+      main_pane_size: 60
+    };
+  }
+  return config;
+}
+
+// src/cli/config-io.ts
+var PACKAGE_NAME = "@zcy2nn/agent-forge";
+function isString(value) {
+  return typeof value === "string";
+}
+function getPlugins(config) {
+  return Array.isArray(config.plugin) ? config.plugin : [];
+}
+function getPluginEntries(config) {
+  return getPlugins(config).filter(isString);
+}
+function getPluginSpec(entry) {
+  if (isString(entry))
+    return entry;
+  if (!Array.isArray(entry))
+    return;
+  const spec = entry[0];
+  return isString(spec) ? spec : undefined;
+}
+function normalizePathForMatch(path) {
+  return path.replaceAll("\\", "/");
+}
+function findPackageRoot(startPath) {
+  let currentPath = dirname3(startPath);
+  while (true) {
+    const packageJsonPath = join3(currentPath, "package.json");
+    if (existsSync3(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.name === PACKAGE_NAME) {
+          return currentPath;
+        }
+      } catch {}
+    }
+    const parentPath = dirname3(currentPath);
+    if (parentPath === currentPath) {
+      return null;
+    }
+    currentPath = parentPath;
+  }
+}
+function isPackageManagerInstall(path) {
+  const normalizedPath = normalizePathForMatch(path);
+  return normalizedPath.includes(`/node_modules/${PACKAGE_NAME}`);
+}
+function isLocalPackageRootEntry(entry) {
+  if (!entry || entry.startsWith("file://")) {
+    return false;
+  }
+  const packageJsonPath = join3(entry, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.name === PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function isPluginEntry(entry) {
+  return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`) || entry.startsWith("file://") && entry.includes(PACKAGE_NAME) || isLocalPackageRootEntry(entry);
+}
+function isMatchingPluginEntry(entry) {
+  const spec = getPluginSpec(entry);
+  return spec ? isPluginEntry(spec) : false;
+}
+function getPluginEntry() {
+  const cliEntryPath = process.argv[1];
+  if (!cliEntryPath) {
+    return PACKAGE_NAME;
+  }
+  try {
+    const packageRoot = findPackageRoot(cliEntryPath);
+    if (!packageRoot || isPackageManagerInstall(packageRoot)) {
+      return PACKAGE_NAME;
+    }
+    return packageRoot;
+  } catch {
+    return PACKAGE_NAME;
+  }
+}
+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 (!existsSync3(path))
+      return { config: null };
+    const stat = statSync2(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 (existsSync3(configPath)) {
+    copyFileSync2(configPath, bakPath);
+  }
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
+}
+async function addPluginToOpenCodeConfig() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`
+    };
+  }
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = getPlugins(config);
+    const pluginEntry = getPluginEntry();
+    const filteredPlugins = plugins.filter((plugin) => !isMatchingPluginEntry(plugin));
+    filteredPlugins.push(pluginEntry);
+    config.plugin = filteredPlugins;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode config: ${err}`
+    };
+  }
+}
+async function addPluginToOpenCodeTuiConfig() {
+  const configPath = getExistingTuiConfigPath();
+  try {
+    ensureTuiConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`
+    };
+  }
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse TUI config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = getPlugins(config);
+    const pluginEntry = getPluginEntry();
+    const filteredPlugins = plugins.filter((plugin) => !isMatchingPluginEntry(plugin));
+    filteredPlugins.push(pluginEntry);
+    config.plugin = filteredPlugins;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode TUI config: ${err}`
+    };
+  }
+}
+function writeLiteConfig(installConfig, targetPath) {
+  const configPath = targetPath ?? getLiteConfig();
+  try {
+    ensureConfigDir();
+    const config = generateLiteConfig(installConfig);
+    const tmpPath = `${configPath}.tmp`;
+    const bakPath = `${configPath}.bak`;
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    if (existsSync3(configPath)) {
+      copyFileSync2(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 {
+    ensureOpenCodeConfigDir();
+    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 enableLspByDefault() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    if (config.lsp === undefined) {
+      config.lsp = true;
+      writeConfig(configPath, config);
+    }
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to enable LSP: ${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 = getPluginEntries(config);
+  result.isInstalled = plugins.some((p) => isPluginEntry(p));
+  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/config/loader.ts
+function findConfigPath(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (fs.existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+function findConfigPathInDirs(configDirs, baseName) {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function findPluginConfigPaths(directory) {
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "agent-forge");
+  const projectConfigBasePath = path.join(directory, ".opencode", "agent-forge");
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  return { userConfigPath, projectConfigPath };
+}
+function mergePluginConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    agents: deepMerge(base.agents, override.agents),
+    tmux: deepMerge(base.tmux, override.tmux),
+    multiplexer: deepMerge(base.multiplexer, override.multiplexer),
+    interview: deepMerge(base.interview, override.interview),
+    sessionManager: deepMerge(base.sessionManager, override.sessionManager),
+    divoom: deepMerge(base.divoom, override.divoom),
+    fallback: deepMerge(base.fallback, override.fallback),
+    council: deepMerge(base.council, override.council)
+  };
+}
+function deepMerge(base, override) {
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(baseVal, overrideVal);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+
+// src/cli/doctor.ts
+function parseDoctorArgs(args) {
+  const result = {};
+  for (const arg of args) {
+    if (arg === "--json") {
+      result.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else {
+      result.error ??= `Unknown doctor option: ${arg}`;
+    }
+  }
+  return result;
+}
+function checkConfigFile(scope, configPath) {
+  if (configPath === null) {
+    return { scope, path: null, exists: false, ok: true };
+  }
+  try {
+    const stat = fs2.statSync(configPath);
+    if (stat.size === 0) {
+      return {
+        scope,
+        path: configPath,
+        exists: true,
+        ok: false,
+        error: {
+          kind: "invalid-json",
+          message: "Empty file is not valid JSON"
+        }
+      };
+    }
+    const content = fs2.readFileSync(configPath, "utf-8");
+    const rawConfig = JSON.parse(stripJsonComments(content));
+    const parseResult = PluginConfigSchema.safeParse(rawConfig);
+    if (!parseResult.success) {
+      return {
+        scope,
+        path: configPath,
+        exists: true,
+        ok: false,
+        error: {
+          kind: "invalid-schema",
+          message: z3.prettifyError(parseResult.error),
+          issues: parseResult.error.issues
+        }
+      };
+    }
+    return {
+      scope,
+      path: configPath,
+      exists: true,
+      ok: true,
+      config: parseResult.data
+    };
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      return {
+        scope,
+        path: configPath,
+        exists: true,
+        ok: false,
+        error: {
+          kind: "invalid-json",
+          message: err.message
+        }
+      };
+    } else if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return {
+        scope,
+        path: configPath,
+        exists: false,
+        ok: false,
+        error: {
+          kind: "read-error",
+          message: "File was not found while reading"
+        }
+      };
+    }
+    return {
+      scope,
+      path: configPath,
+      exists: true,
+      ok: false,
+      error: {
+        kind: "read-error",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+function checkPreset(mergedConfig) {
+  const envPreset = process.env.OH_MY_OPENCODE_SLIM_PRESET;
+  const presetName = envPreset || mergedConfig.preset;
+  if (presetName === undefined) {
+    return;
+  }
+  if (!mergedConfig.presets?.[presetName]) {
+    return {
+      preset: presetName,
+      ok: false,
+      error: {
+        kind: "missing-preset",
+        message: `Preset "${presetName}" not found in config`
+      }
+    };
+  }
+  return { preset: presetName, ok: true };
+}
+function getMergedConfig(userConfig, projectConfig) {
+  return projectConfig ? mergePluginConfigs(userConfig ?? {}, projectConfig) : userConfig ?? {};
+}
+function runDoctorCheck(cwd) {
+  const { userConfigPath, projectConfigPath } = findPluginConfigPaths(cwd);
+  const userCheck = checkConfigFile("user", userConfigPath);
+  const projectCheck = checkConfigFile("project", projectConfigPath);
+  const configs = [userCheck, projectCheck];
+  const hasInvalidConfig = configs.some((c) => !c.ok);
+  let presetCheckResult;
+  if (!hasInvalidConfig) {
+    const mergedConfig = getMergedConfig(userCheck.config, projectCheck.config);
+    presetCheckResult = checkPreset(mergedConfig);
+  }
+  return {
+    ok: configs.every((c) => c.ok) && (!presetCheckResult || presetCheckResult.ok),
+    project: cwd,
+    configs,
+    presetCheck: presetCheckResult
+  };
+}
+function formatHumanDoctorResult(result) {
+  const lines = [];
+  lines.push(`Project: ${result.project}`);
+  lines.push("");
+  for (const config of result.configs) {
+    if (config.path === null) {
+      lines.push(`[${config.scope}] No config file found`);
+    } else {
+      const status = config.ok ? "✓" : "✗";
+      lines.push(`[${config.scope}] ${config.path} ${status}`);
+      if (!config.ok && config.error) {
+        if (config.error.kind === "invalid-json") {
+          lines.push(`  Invalid JSON: ${config.error.message}`);
+        } else if (config.error.kind === "invalid-schema") {
+          lines.push("  Schema error:");
+          for (const line of config.error.message.split(`
+`)) {
+            lines.push(`  ${line}`);
+          }
+        } else if (config.error.kind === "read-error") {
+          lines.push(`  Read error: ${config.error.message}`);
+        }
+      }
+    }
+  }
+  if (result.presetCheck) {
+    lines.push("");
+    const status = result.presetCheck.ok ? "✓" : "✗";
+    lines.push(`[preset] ${result.presetCheck.preset} ${status}`);
+    if (result.presetCheck.error) {
+      lines.push(`  ${result.presetCheck.error.message}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function formatJsonDoctorResult(result) {
+  return JSON.stringify({
+    ...result,
+    configs: result.configs.map(({ config: _config, ...config }) => config)
+  }, null, 2);
+}
+async function doctor(args) {
+  if (args.help) {
+    console.log(`Usage: agent-forge doctor [OPTIONS]
+
+Options:
+  --json              Print diagnostics as JSON
+  -h, --help          Show this help message`);
+    return 0;
+  }
+  if (args.error) {
+    console.error(args.error);
+    return 1;
+  }
+  const result = runDoctorCheck(process.cwd());
+  if (args.json) {
+    console.log(formatJsonDoctorResult(result));
+  } else {
+    console.log(formatHumanDoctorResult(result));
+  }
+  return result.ok ? 0 : 1;
+}
+
+// src/cli/install.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { createInterface } from "node:readline/promises";
+// src/cli/system.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { statSync as statSync4 } from "node:fs";
+
+// src/utils/compat.ts
+import { spawn as nodeSpawn } from "node:child_process";
+var isBun = typeof globalThis.Bun !== "undefined";
+function collectStream(stream) {
+  if (!stream)
+    return () => Promise.resolve("");
+  const chunks = [];
+  stream.on("data", (chunk) => chunks.push(chunk));
+  return () => new Promise((resolve, reject) => {
+    if (!stream.readable) {
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+      return;
+    }
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stream.on("error", reject);
+  });
+}
+function crossSpawn(command, options) {
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    stdio: [
+      options?.stdin ?? "ignore",
+      options?.stdout ?? "pipe",
+      options?.stderr ?? "pipe"
+    ],
+    cwd: options?.cwd,
+    env: options?.env
+  });
+  const stdoutCollector = collectStream(proc.stdout);
+  const stderrCollector = collectStream(proc.stderr);
+  const exited = new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  return {
+    proc,
+    stdout: stdoutCollector,
+    stderr: stderrCollector,
+    exited,
+    kill: (signal) => proc.kill(signal),
+    get exitCode() {
+      return proc.exitCode;
+    }
+  };
+}
+
+// src/cli/system.ts
+var cachedOpenCodePath = null;
+function resolvePathCommand(command) {
+  try {
+    const resolver = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync2(resolver, [command], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.status !== 0) {
+      return null;
+    }
+    const resolved = result.stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    return resolved ?? null;
+  } catch {
+    return null;
+  }
+}
+function canExecute(command, args) {
+  try {
+    const result = spawnSync2(command, args, {
+      stdio: "ignore"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+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 pathOpenCodePath = resolvePathCommand("opencode");
+  if (pathOpenCodePath) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return pathOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode")
+      continue;
+    try {
+      const stat = statSync4(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {}
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const pathOpenCodePath = resolvePathCommand("opencode");
+  if (pathOpenCodePath && canExecute(pathOpenCodePath, ["--version"])) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return true;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode")
+      continue;
+    try {
+      const proc = crossSpawn([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 = crossSpawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const outputPromise = proc.stdout();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return (await outputPromise).trim();
+    }
+  } catch {}
+  return null;
+}
+function getOpenCodePath() {
+  const path2 = resolveOpenCodePath();
+  return path2 === "opencode" ? null : path2;
+}
+// src/cli/migration.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+var LEGACY_BASE_NAME = "oh-my-opencode-slim";
+var PRIMARY_AGENT_MAP = {
+  explorer: "researcher",
+  oracle: "reviewer",
+  designer: "implementer"
+};
+var SECONDARY_AGENT_MAP = {
+  librarian: "researcher",
+  fixer: "implementer"
+};
+var REMOVED_AGENTS = new Set(["observer"]);
+var ALL_LEGACY_NAMES = new Set([
+  ...Object.keys(PRIMARY_AGENT_MAP),
+  ...Object.keys(SECONDARY_AGENT_MAP),
+  ...REMOVED_AGENTS
+]);
+function getLegacyConfigPaths() {
+  const configDir = getConfigDir();
+  return [
+    join5(configDir, `${LEGACY_BASE_NAME}.json`),
+    join5(configDir, `${LEGACY_BASE_NAME}.jsonc`)
+  ];
+}
+function detectLegacyConfig() {
+  const paths2 = getLegacyConfigPaths();
+  for (const p of paths2) {
+    if (existsSync5(p))
+      return p;
+  }
+  return;
+}
+function migrateAgentNames(config) {
+  const result = { ...config };
+  const presets = result.presets;
+  if (presets) {
+    const migratedPresets = {};
+    for (const [presetName, preset] of Object.entries(presets)) {
+      migratedPresets[presetName] = migrateRecord(preset);
+    }
+    result.presets = migratedPresets;
+  }
+  const agents = result.agents;
+  if (agents) {
+    result.agents = migrateRecord(agents);
+  }
+  const disabled = result.disabled_agents;
+  if (Array.isArray(disabled)) {
+    result.disabled_agents = disabled.filter((name) => !REMOVED_AGENTS.has(name));
+  }
+  return result;
+}
+function migrateRecord(record) {
+  const result = {};
+  const usedTargets = new Set;
+  for (const [key, value] of Object.entries(record)) {
+    if (REMOVED_AGENTS.has(key)) {
+      continue;
+    }
+    const primaryTarget = PRIMARY_AGENT_MAP[key];
+    if (primaryTarget) {
+      result[primaryTarget] = value;
+      usedTargets.add(primaryTarget);
+      continue;
+    }
+    if (!ALL_LEGACY_NAMES.has(key)) {
+      result[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(record)) {
+    const secondaryTarget = SECONDARY_AGENT_MAP[key];
+    if (secondaryTarget && !usedTargets.has(secondaryTarget)) {
+      result[secondaryTarget] = value;
+      usedTargets.add(secondaryTarget);
+    }
+  }
+  return result;
+}
+function performMigration(legacyPath) {
+  try {
+    const content = readFileSync4(legacyPath, "utf-8");
+    if (content.trim().length === 0) {
+      return {
+        detected: true,
+        migrated: false,
+        legacyPath,
+        error: "Legacy config file is empty"
+      };
+    }
+    const config = JSON.parse(stripJsonComments(content));
+    const migrated = migrateAgentNames(config);
+    const configDir = getConfigDir();
+    const newPath = join5(configDir, "agent-forge.json");
+    const newContent = `${JSON.stringify(migrated, null, 2)}
+`;
+    const tmpPath = `${newPath}.tmp`;
+    writeFileSync2(tmpPath, newContent);
+    renameSync2(tmpPath, newPath);
+    const bakPath = `${legacyPath}.bak`;
+    renameSync2(legacyPath, bakPath);
+    return {
+      detected: true,
+      migrated: true,
+      newPath,
+      legacyPath
+    };
+  } catch (err) {
+    return {
+      detected: true,
+      migrated: false,
+      legacyPath,
+      error: `Migration failed: ${err}`
+    };
+  }
+}
+
+// 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}[ok]${RESET}`,
+  cross: `${RED}[x]${RESET}`,
+  arrow: `${BLUE}->${RESET}`,
+  bullet: `${DIM}-${RESET}`,
+  info: `${BLUE}[i]${RESET}`,
+  warn: `${YELLOW}[!]${RESET}`,
+  star: `${YELLOW}★${RESET}`
+};
+var GITHUB_REPO = "zcyoop/ai-assistant/agent-forge";
+var GITHUB_URL = `https://cnb.cool/${GITHUB_REPO}`;
+function printHeader(isUpdate) {
+  console.log();
+  console.log(`${BOLD}agent-forge ${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 confirm(message, defaultYes = true) {
+  const suffix = defaultYes ? " (Y/n) " : " (y/N) ";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${message}${suffix}`)).trim().toLowerCase();
+    if (!answer)
+      return defaultYes;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function askToStarRepo(config) {
+  if (!config.promptForStar || config.dryRun || !process.stdin.isTTY)
+    return;
+  console.log();
+  const shouldStar = await confirm(`${SYMBOLS.star} Star the repo on GitHub?`, true);
+  if (!shouldStar)
+    return;
+  try {
+    const { execFileSync } = await import("node:child_process");
+    execFileSync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${GITHUB_REPO}`], { stdio: "ignore", timeout: 1e4 });
+    printSuccess("Thanks for starring! ★");
+  } catch {
+    printInfo(`Couldn't star automatically. You can star manually:
+  ${BLUE}${GITHUB_URL}${RESET}`);
+  }
+}
+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 path2 = getOpenCodePath();
+  const detectedVersion = version ?? "";
+  const pathInfo = path2 ? ` (${DIM}${path2}${RESET})` : "";
+  printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
+  return { ok: true, version: version ?? undefined, path: path2 ?? undefined };
+}
+function handleStepResult(result, successMsg) {
+  if (!result.success) {
+    printError(`Failed: ${result.error}`);
+    return false;
+  }
+  printSuccess(`${successMsg} ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`);
+  return true;
+}
+async function runInstall(config) {
+  const detected = detectCurrentConfig();
+  const isUpdate = detected.isInstalled;
+  printHeader(isUpdate);
+  let totalSteps = 6;
+  if (config.installSkills)
+    totalSteps += 1;
+  if (config.installCustomSkills)
+    totalSteps += 1;
+  const legacyPath = detectLegacyConfig();
+  const hasLegacy = legacyPath !== undefined;
+  if (hasLegacy)
+    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 agent-forge 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, "Adding TUI version badge...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping TUI plugin installation");
+  } else {
+    const tuiResult = await addPluginToOpenCodeTuiConfig();
+    if (!tuiResult.success) {
+      printInfo(`Skipped TUI badge: ${tuiResult.error}`);
+    } else {
+      handleStepResult(tuiResult, "TUI badge added");
+    }
+  }
+  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, "Enabling OpenCode LSP integration...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping LSP configuration");
+  } else {
+    const lspResult = enableLspByDefault();
+    if (!handleStepResult(lspResult, "LSP enabled"))
+      return 1;
+  }
+  if (hasLegacy && legacyPath) {
+    printStep(step++, totalSteps, "Migrating legacy configuration...");
+    if (config.dryRun) {
+      printInfo(`Dry run mode - detected legacy config: ${legacyPath}`);
+      printInfo("Would migrate agent names and rename to agent-forge.json");
+    } else if (config.reset) {
+      const migrationResult = performMigration(legacyPath);
+      if (migrationResult.migrated) {
+        printSuccess(`Legacy config migrated ${SYMBOLS.arrow} ${migrationResult.newPath}`);
+      } else if (migrationResult.error) {
+        printInfo(`Legacy config migration skipped: ${migrationResult.error}`);
+      }
+    } else {
+      printInfo(`Legacy config detected: ${DIM}${legacyPath}${RESET}`);
+      printInfo("This is an oh-my-opencode-slim config with old agent names (explorer, librarian, oracle, designer, fixer, observer).");
+      printInfo("New agent names: researcher (explorer+librarian), reviewer (oracle), implementer (designer+fixer).");
+      const shouldMigrate = await confirm("Migrate to agent-forge.json?", true);
+      if (shouldMigrate) {
+        const migrationResult = performMigration(legacyPath);
+        if (migrationResult.migrated) {
+          printSuccess(`Migrated ${SYMBOLS.arrow} ${DIM}${migrationResult.newPath}${RESET}`);
+          printInfo(`Legacy config backed up to ${DIM}${legacyPath}.bak${RESET}`);
+        } else {
+          printError(migrationResult.error ?? "Unknown migration error");
+        }
+      } else {
+        printInfo("Skipped migration. You can manually rename oh-my-opencode-slim.json to agent-forge.json and " + "update agent names: explorer→researcher, " + "oracle→reviewer, designer→implementer.");
+      }
+    }
+  }
+  printStep(step++, totalSteps, "Writing agent-forge 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 configPath2 = getExistingLiteConfigPath();
+    const configExists = existsSync6(configPath2);
+    if (configExists && !config.reset) {
+      printInfo(`Configuration already exists at ${configPath2}. Use --reset to overwrite.`);
+    } else {
+      const liteResult = writeLiteConfig(config, configExists ? configPath2 : undefined);
+      if (!handleStepResult(liteResult, configExists ? "Config reset" : "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)`);
+        }
+      }
+      const totalCustom = CUSTOM_SKILLS.length;
+      printSuccess(`${customSkillsInstalled}/${totalCustom} custom skills processed`);
+    }
+  }
+  const statusMsg = isUpdate ? "Configuration updated!" : "Installation complete!";
+  console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${statusMsg}${RESET}`);
+  console.log();
+  console.log(`${BOLD}Next steps:${RESET}`);
+  console.log();
+  const configPath = getExistingLiteConfigPath();
+  console.log("  1. Log in to the provider(s) you want to use:");
+  console.log(`     ${BLUE}$ opencode auth login${RESET}`);
+  console.log();
+  console.log("  2. Refresh the models OpenCode can see:");
+  console.log(`     ${BLUE}$ opencode models --refresh${RESET}`);
+  console.log();
+  console.log("  3. Review your generated config:");
+  console.log(`     ${BLUE}${configPath}${RESET}`);
+  console.log();
+  console.log("  4. Start OpenCode:");
+  console.log(`     ${BLUE}$ opencode${RESET}`);
+  console.log();
+  console.log("  5. Verify the agents are responding:");
+  console.log(`     ${BLUE}> ping all agents${RESET}`);
+  console.log();
+  const modelsInfo = config.preset && config.preset !== "openai" ? `Generated OpenAI and OpenCode Go presets; ${config.preset} is active.` : "Generated OpenAI and OpenCode Go presets; OpenAI is active by default.";
+  console.log(`${modelsInfo}`);
+  const altProviders = "For the full configuration reference, see:";
+  console.log(altProviders);
+  const docsUrl = "https://cnb.cool/zcyoop/ai-assistant/agent-forge/blob/master/docs/configuration.md";
+  console.log(`  ${BLUE}${docsUrl}${RESET}`);
+  console.log();
+  await askToStarRepo(config);
+  return 0;
+}
+async function install(args) {
+  const config = {
+    hasTmux: false,
+    installSkills: args.skills === "yes",
+    installCustomSkills: args.skills === "yes",
+    preset: args.preset,
+    promptForStar: args.tui,
+    dryRun: args.dryRun,
+    reset: args.reset ?? false
+  };
+  return runInstall(config);
+}
+
+// src/cli/providers.ts
+var GENERATED_PRESETS2 = ["openai", "opencode-go"];
+function isGeneratedPresetName2(value) {
+  return GENERATED_PRESETS2.includes(value);
+}
+function getGeneratedPresetNames2() {
+  return [...GENERATED_PRESETS2];
+}
+
+// src/cli/index.ts
+function parseArgs(args) {
+  const result = {
+    tui: true,
+    skills: "yes"
+  };
+  for (const arg of args) {
+    if (arg === "--no-tui") {
+      result.tui = false;
+    } else if (arg.startsWith("--skills=")) {
+      result.skills = arg.split("=")[1];
+    } else if (arg.startsWith("--preset=")) {
+      const preset = arg.split("=")[1];
+      if (!isGeneratedPresetName2(preset)) {
+        console.error(`Unsupported preset: ${preset}. Available presets: ${getGeneratedPresetNames2().join(", ")}`);
+        process.exit(1);
+      }
+      result.preset = preset;
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "--reset") {
+      result.reset = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`
+@zcy2nn/agent-forge installer
+
+Usage:
+  bunx @zcy2nn/agent-forge install [OPTIONS]
+  bunx @zcy2nn/agent-forge doctor [OPTIONS]
+
+Options:
+  --skills=yes|no        Install recommended and bundled skills (default: yes)
+  --preset=<name>        Active generated config preset (default: openai)
+  --no-tui               Non-interactive mode
+  --dry-run              Simulate install without writing files
+  --reset                Force overwrite of existing configuration
+  -h, --help             Show this help message
+
+Doctor options:
+  --json                 Print diagnostics as JSON
+
+Available presets: ${getGeneratedPresetNames2().join(", ")}
+
+The installer generates OpenAI and OpenCode Go presets by default.
+OpenAI is active unless --preset selects another generated preset.
+For the full config reference, see docs/configuration.md.
+
+Examples:
+  bunx @zcy2nn/agent-forge install
+  bunx @zcy2nn/agent-forge install --no-tui --skills=yes
+  bunx @zcy2nn/agent-forge install --preset=opencode-go
+  bunx @zcy2nn/agent-forge install --reset
+  bunx @zcy2nn/agent-forge doctor
+`);
+}
+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] === "doctor") {
+    const doctorArgs = parseDoctorArgs(args.slice(1));
+    const exitCode = await doctor(doctorArgs);
+    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);
+});