opencode-rules-md 0.8.5 → 0.9.0

package/dist/cli.mjs

@@ -5,8 +5,27 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/cli/main.ts
 import { parseArgs } from "node:util";
 
-// src/cli/install.ts
-import { dirname as dirname2, join as join3 } from "path";
+// src/cli/spawn.ts
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+async function spawnOpencodePlugin(args, opts = {}) {
+  const env = opts.env ?? process.env;
+  const stdio = opts.stdio ?? "inherit";
+  const spawnFn = opts.spawn ?? defaultSpawn;
+  return spawnFn("opencode", ["plugin", ...args], { env, stdio });
+}
+function defaultSpawn(command, args, options) {
+  const cp = require2("node:child_process");
+  const result = cp.spawnSync(command, args, {
+    env: options.env,
+    stdio: options.stdio
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout?.toString() ?? "",
+    stderr: result.stderr?.toString() ?? ""
+  };
+}
 
 // src/cli/config.ts
 import { join, dirname } from "path";
@@ -147,6 +166,13 @@ function normalizePlugin(raw) {
   }
   return [];
 }
+function readInstalledPlugins(config) {
+  const modern = config.data["plugin"];
+  if (modern !== undefined) {
+    return normalizePlugin(modern);
+  }
+  return normalizePlugin(config.data["plugins"]);
+}
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -246,6 +272,37 @@ function writeAtomically(fs, path, content) {
   }
 }
 
+// src/cli/install.ts
+var DEFAULT_SPECIFIER = PLUGIN_NAME;
+function buildSpecifier(version) {
+  const trimmed = version?.trim() ?? "";
+  if (!trimmed || trimmed === "latest") {
+    return DEFAULT_SPECIFIER;
+  }
+  return `${PLUGIN_NAME}@${trimmed}`;
+}
+var runInstall = async (opts = {}, _fs, env) => {
+  const specifier = buildSpecifier(opts.version);
+  const spawnFn = opts.spawn ?? spawnOpencodePlugin;
+  const targetEnv = env ?? process.env;
+  if (opts.dryRun) {
+    console.log(`omd: would run: opencode plugin ${specifier} --global`);
+    return { status: "skipped", specifier };
+  }
+  const result = await spawnFn([specifier, "--global"], { env: targetEnv, stdio: "inherit" });
+  if ((result.status ?? 0) !== 0) {
+    throw new Error(`opencode plugin ${specifier} --global exited with status ${String(result.status)}`);
+  }
+  return { status: "wrote", specifier };
+};
+
+// src/cli/uninstall.ts
+import { join as join3 } from "path";
+
+// src/cli/update.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
 // src/cli/registry.ts
 var REGISTRY_URL = "https://registry.npmjs.org/opencode-rules-md/latest";
 var fetchLatestVersion = async () => {
@@ -266,87 +323,45 @@ var isStale = (installed, latest) => {
 };
 
 // src/cli/update.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-var CACHE_PATH = join2(homedir2(), ".cache", "opencode", "node_modules", "opencode-rules-md");
-function resolveCachePath(env = process.env) {
-  return join2(env.HOME ?? homedir2(), ".cache", "opencode", "node_modules", "opencode-rules-md");
+var CONFIG_BASENAMES = ["opencode", "tui"];
+var PACKAGES_DIR_BASENAME = [".cache", "opencode", "packages"];
+var CACHE_DIR_BASENAME = "opencode-rules-md";
+function resolveHome(env = process.env) {
+  return env.HOME ?? homedir2();
 }
-function readCacheVersion(fs, cachePath) {
-  const pkgPath = join2(cachePath, "package.json");
-  try {
-    if (!fs.existsSync(pkgPath)) {
-      return null;
+function resolvePackagesDir(env = process.env) {
+  return join2(resolveHome(env), ...PACKAGES_DIR_BASENAME);
+}
+function resolveCachePaths(env = process.env, fs) {
+  const packagesDir = resolvePackagesDir(env);
+  if (fs && fs.existsSync(packagesDir)) {
+    try {
+      const entries = fs.readdirSync(packagesDir);
+      return entries.filter((name) => name === CACHE_DIR_BASENAME || name.startsWith(`${CACHE_DIR_BASENAME}@`)).map((name) => join2(packagesDir, name));
+    } catch {
+      return [];
     }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath));
-    return typeof pkg.version === "string" ? pkg.version : null;
-  } catch {
-    return null;
   }
+  return [
+    join2(packagesDir, CACHE_DIR_BASENAME),
+    join2(packagesDir, `${CACHE_DIR_BASENAME}@latest`)
+  ];
 }
-var CONFIG_BASENAMES = ["opencode", "tui"];
-var runUpdate = async (fs, env, log, _error, opts = {}) => {
-  const latest = opts.latestVersion !== undefined ? opts.latestVersion : await fetchLatestVersion();
-  const cachePath = resolveCachePath(env);
-  if (latest === null) {
-    log("omd: could not determine latest version from npm registry");
-    return {
-      status: "unreachable",
-      cachePath,
-      instruction: "npx opencode-rules-md@latest install"
-    };
-  }
-  let installedVersion = null;
-  for (const basename of CONFIG_BASENAMES) {
-    const loaded = loadGlobalConfig(fs, env, basename);
-    const plugins = normalizePlugin(loaded.data["plugins"]);
+function findInstalledSpecifier(loaded) {
+  for (const cfg of loaded) {
+    const plugins = readInstalledPlugins(cfg);
     const match = plugins.find((p) => matchesPlugin(p));
-    if (match) {
-      const atIndex = match.lastIndexOf("@");
-      installedVersion = atIndex >= 0 ? match.slice(atIndex + 1) : null;
-      break;
-    }
+    if (match)
+      return match;
   }
-  const instruction = `npx opencode-rules-md@latest install`;
-  if (installedVersion !== null && !isStale(installedVersion, latest)) {
-    log(`omd: opencode-rules-md@${installedVersion} is already the latest`);
-    return {
-      status: "current",
-      cachePath,
-      instruction
-    };
-  }
-  const cacheVersion = readCacheVersion(fs, cachePath);
-  const shouldPurge = cacheVersion === null || cacheVersion !== latest;
-  if (opts.dryRun) {
-    log(`omd: update check (dry-run)`);
-    log(`  latest version: ${latest}`);
-    log(`  installed version: ${installedVersion ?? "not installed"}`);
-    log(`  would purge: ${shouldPurge ? cachePath : "(nothing to purge)"}`);
-    log(`  would instruct: ${instruction}`);
-    return {
-      status: "stale",
-      cachePath,
-      instruction
-    };
-  }
-  if (shouldPurge) {
-    try {
-      if (fs.existsSync(cachePath)) {
-        purgeDirectory(fs, cachePath);
-      }
-    } catch {}
-  }
-  log(`omd: opencode-rules-md is stale (latest: ${latest})`);
-  log(`omd: cache purged at ${cachePath}`);
-  log(`omd: to reinstall, run:`);
-  log(`  ${instruction}`);
-  return {
-    status: "stale",
-    cachePath,
-    instruction
-  };
-};
+  return null;
+}
+function extractVersion(specifier) {
+  const at = specifier.lastIndexOf("@");
+  if (at < 0 || at === specifier.length - 1)
+    return null;
+  return specifier.slice(at + 1);
+}
 function purgeDirectory(fs, dirPath) {
   let entries = [];
   try {
@@ -357,18 +372,18 @@ function purgeDirectory(fs, dirPath) {
   for (const entry of entries) {
     const entryPath = join2(dirPath, entry);
     try {
-      if (fs.existsSync(entryPath)) {
-        try {
-          const subEntries = fs.readdirSync(entryPath);
-          if (subEntries.length === 0) {
-            fs.rmdirSync(entryPath);
-          } else {
-            purgeDirectory(fs, entryPath);
-            fs.rmdirSync(entryPath);
-          }
-        } catch {
-          fs.unlinkSync(entryPath);
+      if (!fs.existsSync(entryPath))
+        continue;
+      try {
+        const subEntries = fs.readdirSync(entryPath);
+        if (subEntries.length === 0) {
+          fs.rmdirSync(entryPath);
+        } else {
+          purgeDirectory(fs, entryPath);
+          fs.rmdirSync(entryPath);
         }
+      } catch {
+        fs.unlinkSync(entryPath);
       }
     } catch {}
   }
@@ -376,158 +391,119 @@ function purgeDirectory(fs, dirPath) {
     fs.rmdirSync(dirPath);
   } catch {}
 }
-
-// src/cli/install.ts
-var CONFIG_BASENAMES2 = ["opencode", "tui"];
-async function resolveVersion(opts) {
-  const raw = opts.version?.trim() ?? "";
-  const wantsLatest = raw === "" || raw === "latest";
-  if (!wantsLatest) {
-    return raw;
-  }
-  if (opts.latestVersion !== undefined) {
-    return opts.latestVersion;
-  }
-  const latest = await fetchLatestVersion();
-  return latest ?? "latest";
-}
-function readCacheVersion2(fs, cachePath) {
-  const pkgPath = join3(cachePath, "package.json");
-  try {
-    if (!fs.existsSync(pkgPath)) {
-      return null;
-    }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath));
-    return typeof pkg.version === "string" ? pkg.version : null;
-  } catch {
-    return null;
-  }
-}
-function purgeCacheIfStale(fs, env, resolvedVersion) {
-  if (resolvedVersion === "latest") {
-    return false;
+var runUpdate = async (fs, env, log, _error, opts = {}) => {
+  const latest = opts.latestVersion !== undefined ? opts.latestVersion : await fetchLatestVersion();
+  const cachePaths = resolveCachePaths(env, fs);
+  const instruction = "opencode plugin opencode-rules-md --global --force";
+  const spawnFn = opts.spawn ?? spawnOpencodePlugin;
+  if (latest === null) {
+    log("omd: could not determine latest version from npm registry");
+    return { status: "unreachable", cachePaths, instruction };
   }
-  const cachePath = resolveCachePath(env);
-  if (!fs.existsSync(cachePath)) {
-    return false;
+  const configs = CONFIG_BASENAMES.map((basename) => loadGlobalConfig(fs, env, basename));
+  const installedSpecifier = findInstalledSpecifier(configs);
+  const installedVersion = installedSpecifier ? extractVersion(installedSpecifier) : null;
+  if (installedVersion !== null && !isStale(installedVersion, latest)) {
+    log(`omd: opencode-rules-md@${installedVersion} is already the latest`);
+    return { status: "current", cachePaths, instruction: "" };
   }
-  const cacheVersion = readCacheVersion2(fs, cachePath);
-  if (cacheVersion === null || cacheVersion !== resolvedVersion) {
-    purgeDirectory(fs, cachePath);
-    return true;
+  if (opts.dryRun) {
+    log("omd: update check (dry-run)");
+    log(`  latest version: ${latest}`);
+    log(`  installed version: ${installedVersion ?? "not installed"}`);
+    log(`  would purge: ${cachePaths.join(", ") || "(none found)"}`);
+    log(`  would instruct: ${instruction}`);
+    return { status: "stale", cachePaths, instruction };
   }
-  return false;
-}
-var runInstall = async (opts = {}, fs, env) => {
-  const resolvedVersion = await resolveVersion(opts);
-  const freshEntry = `${PLUGIN_NAME}@${resolvedVersion}`;
-  const results = [];
-  let anyProcessed = false;
-  for (const basename of CONFIG_BASENAMES2) {
-    const loaded = loadGlobalConfig(fs, env, basename);
-    const plugins = normalizePlugin(loaded.data["plugins"]);
-    const existingEntry = plugins.find((p) => matchesPlugin(p));
-    if (existingEntry === freshEntry) {
-      results.push({ path: loaded.path, status: "skipped", backup: null });
-      continue;
-    }
-    anyProcessed = true;
-    const withoutStale = plugins.filter((p) => !matchesPlugin(p));
-    const newPlugins = [...withoutStale, freshEntry];
-    const newData = { ...loaded.data, plugins: newPlugins };
-    const newContent = JSON.stringify(newData, null, 2) + `
-`;
-    if (opts.dryRun) {
-      results.push({ path: loaded.path, status: "wrote", backup: null });
-      continue;
-    }
-    let backup;
-    if (loaded.exists) {
-      backup = backupIfWritable(fs, loaded.path);
-      if (backup !== undefined) {
-        const dir = dirname2(loaded.path);
-        const segs = loaded.path.replace(/\\/g, "/").split("/");
-        const base = segs[segs.length - 1] ?? loaded.path;
-        const dot = base.lastIndexOf(".");
-        const name = dot >= 0 ? base.slice(0, dot) : base;
-        rotateBackups(fs, dir, name, 3);
+  log(installedVersion === null ? `omd: opencode-rules-md is not installed; registering latest (${latest})` : `omd: opencode-rules-md is stale (installed ${installedVersion}, latest ${latest})`);
+  for (const cachePath of cachePaths) {
+    try {
+      if (fs.existsSync(cachePath)) {
+        purgeDirectory(fs, cachePath);
+        log(`omd: purged cache ${cachePath}`);
       }
-    }
-    writeAtomically(fs, loaded.path, newContent);
-    results.push({
-      path: loaded.path,
-      status: "wrote",
-      backup: backup ?? null
-    });
+    } catch {}
   }
-  let purged = false;
-  if (!opts.dryRun) {
-    purged = purgeCacheIfStale(fs, env, resolvedVersion);
+  const result = await spawnFn(["opencode-rules-md", "--global", "--force"], {
+    env: process.env,
+    stdio: "inherit"
+  });
+  if ((result.status ?? 0) !== 0) {
+    throw new Error(`opencode plugin opencode-rules-md --global --force exited with status ${String(result.status)}`);
   }
-  return {
-    status: anyProcessed ? "wrote" : "skipped",
-    results,
-    purged
-  };
+  return { status: "stale", cachePaths, instruction: "" };
 };
 
 // src/cli/uninstall.ts
-import { dirname as dirname3, join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-var CONFIG_BASENAMES3 = ["opencode", "tui"];
+var CONFIG_BASENAMES2 = ["opencode", "tui"];
+function stripFromData(data) {
+  let removed = 0;
+  const next = { ...data };
+  const currentRaw = next["plugin"] ?? next["plugins"];
+  if (currentRaw !== undefined) {
+    if (typeof currentRaw === "string") {
+      if (currentRaw.startsWith("opencode-rules-md")) {
+        delete next["plugin"];
+        delete next["plugins"];
+        removed += 1;
+      }
+    } else if (Array.isArray(currentRaw)) {
+      const filtered = currentRaw.filter((p) => !(typeof p === "string" && p.startsWith("opencode-rules-md")));
+      if (filtered.length !== currentRaw.length) {
+        removed += currentRaw.length - filtered.length;
+        if (filtered.length === 0) {
+          delete next["plugin"];
+          delete next["plugins"];
+        } else {
+          next["plugin"] = filtered;
+          delete next["plugins"];
+        }
+      }
+    }
+  }
+  return { next, removed };
+}
 var runUninstall = (opts = {}, fs, env) => {
   const results = [];
   let anyProcessed = false;
   let purged = false;
   if (opts.purge) {
-    const cachePath = join4(homedir3(), ".cache", "opencode", "node_modules", "opencode-rules-md");
-    if (fs.existsSync(cachePath)) {
+    const cachePaths = resolveCachePaths(env, fs);
+    for (const cachePath of cachePaths) {
       try {
-        const entries = fs.readdirSync(cachePath);
-        if (entries.length === 0) {
-          fs.rmdirSync(cachePath);
-        } else {
-          for (const entry of entries) {
-            const entryPath = join4(cachePath, entry);
-            if (fs.existsSync(entryPath)) {
-              try {
-                fs.unlinkSync(entryPath);
-              } catch {}
-            }
-          }
-          fs.rmdirSync(cachePath);
+        if (fs.existsSync(cachePath)) {
+          purgeDirectory(fs, cachePath);
+          purged = true;
         }
-        purged = true;
       } catch {}
     }
   }
-  for (const basename of CONFIG_BASENAMES3) {
+  for (const basename of CONFIG_BASENAMES2) {
     const loaded = loadGlobalConfig(fs, env, basename);
-    const plugins = normalizePlugin(loaded.data["plugins"]);
-    const remaining = plugins.filter((p) => !matchesPlugin(p));
-    if (remaining.length === plugins.length) {
+    if (!loaded.exists) {
+      results.push({ path: loaded.path, status: "skipped", backup: null });
+      continue;
+    }
+    const { next, removed } = stripFromData(loaded.data);
+    if (removed === 0) {
       results.push({ path: loaded.path, status: "skipped", backup: null });
       continue;
     }
     anyProcessed = true;
-    const newData = { ...loaded.data, plugins: remaining };
-    const newContent = JSON.stringify(newData, null, 2) + `
+    const newContent = JSON.stringify(next, null, 2) + `
 `;
     if (opts.dryRun) {
       results.push({ path: loaded.path, status: "wrote", backup: null });
       continue;
     }
-    let backup;
-    if (loaded.exists) {
-      backup = backupIfWritable(fs, loaded.path);
-      if (backup !== undefined) {
-        const dir = dirname3(loaded.path);
-        const segs = loaded.path.replace(/\\/g, "/").split("/");
-        const base = segs[segs.length - 1] ?? loaded.path;
-        const dot = base.lastIndexOf(".");
-        const name = dot >= 0 ? base.slice(0, dot) : base;
-        rotateBackups(fs, dir, name, 3);
-      }
+    const backup = backupIfWritable(fs, loaded.path);
+    if (backup !== undefined) {
+      const segs = loaded.path.replace(/\\/g, "/").split("/");
+      const base = segs[segs.length - 1] ?? loaded.path;
+      const dot = base.lastIndexOf(".");
+      const name = dot >= 0 ? base.slice(0, dot) : base;
+      const dir = join3(...segs.slice(0, -1));
+      rotateBackups(fs, dir, name, 3);
     }
     writeAtomically(fs, loaded.path, newContent);
     results.push({
@@ -544,29 +520,28 @@ var runUninstall = (opts = {}, fs, env) => {
 };
 
 // src/cli/status.ts
-import { join as join5, dirname as dirname4 } from "path";
-import { homedir as homedir4 } from "os";
-import { extname } from "path";
+import { join as join4, dirname as dirname2, extname } from "path";
+import { homedir as homedir3 } from "os";
 var RULE_DIR_NAME = "opencode-rules-md";
 var MIN_NODE_VERSION = 20;
-var CONFIG_BASENAMES4 = ["opencode", "tui"];
-var runStatus = async (fs, env, log) => {
+var CONFIG_BASENAMES3 = ["opencode", "tui"];
+var runStatus = async (fs, env, log, opts = {}) => {
   const configs = [];
-  const latest = await fetchLatestVersion();
-  for (const basename of CONFIG_BASENAMES4) {
+  const latest = opts.latestVersion !== undefined ? opts.latestVersion : await fetchLatestVersion();
+  for (const basename of CONFIG_BASENAMES3) {
     const loaded = loadGlobalConfig(fs, env, basename);
     const format = extname(loaded.path);
-    const plugins = normalizePlugin(loaded.data["plugins"]);
-    const match = plugins.find((p) => matchesPlugin(p));
+    const plugins = readInstalledPlugins(loaded);
+    const match = plugins.find((p) => matchesPlugin(p)) ?? null;
     const entry = {
       basename,
       path: loaded.path,
       format,
-      installed: match ?? null,
-      notInstalled: !loaded.exists ? true : match === undefined || match === null,
+      installed: match,
+      notInstalled: !loaded.exists || match === null,
       otherPlugins: plugins.filter((p) => !matchesPlugin(p)),
       latest,
-      isLatest: match !== undefined && latest !== null ? match === `opencode-rules-md@${latest}` : null
+      isLatest: match !== null && latest !== null ? match === `opencode-rules-md@${latest}` : null
     };
     configs.push(entry);
     if (!loaded.exists) {
@@ -578,7 +553,7 @@ var runStatus = async (fs, env, log) => {
       const isLatestLabel = entry.isLatest === true ? " (latest)" : entry.isLatest === false ? ` (behind: latest is ${latest ?? "unknown"})` : "";
       log(`  opencode-rules-md: ${match}${isLatestLabel}`);
     } else {
-      log(`  opencode-rules-md: not installed`);
+      log("  opencode-rules-md: not installed");
     }
     if (entry.otherPlugins.length > 0) {
       log(`  other plugins: ${entry.otherPlugins.join(", ")}`);
@@ -619,7 +594,7 @@ var runDoctor = async (fs, env, log, error, opts = {}) => {
   } else {
     log("  Bun — found on PATH");
   }
-  for (const basename of CONFIG_BASENAMES4) {
+  for (const basename of CONFIG_BASENAMES3) {
     log(`Checking ${basename} config...`);
     const loaded = loadGlobalConfig(fs, env, basename);
     if (!loaded.exists) {
@@ -628,33 +603,46 @@ var runDoctor = async (fs, env, log, error, opts = {}) => {
       continue;
     }
     log(`  ${basename}${extname(loaded.path)}: ${loaded.path}`);
-    const plugins = normalizePlugin(loaded.data["plugins"]);
-    const match = plugins.find((p) => matchesPlugin(p));
+    const plugins = readInstalledPlugins(loaded);
+    const match = plugins.find((p) => matchesPlugin(p)) ?? null;
     if (match) {
-      info.push(`${basename}: opencode-rules-md@${match ?? "unknown"} installed`);
+      info.push(`${basename}: opencode-rules-md installed (${match})`);
       log(`  opencode-rules-md: ${match}`);
     } else {
       warnings.push(`${basename}: plugin not installed`);
-      log(`  opencode-rules-md: not installed`);
+      log("  opencode-rules-md: not installed");
     }
-    if (loaded.data["plugins"] !== undefined && !Array.isArray(loaded.data["plugins"]) && typeof loaded.data["plugins"] !== "object") {
-      issues.push(`${basename}: plugins field has invalid type — expected array or object`);
+    if (loaded.data["plugins"] !== undefined && loaded.data["plugin"] === undefined) {
+      warnings.push(`${basename}: legacy "plugins" field present (should be "plugin") — run "omd uninstall && omd install" to migrate`);
+      log(`  [WARN] ${basename}: legacy "plugins" field present (should be "plugin")`);
+    }
+    const pluginField = loaded.data["plugin"] ?? loaded.data["plugins"];
+    if (pluginField !== undefined && !Array.isArray(pluginField) && typeof pluginField !== "object" && typeof pluginField !== "string") {
+      issues.push(`${basename}: plugin field has invalid type — expected array, object, or string`);
       error(`[ISSUE] ${basename}: invalid plugin shape`);
     } else {
-      log(`  plugins field: valid`);
+      log("  plugin field: valid");
     }
   }
   log("Checking rule directory...");
-  const ruleBase = join5(homedir4(), ".local", "share", RULE_DIR_NAME);
+  const ruleBase = join4(homedir3(), ".local", "share", RULE_DIR_NAME);
   if (!ruleDirExists) {
     warnings.push(`Rule directory not found at ${ruleBase}`);
     log(`  ${ruleBase}: not found (plugin rules not installed — this is optional)`);
   } else {
     log(`  ${ruleBase}: exists`);
   }
-  const configDir = env.OPENCODE_CONFIG_DIR ?? join5(homedir4(), ".config", "opencode");
+  log("Checking OpenCode package cache...");
+  const cachePaths = resolveCachePaths(env, fs);
+  if (cachePaths.length === 0) {
+    info.push("No opencode-rules-md cache found under ~/.cache/opencode/packages/");
+    log("  no cache entries match opencode-rules-md*");
+  } else {
+    log(`  cache entries: ${cachePaths.join(", ")}`);
+  }
+  const configDir = env.OPENCODE_CONFIG_DIR ?? join4(homedir3(), ".config", "opencode");
   log("Checking config directory write access...");
-  const parentDir = dirname4(configDir);
+  const parentDir = dirname2(configDir);
   if (!fs.existsSync(parentDir)) {
     issues.push(`Config parent directory does not exist: ${parentDir}`);
     error(`[ISSUE] Config dir parent missing: ${parentDir}`);
@@ -719,17 +707,17 @@ Usage:
   omd [command] [options]
 
 Commands:
-  install   Register opencode-rules-md in both opencode.json and tui.json
-  uninstall Remove opencode-rules-md from both configs
-  status    Show installed plugin state for each config
-  doctor    Run health checks for the plugin environment
-  update    Check for new versions and purge stale cache
+  install    Register opencode-rules-md via OpenCode's plugin command
+  uninstall  Remove opencode-rules-md from both configs and cache
+  status     Show installed plugin state for each config
+  doctor     Run health checks for the plugin environment
+  update     Check for new versions and refresh the install via OpenCode
 
 Options:
   --dry-run    Show what would be changed without writing
   --version    Pin to a specific version (install only)
   --latest     Use the latest version (install only)
-  --purge      Also remove ~/.cache/opencode/node_modules/opencode-rules-md (uninstall only)
+  --purge      Also remove ~/.cache/opencode/packages/opencode-rules-md* (uninstall only)
   --yes        Accept all prompts automatically
 
 Examples:
@@ -803,12 +791,12 @@ var runMain = async (opts, argv) => {
       case "install": {
         const remaining = argv.slice(argv.indexOf("install") + 1 || argv.indexOf(resolvedCommand) + 1);
         const { values } = parseArgs({
-          argv: remaining,
+          args: remaining,
           allowPositionals: true,
           strict: false,
           options: {
             "dry-run": { type: "boolean", default: false },
-            version: { type: "string", default: undefined },
+            version: { type: "string", default: "" },
             latest: { type: "boolean", default: false },
             yes: { type: "boolean", default: false }
           }
@@ -817,29 +805,21 @@ var runMain = async (opts, argv) => {
           version: values["latest"] ? "latest" : String(values["version"] ?? ""),
           dryRun: Boolean(values["dry-run"]),
           yes: Boolean(values["yes"]),
-          latestVersion: opts.latestVersion
+          latestVersion: opts.latestVersion,
+          ...opts.spawn ? { spawn: opts.spawn } : {}
         };
         const result = await runInstall(installOpts, fs, env);
         if (result.status === "skipped") {
-          stdout("omd: already installed (no changes needed)");
+          stdout(`omd: install skipped (dry-run) — would run: opencode plugin ${result.specifier} --global`);
           return 0;
         }
-        for (const r of result.results) {
-          if (r.status === "wrote") {
-            stdout(`omd: registered in ${r.path}`);
-          } else if (r.status === "skipped") {
-            stdout(`omd: ${r.path} — already up to date`);
-          }
-        }
-        if (result.purged) {
-          stdout("omd: cache purged");
-        }
+        stdout(`omd: installed via opencode plugin ${result.specifier} --global`);
         return 0;
       }
       case "uninstall": {
         const remaining = argv.slice(argv.indexOf(resolvedCommand) + 1);
         const { values } = parseArgs({
-          argv: remaining,
+          args: remaining,
           allowPositionals: true,
           strict: false,
           options: {
@@ -871,7 +851,7 @@ var runMain = async (opts, argv) => {
         return 0;
       }
       case "status": {
-        await runStatus(fs, env, stdout);
+        await runStatus(fs, env, stdout, opts.latestVersion !== undefined ? { latestVersion: opts.latestVersion } : {});
         return 0;
       }
       case "doctor": {
@@ -881,7 +861,7 @@ var runMain = async (opts, argv) => {
       case "update": {
         const remaining = argv.slice(argv.indexOf(resolvedCommand) + 1);
         const { values } = parseArgs({
-          argv: remaining,
+          args: remaining,
           allowPositionals: true,
           strict: false,
           options: {
@@ -889,9 +869,20 @@ var runMain = async (opts, argv) => {
           }
         });
         const dryRun = Boolean(values["dry-run"]);
-        const updateResult = await runUpdate(fs, env, stdout, stderr, { dryRun, latestVersion: opts.latestVersion });
-        if (updateResult.status === "current") {
-          stdout("omd: already at latest version");
+        const updateResult = await runUpdate(fs, env, stdout, stderr, {
+          dryRun,
+          latestVersion: opts.latestVersion,
+          ...opts.spawn ? { spawn: opts.spawn } : {}
+        });
+        switch (updateResult.status) {
+          case "current":
+            stdout("omd: already at latest version");
+            break;
+          case "unreachable":
+            stderr("omd: could not reach npm registry — try again later");
+            return 1;
+          case "stale":
+            break;
         }
         return 0;
       }