oh-my-opencode-slim 1.0.6 → 1.1.0

package/dist/cli/index.js

@@ -3,21 +3,73 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/cli/install.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { createInterface } from "node:readline/promises";
+// 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,
+  mkdirSync as mkdirSync3,
   readFileSync,
   renameSync,
   statSync as statSync2,
   writeFileSync
 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
 import { dirname as dirname3, join as join3 } from "node:path";
 
+// 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/paths.ts
 import { existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -41,6 +93,12 @@ function getConfigDir() {
   }
   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")];
@@ -298,6 +356,17 @@ var SessionManagerConfigSchema = z2.object({
   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)"),
@@ -349,6 +418,7 @@ var PluginConfigSchema = z2.object({
   websearch: WebsearchConfigSchema.optional(),
   interview: InterviewConfigSchema.optional(),
   sessionManager: SessionManagerConfigSchema.optional(),
+  divoom: DivoomConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
@@ -397,6 +467,12 @@ var CUSTOM_SKILLS = [
     description: "Repository understanding and hierarchical codemap generation",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/codemap"
+  },
+  {
+    name: "clonedeps",
+    description: "Clone important dependency source for local inspection",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/clonedeps"
   }
 ];
 function getCustomSkillsDir() {
@@ -535,7 +611,8 @@ var MODEL_MAPPINGS = {
     librarian: { model: "opencode-go/minimax-m2.7" },
     explorer: { model: "opencode-go/minimax-m2.7" },
     designer: { model: "opencode-go/kimi-k2.6", variant: "medium" },
-    fixer: { model: "opencode-go/deepseek-v4-flash", variant: "high" }
+    fixer: { model: "opencode-go/deepseek-v4-flash", variant: "high" },
+    observer: { model: "opencode-go/kimi-k2.6" }
   }
 };
 function isGeneratedPresetName(value) {
@@ -554,6 +631,9 @@ function generateLiteConfig(installConfig) {
     preset,
     presets: {}
   };
+  if (preset === "opencode-go") {
+    config.disabled_agents = [];
+  }
   const createAgentConfig = (agentName, modelInfo) => {
     const isOrchestrator = agentName === "orchestrator";
     const skills = isOrchestrator ? ["*"] : [
@@ -632,10 +712,6 @@ function findPackageRoot(startPath) {
     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;
@@ -651,6 +727,10 @@ function isLocalPackageRootEntry(entry) {
     return false;
   }
 }
+function isPackageManagerInstall(path) {
+  const normalizedPath = normalizePathForMatch(path);
+  return normalizedPath.includes(`/node_modules/${PACKAGE_NAME}`);
+}
 function isPluginEntry(entry) {
   return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`) || entry.startsWith("file://") && entry.includes(PACKAGE_NAME) || isLocalPackageRootEntry(entry);
 }
@@ -673,6 +753,104 @@ function getPluginEntry() {
     return PACKAGE_NAME;
   }
 }
+function getOpenCodePluginCacheDir() {
+  const cacheDir = process.env.XDG_CACHE_HOME?.trim() || join3(homedir2(), ".cache");
+  return join3(cacheDir, "opencode", "packages", `${PACKAGE_NAME}@latest`);
+}
+function writeOpenCodePluginCacheManifest(cacheDir) {
+  try {
+    writeFileSync(join3(cacheDir, "package.json"), JSON.stringify({
+      name: `${PACKAGE_NAME}-cache`,
+      private: true,
+      dependencies: {
+        [PACKAGE_NAME]: "latest"
+      }
+    }, null, 2));
+    return null;
+  } catch (err) {
+    return {
+      success: false,
+      configPath: cacheDir,
+      error: `Failed to write cache package.json: ${err}`
+    };
+  }
+}
+function verifyOpenCodePluginCache(cacheDir) {
+  const pluginPackageJsonPath = join3(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
+  if (!existsSync3(pluginPackageJsonPath)) {
+    return {
+      success: false,
+      configPath: cacheDir,
+      error: `Cached plugin package not found at ${pluginPackageJsonPath}`
+    };
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(pluginPackageJsonPath, "utf-8"));
+    if (packageJson.name !== PACKAGE_NAME) {
+      return {
+        success: false,
+        configPath: cacheDir,
+        error: `Cached plugin package has unexpected name: ${packageJson.name}`
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      configPath: cacheDir,
+      error: `Failed to verify cached plugin package: ${err}`
+    };
+  }
+  return null;
+}
+async function warmOpenCodePluginCache() {
+  const cliEntryPath = process.argv[1];
+  if (!cliEntryPath) {
+    return null;
+  }
+  const packageRoot = findPackageRoot(cliEntryPath);
+  if (!packageRoot || !isPackageManagerInstall(packageRoot)) {
+    return null;
+  }
+  const cacheDir = getOpenCodePluginCacheDir();
+  try {
+    mkdirSync3(cacheDir, { recursive: true });
+  } catch (err) {
+    return {
+      success: false,
+      configPath: cacheDir,
+      error: `Failed to create OpenCode cache directory: ${err}`
+    };
+  }
+  const manifestError = writeOpenCodePluginCacheManifest(cacheDir);
+  if (manifestError)
+    return manifestError;
+  try {
+    const proc = crossSpawn(["bun", "install", "--ignore-scripts"], {
+      cwd: cacheDir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      const stderr = (await proc.stderr()).trim();
+      return {
+        success: false,
+        configPath: cacheDir,
+        error: stderr || `bun install exited with code ${proc.exitCode}`
+      };
+    }
+    const verificationError = verifyOpenCodePluginCache(cacheDir);
+    if (verificationError)
+      return verificationError;
+    return { success: true, configPath: cacheDir };
+  } catch (err) {
+    return {
+      success: false,
+      configPath: cacheDir,
+      error: `Failed to warm OpenCode cache: ${err}`
+    };
+  }
+}
 function stripJsonComments(json) {
   const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
   const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
@@ -919,57 +1097,266 @@ function detectCurrentConfig() {
   }
   return result;
 }
-// src/cli/system.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { statSync as statSync3 } 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;
+// 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;
     }
-    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    stream.on("error", reject);
-  });
+  }
+  return null;
 }
-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));
-  });
+function findPluginConfigPaths(directory) {
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
+  const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  return { userConfigPath, projectConfigPath };
+}
+function mergePluginConfigs(base, override) {
   return {
-    proc,
-    stdout: stdoutCollector,
-    stderr: stderrCollector,
-    exited,
-    kill: (signal) => proc.kill(signal),
-    get exitCode() {
-      return proc.exitCode;
+    ...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: oh-my-opencode-slim 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 existsSync5 } 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";
 var cachedOpenCodePath = null;
 function resolvePathCommand(command) {
   try {
@@ -1042,7 +1429,7 @@ function resolveOpenCodePath() {
     if (opencodePath === "opencode")
       continue;
     try {
-      const stat = statSync3(opencodePath);
+      const stat = statSync4(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -1091,8 +1478,8 @@ async function getOpenCodeVersion() {
   return null;
 }
 function getOpenCodePath() {
-  const path = resolveOpenCodePath();
-  return path === "opencode" ? null : path;
+  const path2 = resolveOpenCodePath();
+  return path2 === "opencode" ? null : path2;
 }
 // src/cli/install.ts
 var GREEN = "\x1B[32m";
@@ -1172,11 +1559,11 @@ async function checkOpenCodeInstalled() {
     return { ok: false };
   }
   const version = await getOpenCodeVersion();
-  const path = getOpenCodePath();
+  const path2 = getOpenCodePath();
   const detectedVersion = version ?? "";
-  const pathInfo = path ? ` (${DIM}${path}${RESET})` : "";
+  const pathInfo = path2 ? ` (${DIM}${path2}${RESET})` : "";
   printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
-  return { ok: true, version: version ?? undefined, path: path ?? undefined };
+  return { ok: true, version: version ?? undefined, path: path2 ?? undefined };
 }
 function handleStepResult(result, successMsg) {
   if (!result.success) {
@@ -1195,6 +1582,7 @@ async function runInstall(config) {
     totalSteps += 1;
   if (config.installCustomSkills)
     totalSteps += 1;
+  totalSteps += 1;
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   if (config.dryRun) {
@@ -1223,6 +1611,19 @@ async function runInstall(config) {
       handleStepResult(tuiResult, "TUI badge added");
     }
   }
+  printStep(step++, totalSteps, "Warming OpenCode plugin cache...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping cache warm-up");
+  } else {
+    const cacheResult = await warmOpenCodePluginCache();
+    if (cacheResult === null) {
+      printInfo("Local development install - cache warm-up not required");
+    } else if (!cacheResult.success) {
+      printInfo(`Skipped cache warm-up: ${cacheResult.error}`);
+    } else {
+      handleStepResult(cacheResult, "OpenCode cache warmed");
+    }
+  }
   printStep(step++, totalSteps, "Disabling OpenCode default agents...");
   if (config.dryRun) {
     printInfo("Dry run mode - skipping agent disabling");
@@ -1248,7 +1649,7 @@ ${JSON.stringify(liteConfig, null, 2)}
 `);
   } else {
     const configPath2 = getExistingLiteConfigPath();
-    const configExists = existsSync4(configPath2);
+    const configExists = existsSync5(configPath2);
     if (configExists && !config.reset) {
       printInfo(`Configuration already exists at ${configPath2}. Use --reset to overwrite.`);
     } else {
@@ -1386,7 +1787,9 @@ function printHelp() {
   console.log(`
 oh-my-opencode-slim installer
 
-Usage: bunx oh-my-opencode-slim install [OPTIONS]
+Usage:
+  bunx oh-my-opencode-slim install [OPTIONS]
+  bunx oh-my-opencode-slim doctor [OPTIONS]
 
 Options:
   --skills=yes|no        Install recommended and bundled skills (default: yes)
@@ -1396,6 +1799,9 @@ Options:
   --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.
@@ -1407,6 +1813,7 @@ Examples:
   bunx oh-my-opencode-slim install --no-tui --skills=yes
   bunx oh-my-opencode-slim install --preset=opencode-go
   bunx oh-my-opencode-slim install --reset
+  bunx oh-my-opencode-slim doctor
 `);
 }
 async function main() {
@@ -1416,6 +1823,10 @@ async function main() {
     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);

package/dist/cli/providers.d.ts

@@ -127,6 +127,9 @@ export declare const MODEL_MAPPINGS: {
             readonly model: "opencode-go/deepseek-v4-flash";
             readonly variant: "high";
         };
+        readonly observer: {
+            readonly model: "opencode-go/kimi-k2.6";
+        };
     };
 };
 export type PresetName = keyof typeof MODEL_MAPPINGS;