claude-smart 0.2.45 → 0.2.47

package/bin/claude-smart.js

@@ -17,13 +17,17 @@ const { execSync, spawn, spawnSync } = require("child_process");
 const crypto = require("crypto");
 const {
   chmodSync,
+  constants,
   cpSync,
   existsSync,
+  accessSync,
   lstatSync,
   mkdirSync,
   readFileSync,
   readdirSync,
+  realpathSync,
   renameSync,
+  rmdirSync,
   rmSync,
   statSync,
   symlinkSync,
@@ -31,12 +35,15 @@ const {
 } = require("fs");
 const https = require("https");
 const { arch, homedir, platform, release, tmpdir } = require("os");
-const { dirname, join } = require("path");
+const { dirname, join, resolve } = require("path");
+const { fileURLToPath, pathToFileURL } = require("url");
 
 const PLUGIN_SPEC = "claude-smart@reflexioai";
 const CODEX_MARKETPLACE_NAME = "reflexioai";
 const CODEX_MARKETPLACE_DISPLAY_NAME = "ReflexioAI";
 const CODEX_PLUGIN_ID = `claude-smart@${CODEX_MARKETPLACE_NAME}`;
+const OPENCODE_BARE_PLUGIN_SPEC = "claude-smart";
+const OPENCODE_CONFIG_NAMES = ["opencode.json", "opencode.jsonc"];
 const REFLEXIO_ENV_PATH = join(homedir(), ".reflexio", ".env");
 const MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/";
 const MANAGED_SETUP_ENV = "CLAUDE_SMART_MANAGED_SETUP";
@@ -46,6 +53,9 @@ const CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV = "CLAUDE_SMART_USE_LOCAL_EMBEDDING";
 const REFLEXIO_USER_ID_ENV = "REFLEXIO_USER_ID";
 const REFLEXIO_DIR = join(homedir(), ".reflexio");
 const CLAUDE_SMART_STATE_DIR = join(homedir(), ".claude-smart");
+const OPENCODE_LOCAL_PACKAGE_DIR = join(CLAUDE_SMART_STATE_DIR, "opencode", "claude-smart");
+const OPENCODE_PACKAGE_LOCK_TIMEOUT_MS = 120_000;
+const OPENCODE_PACKAGE_LOCK_STALE_MS = 10 * 60_000;
 const CODEX_CONFIG_PATH = join(homedir(), ".codex", "config.toml");
 const PACKAGE_ROOT = dirname(dirname(__filename));
 const CODEX_MARKETPLACE_DIR = join(
@@ -79,6 +89,9 @@ const CODEX_REQUIRED_FILES = [
   "plugin/scripts/codex-claude-compat",
   "plugin/scripts/codex-claude-compat.cmd",
   "plugin/scripts/codex-claude-compat.js",
+  "plugin/scripts/opencode-claude-compat",
+  "plugin/scripts/opencode-claude-compat.cmd",
+  "plugin/scripts/opencode-claude-compat.js",
   "plugin/scripts/codex-hook.js",
   "plugin/scripts/_codex_env.sh",
 ];
@@ -89,6 +102,7 @@ const COPYTREE_IGNORE_NAMES = new Set([
   ".venv",
   ".pytest_cache",
   ".ruff_cache",
+  ".git",
   "node_modules",
   ".next",
 ]);
@@ -342,6 +356,200 @@ function configureReflexioSetup() {
   return loadReflexioSetupEnv();
 }
 
+function stripJsonc(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  const skipTrivia = (index) => {
+    while (index < text.length) {
+      while (index < text.length && /\s/.test(text[index])) index += 1;
+      if (text[index] === "/" && text[index + 1] === "/") {
+        index += 2;
+        while (index < text.length && !"\r\n".includes(text[index])) index += 1;
+        continue;
+      }
+      if (text[index] === "/" && text[index + 1] === "*") {
+        index += 2;
+        while (index + 1 < text.length && !(text[index] === "*" && text[index + 1] === "/")) index += 1;
+        index = Math.min(index + 2, text.length);
+        continue;
+      }
+      break;
+    }
+    return index;
+  };
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1] || "";
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < text.length && !"\r\n".includes(text[i])) i += 1;
+      i -= 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i + 1 < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+      i += 1;
+      continue;
+    }
+    if (ch === ",") {
+      const j = skipTrivia(i + 1);
+      if (text[j] === "}" || text[j] === "]") continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+function readJsoncObject(path) {
+  const text = existsSync(path) ? readFileSync(path, "utf8") : "{}";
+  const parsed = JSON.parse(stripJsonc(text || "{}"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`OpenCode config ${path} must be a JSON object`);
+  }
+  return parsed;
+}
+
+function parseGlobalFlag(args) {
+  return args.includes("--global");
+}
+
+function opencodeGlobalConfigDir() {
+  const xdg = (process.env.XDG_CONFIG_HOME || "").trim();
+  const base = xdg ? xdg : join(homedir(), ".config");
+  return join(base, "opencode");
+}
+
+function opencodeConfigPath(args = [], cwd = process.cwd()) {
+  if (parseGlobalFlag(args)) {
+    const configDir = opencodeGlobalConfigDir();
+    for (const name of OPENCODE_CONFIG_NAMES) {
+      const candidate = join(configDir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+    return join(configDir, "opencode.json");
+  }
+  const candidates = [
+    ...OPENCODE_CONFIG_NAMES.map((name) => join(cwd, name)),
+    ...OPENCODE_CONFIG_NAMES.map((name) => join(cwd, ".opencode", name)),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return join(cwd, "opencode.json");
+}
+
+function opencodePluginSpec(entry) {
+  if (typeof entry === "string") return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0];
+  return null;
+}
+
+function opencodeLocalPluginSpec(packageRoot = OPENCODE_LOCAL_PACKAGE_DIR) {
+  return pathToFileURL(packageRoot).href;
+}
+
+function isOpenCodeLocalPackagePath(packagePath) {
+  return (
+    sameRealPath(packagePath, OPENCODE_LOCAL_PACKAGE_DIR) ||
+    resolve(packagePath) === resolve(OPENCODE_LOCAL_PACKAGE_DIR)
+  );
+}
+
+function isOpenCodeClaudeSmartSpec(spec) {
+  if (!spec) return false;
+  if (spec === OPENCODE_BARE_PLUGIN_SPEC || spec.startsWith(`${OPENCODE_BARE_PLUGIN_SPEC}@`)) {
+    return true;
+  }
+  if (!spec.startsWith("file://")) return false;
+  let packagePath = null;
+  try {
+    packagePath = fileURLToPath(spec);
+  } catch {
+    return false;
+  }
+  if (isOpenCodeLocalPackagePath(packagePath)) return true;
+  try {
+    const manifest = JSON.parse(readFileSync(join(packagePath, "package.json"), "utf8"));
+    if (manifest && manifest.name === OPENCODE_BARE_PLUGIN_SPEC) return true;
+  } catch {
+    // Missing or malformed manifests are not enough to identify arbitrary file specs.
+  }
+  return false;
+}
+
+function patchOpenCodePluginConfig(configPath, { install, pluginSpec = null }) {
+  const resolvedPluginSpec = install ? (pluginSpec || opencodeLocalPluginSpec()) : pluginSpec;
+  const data = readJsoncObject(configPath);
+  for (const field of ["plugins", "plugin"]) {
+    if (data[field] !== undefined && !Array.isArray(data[field])) {
+      throw new Error(`OpenCode config ${configPath} field "${field}" must be a JSON array`);
+    }
+  }
+  const current = [
+    ...(Array.isArray(data.plugin) ? data.plugin : []),
+    ...(Array.isArray(data.plugins) ? data.plugins : []),
+  ];
+  const kept = current.filter((entry) => !isOpenCodeClaudeSmartSpec(opencodePluginSpec(entry)));
+  const next = install ? [...kept, resolvedPluginSpec] : kept;
+  const changed =
+    data.plugins !== undefined ||
+    (Array.isArray(data.plugin)
+      ? next.length !== data.plugin.length || next.some((entry, index) => entry !== data.plugin[index])
+      : install && next.length > 0);
+  if (!changed) return { changed: false, configPath };
+  let backupPath = null;
+  if (existsSync(configPath)) {
+    const original = readFileSync(configPath, "utf8");
+    if (original.trim() && original !== stripJsonc(original)) {
+      backupPath = `${configPath}.bak`;
+      writeFileSync(backupPath, original);
+    }
+  }
+  data.plugin = next;
+  delete data.plugins;
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(data, null, 2) + "\n");
+  return { changed: true, configPath, backupPath };
+}
+
+function hasExtractionProvider() {
+  if ((process.env.REFLEXIO_API_KEY || "").trim()) return true;
+  const cliPath = (process.env.CLAUDE_SMART_CLI_PATH || "").trim();
+  if (cliPath && isExecutableFile(cliPath)) return true;
+  return hasCli("claude") || hasCli("codex") || hasCli("opencode");
+}
+
+function isExecutableFile(path) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function extractionProviderError() {
+  return (
+    "error: OpenCode support needs a working learning/extraction provider.\n" +
+    "Run `npx claude-smart setup` to configure Reflexio, or install " +
+    "OpenCode, Claude Code, or Codex so local extraction can use a supported CLI.\n"
+  );
+}
+
 function findClaudeCodePluginRoot() {
   const cacheRoot = join(homedir(), ".claude", "plugins", "cache", CODEX_MARKETPLACE_NAME, "claude-smart");
   const candidates = [];
@@ -429,6 +637,130 @@ function forcePluginRoot(pluginRoot) {
   }
 }
 
+function sameRealPath(left, right) {
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return false;
+  }
+}
+
+function pathEntryExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function fileSha256(path) {
+  return crypto.createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+function verifyOpenCodePluginPackage(packageRoot) {
+  const sourceScript = join(PACKAGE_ROOT, "plugin", "scripts", "smart-install.sh");
+  const copiedScript = join(packageRoot, "plugin", "scripts", "smart-install.sh");
+  for (const file of [join(packageRoot, "package.json"), copiedScript]) {
+    if (!existsSync(file)) {
+      throw new Error(`OpenCode local plugin package is missing ${file}`);
+    }
+  }
+  if (fileSha256(sourceScript) !== fileSha256(copiedScript)) {
+    throw new Error(
+      "OpenCode local plugin package does not match the installed claude-smart package",
+    );
+  }
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function withOpenCodePackageInstallLock(fn) {
+  const lockDir = join(dirname(OPENCODE_LOCAL_PACKAGE_DIR), ".install.lock");
+  mkdirSync(dirname(OPENCODE_LOCAL_PACKAGE_DIR), { recursive: true });
+  const deadline = Date.now() + OPENCODE_PACKAGE_LOCK_TIMEOUT_MS;
+  while (true) {
+    try {
+      mkdirSync(lockDir);
+      break;
+    } catch (err) {
+      if (!err || err.code !== "EEXIST") throw err;
+      try {
+        if (Date.now() - statSync(lockDir).mtimeMs > OPENCODE_PACKAGE_LOCK_STALE_MS) {
+          rmSync(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch (statErr) {
+        if (statErr && statErr.code !== "ENOENT") throw statErr;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`timed out waiting for OpenCode package install lock at ${lockDir}`);
+      }
+      sleepSync(100);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+
+function uniqueOpenCodePackagePath(prefix) {
+  return join(
+    dirname(OPENCODE_LOCAL_PACKAGE_DIR),
+    `${prefix}-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`,
+  );
+}
+
+function replaceOpenCodePluginPackage(stagedPackage, packageRoot) {
+  const backupPackage = uniqueOpenCodePackagePath(".claude-smart-previous");
+  let backupCreated = false;
+  try {
+    if (pathEntryExists(packageRoot)) {
+      renameSync(packageRoot, backupPackage);
+      backupCreated = true;
+    }
+    renameSync(stagedPackage, packageRoot);
+    if (backupCreated) {
+      rmSync(backupPackage, { recursive: true, force: true });
+    }
+  } catch (err) {
+    if (backupCreated && !existsSync(packageRoot) && existsSync(backupPackage)) {
+      renameSync(backupPackage, packageRoot);
+    }
+    throw err;
+  }
+}
+
+function installOpenCodePluginPackage() {
+  const packageRoot = OPENCODE_LOCAL_PACKAGE_DIR;
+  if (sameRealPath(PACKAGE_ROOT, packageRoot)) {
+    verifyOpenCodePluginPackage(packageRoot);
+    return packageRoot;
+  }
+  return withOpenCodePackageInstallLock(() => {
+    const stagedPackage = uniqueOpenCodePackagePath(".claude-smart-copy");
+    rmSync(stagedPackage, { recursive: true, force: true });
+    try {
+      cpSync(PACKAGE_ROOT, stagedPackage, {
+        recursive: true,
+        force: true,
+        verbatimSymlinks: false,
+        filter: shouldCopyPath,
+      });
+      verifyOpenCodePluginPackage(stagedPackage);
+      replaceOpenCodePluginPackage(stagedPackage, packageRoot);
+      verifyOpenCodePluginPackage(packageRoot);
+      return packageRoot;
+    } finally {
+      rmSync(stagedPackage, { recursive: true, force: true });
+    }
+  });
+}
+
 async function bootstrapClaudeCodeInstall() {
   const pluginRoot = findClaudeCodePluginRoot();
   if (!pluginRoot) {
@@ -523,6 +855,18 @@ function runChecked(command, args, options = {}) {
   });
 }
 
+function runSilentStatus(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    shell: isWindows() && /\.(?:cmd|bat)$/i.test(command),
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  if (result.error || result.signal) return 1;
+  return typeof result.status === "number" ? result.status : 1;
+}
+
 function runPluginService(pluginRoot, scriptName, subcommand, envOverrides = {}) {
   const script = join(pluginRoot, "scripts", scriptName);
   if (!existsSync(script)) return false;
@@ -921,11 +1265,66 @@ async function installVendoredReflexio(pluginRoot, uv, env) {
   if (code !== 0) throw new Error(`vendored Reflexio install failed in ${pluginRoot}`);
 }
 
+async function syncPluginPythonEnv(pluginRoot, uv, env) {
+  let code = await runChecked(
+    uv,
+    ["sync", "--locked", "--python", "3.12", "--quiet"],
+    { cwd: pluginRoot, env },
+  );
+  if (code === 0) return;
+
+  const lockIsFresh = runSilentStatus(
+    uv,
+    ["lock", "--check", "--python", "3.12"],
+    { cwd: pluginRoot, env },
+  ) === 0;
+  if (lockIsFresh) {
+    process.stderr.write(
+      `warning: quiet uv sync failed in ${pluginRoot}; retrying with full output.\n`,
+    );
+    code = await runChecked(
+      uv,
+      ["sync", "--locked", "--python", "3.12"],
+      { cwd: pluginRoot, env },
+    );
+    if (code !== 0) throw new Error(`uv sync failed in ${pluginRoot}`);
+    return;
+  }
+
+  process.stderr.write(
+    "warning: plugin/uv.lock is out of sync; refreshing local lockfile and retrying uv sync.\n",
+  );
+  code = await runChecked(
+    uv,
+    ["lock", "--python", "3.12"],
+    { cwd: pluginRoot, env },
+  );
+  if (code !== 0) throw new Error(`uv lock failed in ${pluginRoot}`);
+  code = await runChecked(
+    uv,
+    ["sync", "--python", "3.12", "--quiet"],
+    { cwd: pluginRoot, env },
+  );
+  if (code !== 0) {
+    process.stderr.write(
+      `warning: quiet uv sync failed in ${pluginRoot} after refreshing plugin/uv.lock; retrying with full output.\n`,
+    );
+    code = await runChecked(
+      uv,
+      ["sync", "--python", "3.12"],
+      { cwd: pluginRoot, env },
+    );
+  }
+  if (code !== 0) throw new Error(`uv sync failed in ${pluginRoot}`);
+}
+
 async function bootstrapPluginRuntime(pluginRoot, options = {}) {
   assertSupportedRuntimePlatform();
   process.stdout.write("Preparing claude-smart runtime for hooks...\n");
   const nodeRuntime = await ensurePrivateNode();
-  patchCodexHooksForNode(pluginRoot, nodeRuntime.node);
+  if (options.patchCodexHooks !== false) {
+    patchCodexHooksForNode(pluginRoot, nodeRuntime.node);
+  }
   if (options.readOnly) prunePublishHooksForReadOnly(pluginRoot);
   ensurePluginRoot(pluginRoot);
   const uv = await ensureUv();
@@ -940,27 +1339,12 @@ async function bootstrapPluginRuntime(pluginRoot, options = {}) {
     );
     if (lockCode !== 0) throw new Error(`uv lock failed in ${pluginRoot}`);
   }
-  let code = await runChecked(
-    uv,
-    ["sync", "--locked", "--python", "3.12", "--quiet"],
-    { cwd: pluginRoot, env },
-  );
-  if (code !== 0) {
-    process.stderr.write(
-      `warning: quiet uv sync failed in ${pluginRoot}; retrying with full output.\n`,
-    );
-    code = await runChecked(
-      uv,
-      ["sync", "--locked", "--python", "3.12"],
-      { cwd: pluginRoot, env },
-    );
-  }
-  if (code !== 0) throw new Error(`uv sync failed in ${pluginRoot}`);
+  await syncPluginPythonEnv(pluginRoot, uv, env);
   await installVendoredReflexio(pluginRoot, uv, env);
 
   const dashboardDir = join(pluginRoot, "dashboard");
   if (existsSync(dashboardDir)) {
-    code = await runChecked(nodeRuntime.npm, ["ci"], { cwd: dashboardDir, env });
+    let code = await runChecked(nodeRuntime.npm, ["ci"], { cwd: dashboardDir, env });
     if (code !== 0) throw new Error(`npm ci failed in ${dashboardDir}`);
     code = await runChecked(nodeRuntime.npm, ["run", "build"], { cwd: dashboardDir, env });
     if (code !== 0) throw new Error(`npm run build failed in ${dashboardDir}`);
@@ -970,13 +1354,15 @@ async function bootstrapPluginRuntime(pluginRoot, options = {}) {
 function printHelp() {
   process.stdout.write(
     [
-      "claude-smart — install helper for Claude Code and Codex",
+      "claude-smart — install helper for Claude Code, Codex, and OpenCode",
       "",
       "Usage:",
       "  npx claude-smart install                       Install the plugin into Claude Code",
       "  npx claude-smart install --host codex          Register the plugin marketplace for Codex",
+      "  npx claude-smart install --host opencode       Add claude-smart to OpenCode config",
       "  npx claude-smart setup                         Configure managed/read-only/global setup",
       "  npx claude-smart uninstall --host codex        Remove the Codex marketplace registration",
+      "  npx claude-smart uninstall --host opencode     Remove claude-smart from OpenCode config",
       "  npx claude-smart --help                        Show this help",
       "",
       "Claude Code install:",
@@ -993,9 +1379,16 @@ function printHelp() {
       "  6. Trusts and enables claude-smart hook entries in ~/.codex/config.toml",
       "  7. Restart Codex.",
       "",
+      "OpenCode install:",
+      `  1. Copies this package to ${OPENCODE_LOCAL_PACKAGE_DIR}`,
+      "  2. Adds that local file:// package to OpenCode's plugin list in opencode.json",
+      "  3. Prepares local services now from the copied plugin runtime",
+      "  4. Restart OpenCode.",
+      "",
       "Update:",
       "  npx claude-smart update                        Reinstall Claude Code support from this package",
       "  npx claude-smart update --host codex           Reinstall Codex support from this package",
+      "  npx claude-smart update --host opencode        Reinstall OpenCode support from this package",
       "  npx claude-smart setup                         Configure managed/read-only/global setup",
       "",
       "Uninstall:",
@@ -1010,11 +1403,11 @@ function parseHost(args) {
   if (idx === -1) return "claude-code";
   const value = args[idx + 1];
   if (!value) {
-    process.stderr.write("error: --host requires a value: claude-code or codex\n");
+    process.stderr.write("error: --host requires a value: claude-code, codex, or opencode\n");
     process.exit(1);
   }
-  if (value !== "claude-code" && value !== "codex") {
-    process.stderr.write("error: --host must be claude-code or codex\n");
+  if (value !== "claude-code" && value !== "codex" && value !== "opencode") {
+    process.stderr.write("error: --host must be claude-code, codex, or opencode\n");
     process.exit(1);
   }
   return value;
@@ -1433,6 +1826,10 @@ async function runUpdate(args) {
     await runUpdateCodex(args);
     return;
   }
+  if (parseHost(args) === "opencode") {
+    await runUpdateOpenCode(args);
+    return;
+  }
 
   const pluginRoot = findClaudeCodePluginRoot();
   if (pluginRoot) {
@@ -1449,11 +1846,22 @@ async function runUpdateCodex(args) {
   await runInstallCodex(args);
 }
 
+async function runUpdateOpenCode(args) {
+  const pluginRoot = join(PACKAGE_ROOT, "plugin");
+  stopClaudeSmartServices(pluginRoot);
+  process.stdout.write("Updating claude-smart OpenCode support by reinstalling from this package...\n");
+  await runInstallOpenCode(args);
+}
+
 async function runUninstall(args) {
   if (parseHost(args) === "codex") {
     await runUninstallCodex();
     return;
   }
+  if (parseHost(args) === "opencode") {
+    await runUninstallOpenCode(args);
+    return;
+  }
 
   if (!hasClaudeCli()) {
     process.stderr.write(
@@ -1504,6 +1912,10 @@ async function runInstall(args, options = {}) {
     await runInstallCodex(args);
     return;
   }
+  if (parseHost(args) === "opencode") {
+    await runInstallOpenCode(args);
+    return;
+  }
 
   if (!hasClaudeCli()) {
     process.stderr.write(
@@ -1686,6 +2098,68 @@ async function runInstallCodex(args) {
   );
 }
 
+async function runInstallOpenCode(args) {
+  const setup = configureReflexioSetup();
+  const readOnly = setup.readOnly;
+  if (!hasExtractionProvider()) {
+    process.stderr.write(extractionProviderError());
+    process.exit(1);
+  }
+
+  let packageRoot;
+  try {
+    packageRoot = installOpenCodePluginPackage();
+  } catch (err) {
+    process.stderr.write(
+      `error: could not prepare claude-smart OpenCode package: ${err && err.message ? err.message : err}\n`,
+    );
+    process.exit(1);
+  }
+  const pluginRoot = join(packageRoot, "plugin");
+  const pluginSpec = opencodeLocalPluginSpec(packageRoot);
+  let result;
+  try {
+    await bootstrapPluginRuntime(pluginRoot, { readOnly, patchCodexHooks: false });
+  } catch (err) {
+    process.stderr.write(
+      `error: claude-smart OpenCode setup failed during dependency bootstrap: ${err && err.message ? err.message : err}\n`,
+    );
+    process.exit(1);
+  }
+  try {
+    result = patchOpenCodePluginConfig(opencodeConfigPath(args), {
+      install: true,
+      pluginSpec,
+    });
+  } catch (err) {
+    process.stderr.write(`error: could not update OpenCode config: ${err && err.message ? err.message : err}\n`);
+    stopClaudeSmartServices(pluginRoot);
+    process.exit(1);
+  }
+  if (readOnly) {
+    process.stdout.write("Installed read-only hook manifest; publish interactions hooks are disabled.\n");
+  }
+  if (startBackendService(pluginRoot, "opencode")) {
+    process.stdout.write("Started claude-smart backend service.\n");
+  }
+  if (refreshDashboardService(pluginRoot)) {
+    process.stdout.write("Refreshed claude-smart dashboard service.\n");
+  }
+  if (result.backupPath) {
+    process.stdout.write(`Saved a comment-preserving backup of your previous config at ${result.backupPath}.\n`);
+  }
+  process.stdout.write(
+    [
+      "",
+      `${result.changed ? "Updated" : "OpenCode config already includes"} "${pluginSpec}" in ${result.configPath}.`,
+      `Prepared claude-smart OpenCode package at ${packageRoot}.`,
+      "claude-smart OpenCode support is installed.",
+      "Restart OpenCode in your project so it loads the plugin.",
+      "",
+    ].join("\n"),
+  );
+}
+
 async function runUninstallCodex() {
   stopClaudeSmartServices(join(PACKAGE_ROOT, "plugin"));
   if (!hasCli("codex")) {
@@ -1713,6 +2187,38 @@ async function runUninstallCodex() {
   );
 }
 
+async function runUninstallOpenCode(args) {
+  stopClaudeSmartServices(join(PACKAGE_ROOT, "plugin"));
+  stopClaudeSmartServices(join(OPENCODE_LOCAL_PACKAGE_DIR, "plugin"));
+  let result;
+  try {
+    result = patchOpenCodePluginConfig(opencodeConfigPath(args), { install: false });
+  } catch (err) {
+    process.stderr.write(`error: could not update OpenCode config: ${err && err.message ? err.message : err}\n`);
+    process.exit(1);
+  }
+  if (result.backupPath) {
+    process.stdout.write(`Saved a comment-preserving backup of your previous config at ${result.backupPath}.\n`);
+  }
+  rmSync(OPENCODE_LOCAL_PACKAGE_DIR, { recursive: true, force: true });
+  try {
+    rmdirSync(dirname(OPENCODE_LOCAL_PACKAGE_DIR));
+  } catch {
+    // Keep the parent when it still contains future OpenCode state.
+  }
+  process.stdout.write(
+    [
+      "",
+      result.changed
+        ? `Removed claude-smart OpenCode plugin entries from ${result.configPath}.`
+        : "OpenCode config did not include claude-smart.",
+      "Restart OpenCode to apply.",
+      ...LOCAL_DATA_NOTICE,
+      "",
+    ].join("\n"),
+  );
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const cmd = args[0] || "install";
@@ -1764,7 +2270,13 @@ module.exports = {
   ensureUv,
   configureReflexioSetup,
   patchCodexHooksForNode,
+  opencodeConfigPath,
+  opencodeLocalPluginSpec,
+  installOpenCodePluginPackage,
+  patchOpenCodePluginConfig,
+  hasExtractionProvider,
   platformSupportError,
   prunePublishHooksForReadOnly,
   restorePublishHooksFromSource,
+  stripJsonc,
 };