opencode-rules-md 0.8.5 → 0.8.6

package/src/cli/update.ts

@@ -1,85 +1,183 @@
 // ---------------------------------------------------------------------------
 // src/cli/update.ts — `omd update` command implementation.
 //
-// Fetches latest from npm, compares to installed version, purges the
-// ~/.cache/opencode/node_modules/opencode-rules-md cache, and prints the
-// reinstall instruction when stale. No auto-reinstall.
+// Like install, update is now a thin wrapper around OpenCode's own CLI.
+// We compare the installed version (read from `data['plugin']` — singular —
+// with a backward-compat fallback to the legacy `data['plugins']`) against
+// the latest npm version. When stale we purge the on-disk cache under
+// ~/.cache/opencode/packages/ (the actual location OpenCode uses) and
+// invoke `opencode plugin opencode-rules-md --global --force` to refresh
+// the registration.
+//
+// The cache purge matters because OpenCode caches the resolved package
+// by specifier — once a cached copy exists, `--force` re-registers without
+// re-fetching unless we first remove the stale entry.
 // ---------------------------------------------------------------------------
 
 import { homedir } from 'os';
 import { join } from 'path';
 import { fetchLatestVersion, isStale } from './registry.js';
-import { loadGlobalConfig, matchesPlugin, normalizePlugin } from './config.js';
-import type { CliFs } from './config.js';
+import {
+  loadGlobalConfig,
+  matchesPlugin,
+  readInstalledPlugins,
+  type CliFs,
+  type LoadedConfig,
+} from './config.js';
+import { spawnOpencodePlugin } from './spawn.js';
+
+const CONFIG_BASENAMES = ['opencode', 'tui'] as const;
+
+/** Package directory used by OpenCode to cache plugin installs. */
+export const PACKAGES_DIR_BASENAME = ['.cache', 'opencode', 'packages'] as const;
+
+/** Exact cache directory name we look for (bare specifier, no version suffix). */
+export const CACHE_DIR_BASENAME = 'opencode-rules-md';
 
-// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * Resolve the user's home directory, honoring a custom HOME env var.
+ * Used by both resolveCachePaths and the config loader.
+ */
+export function resolveHome(env: NodeJS.ProcessEnv = process.env): string {
+  return env.HOME ?? homedir();
+}
 
-export const CACHE_PATH = join(
-  homedir(),
-  '.cache',
-  'opencode',
-  'node_modules',
-  'opencode-rules-md',
-);
+/**
+ * Return the absolute path of the OpenCode packages cache directory.
+ */
+export function resolvePackagesDir(env: NodeJS.ProcessEnv = process.env): string {
+  return join(resolveHome(env), ...PACKAGES_DIR_BASENAME);
+}
 
-// ─── Types ───────────────────────────────────────────────────────────────────
+/**
+ * Return the cache directories that match the opencode-rules-md prefix.
+ *
+ * Real-world layout under ~/.cache/opencode/packages/ looks like:
+ *   opencode-rules-md/
+ *   opencode-rules-md@latest/
+ *   some-other-plugin/
+ *
+ * We glob-match anything starting with `opencode-rules-md` (exact or with
+ * an `@<version>` suffix). When an injected fs is provided we list the
+ * directory and filter; without one we return the two most common shapes
+ * so callers can pre-check existence cheaply.
+ */
+export function resolveCachePaths(
+  env: NodeJS.ProcessEnv = process.env,
+  fs?: CliFs,
+): string[] {
+  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) => join(packagesDir, name));
+    } catch {
+      return [];
+    }
+  }
+  // No fs injection — return the conventional candidates. Callers that care
+  // about existence should still check with existsSync().
+  return [
+    join(packagesDir, CACHE_DIR_BASENAME),
+    join(packagesDir, `${CACHE_DIR_BASENAME}@latest`),
+  ];
+}
 
 export interface UpdateOptions {
+  /** Injected latest version (test seam). Defaults to a real npm lookup. */
   latestVersion?: string | null | undefined;
+  /** Print the plan without writing or spawning. */
   dryRun?: boolean;
+  /** Injected spawn function (test seam). Defaults to spawnOpencodePlugin. */
+  spawn?: typeof spawnOpencodePlugin;
 }
 
 export interface UpdateResult {
   status: 'stale' | 'current' | 'unreachable';
-  cachePath: string;
+  cachePaths: string[];
+  /** Re-install instruction; empty when status === 'current'. */
   instruction: string;
 }
 
-// ─── Cache path helpers ───────────────────────────────────────────────────────
+/**
+ * Look up the installed specifier across both config files, returning the
+ * first one we find. Returns null when neither file registers the plugin.
+ */
+function findInstalledSpecifier(loaded: readonly LoadedConfig[]): string | null {
+  for (const cfg of loaded) {
+    const plugins = readInstalledPlugins(cfg);
+    const match = plugins.find((p) => matchesPlugin(p));
+    if (match) return match;
+  }
+  return null;
+}
 
 /**
- * Resolve the local cache directory, honoring a custom HOME environment.
- * Falls back to os.homedir() when HOME is not set, matching the
- * resolveConfigDir fallback strategy.
+ * Extract the version portion of an `opencode-rules-md@<version>` specifier.
+ * Returns null when the specifier has no `@version` segment.
  */
-export function resolveCachePath(env: NodeJS.ProcessEnv = process.env): string {
-  return join(
-    env.HOME ?? homedir(),
-    '.cache',
-    'opencode',
-    'node_modules',
-    'opencode-rules-md',
-  );
+export function extractVersion(specifier: string): string | null {
+  const at = specifier.lastIndexOf('@');
+  if (at < 0 || at === specifier.length - 1) return null;
+  return specifier.slice(at + 1);
 }
 
 /**
- * Read the cached package.json version, if determinable.
- * Returns null when the cache is missing or unreadable.
+ * Recursively delete a directory and all its contents using the injected fs.
+ * Best-effort — a failed purge is not fatal; we want the update to keep going.
  */
-function readCacheVersion(fs: CliFs, cachePath: string): string | null {
-  const pkgPath = join(cachePath, 'package.json');
+export function purgeDirectory(fs: CliFs, dirPath: string): void {
+  let entries: string[] = [];
   try {
-    if (!fs.existsSync(pkgPath)) {
-      return null;
-    }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath)) as { version?: unknown };
-    return typeof pkg.version === 'string' ? pkg.version : null;
+    entries = fs.readdirSync(dirPath);
   } catch {
-    return null;
+    return;
   }
-}
 
-// ─── runUpdate ────────────────────────────────────────────────────────────────
+  for (const entry of entries) {
+    const entryPath = join(dirPath, entry);
+    try {
+      if (!fs.existsSync(entryPath)) continue;
+      // Probe to differentiate empty dirs / non-empty dirs / files. The injected
+      // fs interface does not expose stat, so we try readdir first and fall back
+      // to unlink for leaves.
+      try {
+        const subEntries = fs.readdirSync(entryPath);
+        if (subEntries.length === 0) {
+          fs.rmdirSync(entryPath);
+        } else {
+          purgeDirectory(fs, entryPath);
+          fs.rmdirSync(entryPath);
+        }
+      } catch {
+        // Not a directory (or unreadable) — best-effort unlink.
+        fs.unlinkSync(entryPath);
+      }
+    } catch {
+      // best-effort per entry
+    }
+  }
 
-const CONFIG_BASENAMES = ['opencode', 'tui'] as const;
+  try {
+    fs.rmdirSync(dirPath);
+  } catch {
+    // best-effort
+  }
+}
 
 /**
- * Run the update command:
- * 1. Fetch latest version from npm (or use provided mock)
- * 2. Compare to installed version in config
- * 3. If stale: purge cache, print reinstall instruction
- * 4. If current: print "already current"
- * 5. If unreachable: noop
+ * Run the update command.
+ *
+ * 1. Resolve the latest published version from npm (or use the injected mock).
+ * 2. Read the installed version from the user's opencode config.
+ * 3. If unreachable, log and return.
+ * 4. If current, log and return.
+ * 5. Otherwise: purge stale cache directories, then spawn
+ *    `opencode plugin opencode-rules-md --global --force`.
  */
 export const runUpdate = async (
   fs: CliFs,
@@ -88,133 +186,69 @@ export const runUpdate = async (
   _error: (s: string) => void,
   opts: UpdateOptions = {},
 ): Promise<UpdateResult> => {
-  // Use provided latestVersion for testing, otherwise fetch from npm
-  const latest = opts.latestVersion !== undefined
-    ? opts.latestVersion
-    : await fetchLatestVersion();
+  // 1. Resolve latest.
+  const latest = opts.latestVersion !== undefined ? opts.latestVersion : await fetchLatestVersion();
 
-  const cachePath = resolveCachePath(env);
+  const cachePaths = resolveCachePaths(env, fs);
+  const instruction = 'opencode plugin opencode-rules-md --global --force';
+  const spawnFn = opts.spawn ?? spawnOpencodePlugin;
 
+  // 2. Unreachable.
   if (latest === null) {
     log('omd: could not determine latest version from npm registry');
-    return {
-      status: 'unreachable',
-      cachePath,
-      instruction: 'npx opencode-rules-md@latest install',
-    };
+    return { status: 'unreachable', cachePaths, instruction };
   }
 
-  // Determine installed version from config (check both configs)
-  let installedVersion: string | null = null;
-  for (const basename of CONFIG_BASENAMES) {
-    const loaded = loadGlobalConfig(fs, env, basename);
-    const plugins = normalizePlugin(loaded.data['plugins']);
-    const match = plugins.find(p => matchesPlugin(p));
-    if (match) {
-      // Extract version from specifier (e.g. 'opencode-rules-md@2.0.0' -> '2.0.0')
-      const atIndex = match.lastIndexOf('@');
-      installedVersion = atIndex >= 0 ? match.slice(atIndex + 1) : null;
-      break; // use first config that has it
-    }
-  }
+  // 3. Installed version (read both configs).
+  const configs = CONFIG_BASENAMES.map((basename) => loadGlobalConfig(fs, env, basename));
+  const installedSpecifier = findInstalledSpecifier(configs);
+  const installedVersion = installedSpecifier ? extractVersion(installedSpecifier) : null;
 
-  const instruction = `npx opencode-rules-md@latest install`;
-
-  // Check staleness: only stale if installed version differs from latest
+  // 4. Current.
   if (installedVersion !== null && !isStale(installedVersion, latest)) {
     log(`omd: opencode-rules-md@${installedVersion} is already the latest`);
-    return {
-      status: 'current',
-      cachePath,
-      instruction,
-    };
+    return { status: 'current', cachePaths, instruction: '' };
   }
 
-  // Before purging, decide whether the cache is actually stale. When the cache
-  // version is already equal to the latest resolved version, skip the purge
-  // so we do not delete a valid cache. If the version cannot be determined,
-  // fall back to purging to be safe.
-  const cacheVersion = readCacheVersion(fs, cachePath);
-  const shouldPurge = cacheVersion === null || cacheVersion !== latest;
-
+  // 5. Stale — describe plan.
   if (opts.dryRun) {
-    log(`omd: update check (dry-run)`);
+    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 purge: ${cachePaths.join(', ') || '(none found)'}`);
     log(`  would instruct: ${instruction}`);
-    return {
-      status: 'stale',
-      cachePath,
-      instruction,
-    };
+    return { status: 'stale', cachePaths, instruction };
   }
 
-  // Purge the cache directory using the injected fs (allows test faking)
-  if (shouldPurge) {
+  log(
+    installedVersion === null
+      ? `omd: opencode-rules-md is not installed; registering latest (${latest})`
+      : `omd: opencode-rules-md is stale (installed ${installedVersion}, latest ${latest})`,
+  );
+
+  // Purge each matching cache directory. Best-effort per path.
+  for (const cachePath of cachePaths) {
     try {
       if (fs.existsSync(cachePath)) {
-        // Recursively remove contents then the dir itself
         purgeDirectory(fs, cachePath);
+        log(`omd: purged cache ${cachePath}`);
       }
     } catch {
-      // best-effort — purge failure is non-fatal
+      // ignore individual purge failures
     }
   }
 
-  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,
-  };
-};
-
-// ─── purgeDirectory ────────────────────────────────────────────────────────────
-
-/**
- * Recursively delete a directory and all its contents using the given fs.
- */
-export function purgeDirectory(fs: CliFs, dirPath: string): void {
-  let entries: string[] = [];
-  try {
-    entries = fs.readdirSync(dirPath);
-  } catch {
-    return;
-  }
+  // Re-register via OpenCode's CLI. Failure here is fatal — surface it.
+  const result = await spawnFn(['opencode-rules-md', '--global', '--force'], {
+    env: process.env,
+    stdio: 'inherit',
+  });
 
-  for (const entry of entries) {
-    const entryPath = join(dirPath, entry);
-    try {
-      if (fs.existsSync(entryPath)) {
-        // Check if it's a directory by trying to read it
-        try {
-          const subEntries = fs.readdirSync(entryPath);
-          if (subEntries.length === 0) {
-            // Empty directory
-            fs.rmdirSync(entryPath);
-          } else {
-            // Non-empty directory — recurse
-            purgeDirectory(fs, entryPath);
-            fs.rmdirSync(entryPath);
-          }
-        } catch {
-          // It's a file — unlink it
-          fs.unlinkSync(entryPath);
-        }
-      }
-    } catch {
-      // best-effort per entry
-    }
+  if ((result.status ?? 0) !== 0) {
+    throw new Error(
+      `opencode plugin opencode-rules-md --global --force exited with status ${String(result.status)}`,
+    );
   }
 
-  try {
-    fs.rmdirSync(dirPath);
-  } catch {
-    // best-effort
-  }
-}
+  return { status: 'stale', cachePaths, instruction: '' };
+};