opencode-matrixx 2.4.0 → 2.6.0

package/dist/cli.js

@@ -0,0 +1,927 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/doctor/checks/auth.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var OPENCODE_CONFIG_PATHS = [
+  join(homedir(), ".config", "opencode", "opencode.json"),
+  join(homedir(), ".config", "opencode", "opencode.jsonc")
+];
+var AUTH_JSON_PATHS = [
+  join(homedir(), ".local", "share", "opencode", "auth.json"),
+  join(homedir(), ".config", "opencode", "auth.json")
+];
+function stripJsonComments(text) {
+  return text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function collectConfigText() {
+  let combined = "";
+  for (const p of OPENCODE_CONFIG_PATHS) {
+    if (!existsSync(p))
+      continue;
+    try {
+      const raw = readFileSync(p, "utf-8");
+      combined += ` ${stripJsonComments(raw)}`;
+    } catch {}
+  }
+  return combined.toLowerCase();
+}
+function collectAuthText() {
+  let combined = "";
+  for (const p of AUTH_JSON_PATHS) {
+    if (!existsSync(p))
+      continue;
+    try {
+      const raw = readFileSync(p, "utf-8");
+      combined += ` ${raw}`;
+    } catch {}
+  }
+  try {
+    const result = Bun.spawnSync(["opencode", "auth", "list", "--json"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode === 0)
+      combined += ` ${result.stdout.toString()}`;
+  } catch {}
+  return combined.toLowerCase();
+}
+function hasProvider(haystack, keywords) {
+  return keywords.some((k) => haystack.includes(k));
+}
+function getProviderStatuses() {
+  const results = [
+    { provider: "Anthropic", configured: false },
+    { provider: "OpenAI", configured: false },
+    { provider: "Google", configured: false }
+  ];
+  const configText = collectConfigText();
+  const authText = collectAuthText();
+  const combinedAuthConfig = `${configText} ${authText}`;
+  const hasAnyConfigFile = OPENCODE_CONFIG_PATHS.some(existsSync) || AUTH_JSON_PATHS.some(existsSync);
+  if (!hasAnyConfigFile && !combinedAuthConfig.trim()) {
+    if (process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {} else {
+      return results.map((r) => ({ ...r, detail: "No opencode config or auth storage found \u2014 run `opencode auth login`" }));
+    }
+  }
+  const providerChecks = {
+    Anthropic: ["anthropic", "claude"],
+    OpenAI: ["openai"],
+    Google: ["google", "gemini", "vertex"]
+  };
+  for (const r of results) {
+    const keywords = providerChecks[r.provider] ?? [r.provider.toLowerCase()];
+    const inConfig = hasProvider(configText, keywords);
+    const inAuth = hasProvider(authText, keywords);
+    if (inConfig || inAuth) {
+      r.configured = true;
+      r.detail = inAuth ? "Provider found in auth storage" : "Provider found in opencode config";
+    } else {
+      r.detail = "Provider not configured \u2014 run `opencode auth login` or set env var";
+    }
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    results[0].configured = true;
+    results[0].detail = "ANTHROPIC_API_KEY env var set";
+  }
+  if (process.env.OPENAI_API_KEY) {
+    results[1].configured = true;
+    results[1].detail = "OPENAI_API_KEY env var set";
+  }
+  if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
+    results[2].configured = true;
+    results[2].detail = "Google/Gemini API key env var set";
+  }
+  return results;
+}
+var authCheck = {
+  name: "authentication",
+  category: "authentication",
+  check: () => {
+    const providers = getProviderStatuses();
+    const configured = providers.filter((p) => p.configured);
+    const unconfigured = providers.filter((p) => !p.configured);
+    if (configured.length === 0) {
+      return {
+        name: "authentication",
+        status: "fail",
+        message: "No API providers configured",
+        detail: providers.map((p) => `  ${p.provider}: ${p.detail ?? "not configured"}`).join(`
+`)
+      };
+    }
+    const configuredList = configured.map((p) => p.provider).join(", ");
+    const warnings = unconfigured.map((p) => p.provider).join(", ");
+    if (unconfigured.length > 0) {
+      return {
+        name: "authentication",
+        status: "warn",
+        message: `Configured: ${configuredList}. Missing: ${warnings}`,
+        detail: `Missing providers:
+${unconfigured.map((p) => `  ${p.provider}: ${p.detail ?? "not configured"}`).join(`
+`)}`
+      };
+    }
+    return {
+      name: "authentication",
+      status: "pass",
+      message: `All providers configured: ${configuredList}`
+    };
+  }
+};
+
+// src/cli/doctor/checks/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var MATRIX_CONFIG_PATHS = [
+  join2(process.cwd(), "matrixx.json"),
+  join2(process.cwd(), "matrixx.jsonc"),
+  join2(process.cwd(), ".opencode", "matrixx.json"),
+  join2(homedir2(), ".config", "opencode", "matrixx.json"),
+  join2(homedir2(), ".config", "opencode", "matrixx.jsonc")
+];
+function findMatrixxConfig() {
+  for (const p of MATRIX_CONFIG_PATHS) {
+    if (existsSync2(p)) {
+      try {
+        const content = readFileSync2(p, "utf-8");
+        return { path: p, content };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function tryParseJSON(text) {
+  try {
+    JSON.parse(text);
+    return { valid: true };
+  } catch (err) {
+    return { valid: false, error: String(err) };
+  }
+}
+var configValidationCheck = {
+  name: "config-validation",
+  category: "configuration",
+  check: () => {
+    const found = findMatrixxConfig();
+    if (!found) {
+      return {
+        name: "config-validation",
+        status: "warn",
+        message: "No matrixx configuration file found",
+        detail: "Create matrixx.jsonc in your project or ~/.config/opencode/"
+      };
+    }
+    const parseResult = tryParseJSON(found.content);
+    if (!parseResult.valid) {
+      const hasJsoncSigns = found.content.includes("//") || found.content.includes("/*") || found.content.includes(",,");
+      if (hasJsoncSigns) {
+        return {
+          name: "config-validation",
+          status: "warn",
+          message: `Config file has comments/trailing commas (JSONC), may need JSONC parser`,
+          detail: `Path: ${found.path}`
+        };
+      }
+      return {
+        name: "config-validation",
+        status: "fail",
+        message: `Invalid JSON in config: ${parseResult.error}`,
+        detail: `Path: ${found.path}`
+      };
+    }
+    return {
+      name: "config-validation",
+      status: "pass",
+      message: `Configuration file is valid at ${found.path}`
+    };
+  }
+};
+
+// src/cli/doctor/checks/mcp.ts
+function checkUvxVersion() {
+  try {
+    const r = Bun.spawnSync(["uvx", "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (r.exitCode === 0) {
+      return r.stdout.toString().trim().split(`
+`)[0]?.replace(/^uvx\s+/i, "") || null;
+    }
+  } catch {}
+  return null;
+}
+var mcpPrerequisitesCheck = {
+  name: "mcp-prerequisites",
+  category: "dependencies",
+  check: () => {
+    const uvxVersion = checkUvxVersion();
+    if (!uvxVersion) {
+      return {
+        name: "mcp-prerequisites",
+        status: "fail",
+        message: "uvx (uv) not found \u2014 required for the document_reader MCP",
+        detail: `Install uv/uvx: curl -LsSf https://astral.sh/uv/install.sh | sh
+` + `Then run once to warm the markitdown-mcp cache:
+` + "  uvx --from markitdown-mcp markitdown-mcp --help"
+      };
+    }
+    try {
+      const warm = Bun.spawnSync(["uvx", "--from", "markitdown-mcp", "markitdown-mcp", "--help"], { stdout: "pipe", stderr: "pipe", timeout: 120000 });
+      const output = `${warm.stdout.toString()}${warm.stderr.toString()}`;
+      if (warm.exitCode === 0 || output.includes("MarkItDown")) {
+        return {
+          name: "mcp-prerequisites",
+          status: "pass",
+          message: `uvx ${uvxVersion} found; markitdown-mcp cache warm`,
+          detail: output.trim() || undefined
+        };
+      }
+      return {
+        name: "mcp-prerequisites",
+        status: "warn",
+        message: `uvx ${uvxVersion} found but markitdown-mcp could not resolve`,
+        detail: output.trim() || undefined
+      };
+    } catch {
+      return {
+        name: "mcp-prerequisites",
+        status: "warn",
+        message: `uvx ${uvxVersion} found but warm-up timed out (network?)`,
+        detail: "Retry later: uvx --from markitdown-mcp markitdown-mcp --help"
+      };
+    }
+  }
+};
+
+// src/cli/doctor/checks/optional.ts
+var BINARY_CHECKS = [
+  {
+    name: "ast-grep (sg)",
+    check: () => {
+      try {
+        const r = Bun.spawnSync(["sg", "--version"], { stdout: "pipe", stderr: "pipe" });
+        return { available: r.exitCode === 0, version: r.stdout.toString().trim() };
+      } catch {
+        return { available: false };
+      }
+    }
+  },
+  {
+    name: "Gitleaks",
+    check: () => {
+      try {
+        const r = Bun.spawnSync(["gitleaks", "--version"], { stdout: "pipe", stderr: "pipe" });
+        return { available: r.exitCode === 0, version: r.stdout.toString().trim() };
+      } catch {
+        return { available: false };
+      }
+    }
+  }
+];
+var PYTHON_CHECKS = [
+  {
+    name: "PyMuPDF (fitz)",
+    check: () => {
+      try {
+        const r = Bun.spawnSync(["python3", "-c", "import fitz; print(fitz.__version__)"], {
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        return { available: r.exitCode === 0, version: r.stdout.toString().trim() };
+      } catch {
+        return { available: false };
+      }
+    }
+  },
+  {
+    name: "Playwright (CLI)",
+    check: () => {
+      try {
+        const r = Bun.spawnSync(["playwright", "--version"], { stdout: "pipe", stderr: "pipe" });
+        return { available: r.exitCode === 0, version: r.stdout.toString().trim() };
+      } catch {
+        return { available: false };
+      }
+    }
+  }
+];
+var optionalToolsCheck = {
+  name: "optional-tools",
+  category: "tools",
+  check: () => {
+    const binaryResults = BINARY_CHECKS.map((t) => {
+      const result = t.check();
+      return { name: t.name, ...result };
+    });
+    let pythonResults = [];
+    try {
+      const pyCheck = Bun.spawnSync(["python3", "--version"], { stdout: "pipe", stderr: "pipe" });
+      if (pyCheck.exitCode === 0) {
+        pythonResults = PYTHON_CHECKS.map((t) => {
+          const result = t.check();
+          return { name: t.name, ...result };
+        });
+      } else {
+        pythonResults = PYTHON_CHECKS.map((t) => ({
+          name: t.name,
+          available: false,
+          version: undefined
+        }));
+      }
+    } catch {
+      pythonResults = PYTHON_CHECKS.map((t) => ({
+        name: t.name,
+        available: false,
+        version: undefined
+      }));
+    }
+    const allResults = [...binaryResults, ...pythonResults];
+    const available = allResults.filter((r) => r.available);
+    const missing = allResults.filter((r) => !r.available);
+    if (missing.length === 0) {
+      return {
+        name: "optional-tools",
+        status: "pass",
+        message: `All optional tools available: ${available.map((r) => r.name).join(", ")}`
+      };
+    }
+    const detailLines = allResults.map((r) => {
+      if (r.available) {
+        return `  \u2713 ${r.name}${r.version ? ` (${r.version})` : ""}`;
+      }
+      return `  \u2717 ${r.name} \u2014 not installed`;
+    });
+    const missingList = missing.map((r) => r.name).join(", ");
+    return {
+      name: "optional-tools",
+      status: "warn",
+      message: `Available: ${available.length}, Missing: ${missing.length} (${missingList})`,
+      detail: detailLines.join(`
+`)
+    };
+  }
+};
+
+// src/cli/doctor/checks/plugin.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var OPECODE_CONFIG_PATHS = [
+  join3(homedir3(), ".config", "opencode", "opencode.json"),
+  join3(homedir3(), ".config", "opencode", "opencode.jsonc")
+];
+function findOpenCodeConfig() {
+  for (const p of OPECODE_CONFIG_PATHS) {
+    if (existsSync3(p))
+      return p;
+  }
+  return null;
+}
+function checkOpenCodeVersion() {
+  try {
+    const result = Bun.spawnSync(["opencode", "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (result.exitCode === 0) {
+      return result.stdout.toString().trim();
+    }
+  } catch {}
+  return null;
+}
+var pluginInstallationCheck = {
+  name: "plugin-installation",
+  category: "installation",
+  check: () => {
+    const version = checkOpenCodeVersion();
+    if (!version) {
+      return {
+        name: "plugin-installation",
+        status: "fail",
+        message: "OpenCode CLI not found in PATH",
+        detail: "Install OpenCode first: https://opencode.ai/docs"
+      };
+    }
+    const semverMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!semverMatch) {
+      return {
+        name: "plugin-installation",
+        status: "warn",
+        message: `OpenCode version: ${version} (unable to parse)`
+      };
+    }
+    const major = Number(semverMatch[1]);
+    const minor = Number(semverMatch[2]);
+    const meetsMinVersion = major >= 1 && minor >= 0;
+    const configPath = findOpenCodeConfig();
+    if (!configPath) {
+      return {
+        name: "plugin-installation",
+        status: "warn",
+        message: `OpenCode ${version} installed, but opencode.json not found`,
+        detail: "Run `opencode` once to generate the config file"
+      };
+    }
+    let configContent;
+    try {
+      configContent = readFileSync3(configPath, "utf-8");
+    } catch {
+      return {
+        name: "plugin-installation",
+        status: "fail",
+        message: `Cannot read config: ${configPath}`
+      };
+    }
+    const hasPlugin = configContent.includes("opencode-matrixx") || configContent.includes("@klpanagi/opencode-matrixx");
+    if (!meetsMinVersion) {
+      return {
+        name: "plugin-installation",
+        status: "fail",
+        message: `OpenCode ${version} is below minimum 1.0.150`,
+        detail: "Update OpenCode to use Matrixx plugin"
+      };
+    }
+    if (!hasPlugin) {
+      return {
+        name: "plugin-installation",
+        status: "warn",
+        message: `OpenCode ${version} installed, plugin not registered in ${configPath}`,
+        detail: "Run `bunx opencode-matrixx install` to register the plugin"
+      };
+    }
+    return {
+      name: "plugin-installation",
+      status: "pass",
+      message: `OpenCode ${version}, plugin registered in ${configPath}`
+    };
+  }
+};
+
+// src/cli/doctor/checks/runtime.ts
+function checkCommand(cmd, arg = "--version") {
+  try {
+    const result = Bun.spawnSync([cmd, arg], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (result.exitCode === 0) {
+      return result.stdout.toString().trim().split(`
+`)[0] || null;
+    }
+  } catch {}
+  return null;
+}
+function getRuntimeVersions() {
+  const runtimes = [
+    { name: "Bun", version: checkCommand("bun"), status: "fail" },
+    { name: "Node.js", version: checkCommand("node"), status: "fail" },
+    { name: "Git", version: checkCommand("git"), status: "fail" },
+    { name: "Python3", version: checkCommand("python3", "--version"), status: "fail" }
+  ];
+  for (const r of runtimes) {
+    if (r.version) {
+      r.status = "pass";
+    }
+  }
+  return runtimes;
+}
+var runtimeDepsCheck = {
+  name: "runtime-dependencies",
+  category: "dependencies",
+  check: () => {
+    const runtimes = getRuntimeVersions();
+    const passed = runtimes.filter((r) => r.status === "pass");
+    const failed = runtimes.filter((r) => r.status === "fail");
+    if (failed.length === 0) {
+      return {
+        name: "runtime-dependencies",
+        status: "pass",
+        message: `All runtimes found: ${passed.map((r) => `${r.name} ${r.version}`).join(", ")}`
+      };
+    }
+    const missingList = failed.map((r) => r.name).join(", ");
+    const detailLines = [];
+    for (const r of runtimes) {
+      const status = r.version ? `${r.version}` : "NOT FOUND";
+      detailLines.push(`  ${r.name}: ${status}`);
+    }
+    if (failed.length <= passed.length) {
+      return {
+        name: "runtime-dependencies",
+        status: "warn",
+        message: `Found: ${passed.map((r) => r.name).join(", ")}. Missing: ${missingList}`,
+        detail: detailLines.join(`
+`)
+      };
+    }
+    return {
+      name: "runtime-dependencies",
+      status: "fail",
+      message: `Critical runtimes missing: ${missingList}`,
+      detail: detailLines.join(`
+`)
+    };
+  }
+};
+
+// src/cli/doctor/checks/index.ts
+var ALL_CHECKS = [
+  pluginInstallationCheck,
+  configValidationCheck,
+  authCheck,
+  runtimeDepsCheck,
+  optionalToolsCheck,
+  mcpPrerequisitesCheck
+];
+function getChecksByCategory(category) {
+  return ALL_CHECKS.filter((c) => c.category === category);
+}
+
+// src/cli/doctor/format.ts
+var STATUS_ICONS = {
+  pass: "\u2713",
+  warn: "\u26A0",
+  fail: "\u2717"
+};
+function padRight(s, len) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+function formatDoctorReport(report) {
+  const lines = [];
+  const boxWidth = 60;
+  lines.push("");
+  lines.push(`\u250C${"\u2500".repeat(boxWidth - 2)}\u2510`);
+  lines.push(`\u2502${padRight(" Matrixx Doctor", boxWidth - 1)}\u2502`);
+  lines.push(`\u2514${"\u2500".repeat(boxWidth - 2)}\u2518`);
+  lines.push("");
+  const grouped = new Map;
+  for (const check of report.checks) {
+    const cat = check.name.split("-")[0] || "other";
+    if (!grouped.has(cat))
+      grouped.set(cat, []);
+    grouped.get(cat)?.push(check);
+  }
+  for (const [category, checks] of grouped) {
+    lines.push(category.charAt(0).toUpperCase() + category.slice(1));
+    for (const c of checks) {
+      const icon = STATUS_ICONS[c.status] || "?";
+      const label = padRight(`  ${icon} ${c.message}`, boxWidth - 4);
+      lines.push(label);
+      if (c.detail) {
+        const detailLines = c.detail.split(`
+`);
+        for (const dl of detailLines) {
+          lines.push(`    ${dl}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  const s = report.summary;
+  lines.push(`Summary: ${s.passed} passed, ${s.warnings} warning(s), ${s.failed} failed`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatDoctorJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/cli/doctor/index.ts
+async function runDoctor(options = {}) {
+  const checks = options.category ? getChecksByCategory(options.category) : ALL_CHECKS;
+  if (checks.length === 0) {
+    const _available = [...new Set(ALL_CHECKS.map((c) => c.category))];
+    return {
+      timestamp: new Date().toISOString(),
+      checks: [],
+      summary: { total: 0, passed: 0, warnings: 0, failed: 0 }
+    };
+  }
+  const results = [];
+  for (const check of checks) {
+    try {
+      const result = await Promise.resolve(check.check());
+      result.category = check.category;
+      results.push(result);
+    } catch (err) {
+      results.push({
+        name: check.name,
+        category: check.category,
+        status: "fail",
+        message: `Check threw an exception: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warnings = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  return {
+    timestamp: new Date().toISOString(),
+    checks: results,
+    summary: { total: results.length, passed, warnings, failed }
+  };
+}
+async function executeDoctor(options = {}) {
+  const report = await runDoctor(options);
+  if (options.json) {
+    return formatDoctorJson(report);
+  }
+  return formatDoctorReport(report);
+}
+
+// src/cli/install/index.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function getOpenCodeConfigPath() {
+  const configDir = join4(homedir4(), ".config", "opencode");
+  const jsonPath = join4(configDir, "opencode.json");
+  const jsoncPath = join4(configDir, "opencode.jsonc");
+  if (existsSync4(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+function stripJsonComments2(text) {
+  return text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function parseOpenCodeConfig(content) {
+  try {
+    const stripped = stripJsonComments2(content);
+    return JSON.parse(stripped);
+  } catch {
+    return {};
+  }
+}
+function hasExistingPluginRegistration(configPath) {
+  if (!existsSync4(configPath))
+    return false;
+  try {
+    const content = readFileSync4(configPath, "utf-8");
+    return content.includes("opencode-matrixx");
+  } catch {
+    return false;
+  }
+}
+function isLocalRepoCheckout(dir) {
+  return existsSync4(join4(dir, "src", "index.ts")) && existsSync4(join4(dir, "package.json"));
+}
+function generatePluginEntry(absolutePath, forceLocal) {
+  const looksLocal = forceLocal || isLocalRepoCheckout(absolutePath);
+  if (looksLocal) {
+    const distEntry = join4(absolutePath, "dist", "index.js");
+    if (existsSync4(distEntry))
+      return `file://${distEntry}`;
+    if (existsSync4(absolutePath))
+      return `file://${absolutePath}`;
+  }
+  return "opencode-matrixx";
+}
+async function executeInstall(options) {
+  const configDir = join4(homedir4(), ".config", "opencode");
+  const configPath = getOpenCodeConfigPath();
+  if (!existsSync4(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  if (hasExistingPluginRegistration(configPath)) {
+    return `\u2713 Plugin already registered in ${configPath}`;
+  }
+  const cwd = process.cwd();
+  const pluginEntry = generatePluginEntry(cwd, options.local);
+  let config;
+  if (existsSync4(configPath)) {
+    try {
+      const content = readFileSync4(configPath, "utf-8");
+      config = parseOpenCodeConfig(content);
+    } catch {
+      config = {};
+    }
+  } else {
+    config = {};
+  }
+  if (!config.plugin) {
+    config.plugin = [];
+  }
+  if (!config.plugin.includes(pluginEntry)) {
+    config.plugin.push(pluginEntry);
+  }
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  const flags = [];
+  if (options.claude)
+    flags.push(`Claude: ${options.claude}`);
+  if (options.openai)
+    flags.push(`OpenAI: ${options.openai}`);
+  if (options.gemini)
+    flags.push(`Gemini: ${options.gemini}`);
+  if (options.copilot)
+    flags.push(`Copilot: ${options.copilot}`);
+  if (options.opencodeZen)
+    flags.push(`OpenCode Zen: ${options.opencodeZen}`);
+  if (options.zaiCodingPlan)
+    flags.push(`Z.ai: ${options.zaiCodingPlan}`);
+  const parts = [
+    "",
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    "\u2502  Matrixx Install Complete            \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
+    "",
+    `\u2713 Plugin registered in ${configPath}`,
+    `  Entry: ${pluginEntry}`,
+    ""
+  ];
+  if (flags.length > 0) {
+    parts.push("  Subscriptions:");
+    for (const f of flags) {
+      parts.push(`    ${f}`);
+    }
+    parts.push("");
+  }
+  parts.push("  Next steps:");
+  parts.push("    1. Configure authentication via `opencode auth login`");
+  parts.push("    2. Verify with `bunx opencode-matrixx doctor`");
+  if (pluginEntry === "opencode-matrixx") {
+    parts.push("    3. Restart OpenCode to load the plugin");
+  } else {
+    parts.push("    3. Run `bun run build` in the repo, then restart OpenCode");
+  }
+  parts.push("");
+  return parts.join(`
+`);
+}
+
+// src/cli/index.ts
+function getVersion() {
+  try {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      join5(thisDir, "../../package.json"),
+      join5(thisDir, "../package.json"),
+      "package.json"
+    ];
+    for (const p of candidates) {
+      try {
+        const raw = readFileSync5(p, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version && typeof pkg.version === "string")
+          return pkg.version;
+      } catch {}
+    }
+  } catch {}
+  return "2.6.0";
+}
+var VERSION = getVersion();
+function printHelp() {
+  console.log(`
+Matrixx CLI v${VERSION}
+
+Usage: bunx opencode-matrixx <command> [options]
+
+Commands:
+  doctor     Environment diagnostics and health checks
+  install    Interactive setup wizard
+  version    Display version information
+  help       Display this help message
+
+Options:
+  --help, -h    Show help for any command
+  --json        (doctor) Output results as JSON
+  --category    (doctor) Check specific category only
+  --no-tui      (install) Run in non-interactive mode (CI/CD)
+  --local       (install) Use local repo file:// path (dev only)
+  --verbose     (install) Display detailed logs
+
+Doctor categories:
+  installation   Plugin registration and OpenCode version
+  configuration  Config file validation
+  authentication Provider API key status
+  dependencies   Runtime dependencies (Bun, Node, Git, Python)
+  tools          Optional tools (ast-grep, Gitleaks, PyMuPDF, Playwright)
+
+Subscription flags (install --no-tui):
+  --claude=<yes|no|max20>
+  --openai=<yes|no>
+  --gemini=<yes|no>
+  --copilot=<yes|no>
+  --opencode-zen=<yes|no>
+  --zai-coding-plan=<yes|no>
+    `);
+}
+function parseArgs(argv) {
+  const result = {
+    command: "",
+    help: false,
+    json: false,
+    noTui: false,
+    verbose: false,
+    local: false,
+    extra: []
+  };
+  let args = argv.slice(2);
+  if (args.length === 0) {
+    result.help = true;
+    return result;
+  }
+  result.command = args[0];
+  args = args.slice(1);
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--help" || a === "-h") {
+      result.help = true;
+    } else if (a === "--json") {
+      result.json = true;
+    } else if (a === "--no-tui") {
+      result.noTui = true;
+    } else if (a === "--local") {
+      result.local = true;
+    } else if (a === "--verbose") {
+      result.verbose = true;
+    } else if (a.startsWith("--category=")) {
+      result.category = a.slice("--category=".length);
+    } else if (a === "--category" && i + 1 < args.length) {
+      result.category = args[++i];
+    } else if (a.startsWith("--claude=")) {
+      const v = a.slice("--claude=".length);
+      if (["yes", "no", "max20"].includes(v))
+        result.claude = v;
+    } else if (a.startsWith("--openai=")) {
+      const v = a.slice("--openai=".length);
+      if (["yes", "no"].includes(v))
+        result.openai = v;
+    } else if (a.startsWith("--gemini=")) {
+      const v = a.slice("--gemini=".length);
+      if (["yes", "no"].includes(v))
+        result.gemini = v;
+    } else if (a.startsWith("--copilot=")) {
+      const v = a.slice("--copilot=".length);
+      if (["yes", "no"].includes(v))
+        result.copilot = v;
+    } else if (a.startsWith("--opencode-zen=")) {
+      const v = a.slice("--opencode-zen=".length);
+      if (["yes", "no"].includes(v))
+        result.opencodeZen = v;
+    } else if (a.startsWith("--zai-coding-plan=")) {
+      const v = a.slice("--zai-coding-plan=".length);
+      if (["yes", "no"].includes(v))
+        result.zaiCodingPlan = v;
+    } else {
+      result.extra.push(a);
+    }
+  }
+  return result;
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (!args.command || args.command === "help" || args.help) {
+    printHelp();
+    return;
+  }
+  if (args.command === "version") {
+    console.log(VERSION);
+    return;
+  }
+  if (args.command === "doctor") {
+    const output = await executeDoctor({
+      category: args.category,
+      json: args.json
+    });
+    console.log(output);
+    return;
+  }
+  if (args.command === "install") {
+    const output = await executeInstall({
+      noTui: args.noTui,
+      verbose: args.verbose,
+      local: args.local,
+      claude: args.claude,
+      openai: args.openai,
+      gemini: args.gemini,
+      copilot: args.copilot,
+      opencodeZen: args.opencodeZen,
+      zaiCodingPlan: args.zaiCodingPlan
+    });
+    console.log(output);
+    return;
+  }
+  console.error(`Unknown command: ${args.command}
+`);
+  printHelp();
+  process.exit(1);
+}
+var cli_default = main;
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}
+export {
+  cli_default as default,
+  main
+};