opencode-rules-md 0.8.4 → 0.8.5

package/dist/cli.mjs

@@ -0,0 +1,915 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+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/config.ts
+import { join, dirname } from "path";
+import { homedir } from "os";
+var PLUGIN_NAME = "opencode-rules-md";
+var BACKUP_LIMIT = 3;
+var OPENCODE_CONFIG_SUBDIR = "opencode";
+function parseJsonc(content) {
+  if (content.trim() === "") {
+    return {};
+  }
+  let out = "";
+  let i = 0;
+  let depth = 0;
+  while (i < content.length) {
+    const ch = content[i];
+    if (ch === "/" && content[i + 1] === "/" && !isInsideString(out)) {
+      let j = i + 2;
+      while (j < content.length && content[j] !== `
+`) {
+        j++;
+      }
+      out += " ";
+      if (j < content.length && content[j] === `
+`) {
+        i = j;
+        continue;
+      }
+      if (j >= content.length) {
+        const last = content[content.length - 1];
+        if (last === "}" || last === "]") {
+          out += last;
+        }
+        i = j;
+      } else {
+        i = j - 1;
+      }
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*" && !isInsideString(out)) {
+      let j = i + 2;
+      while (j < content.length - 1) {
+        if (content[j] === "*" && content[j + 1] === "/") {
+          j += 2;
+          break;
+        }
+        j++;
+      }
+      out += " ";
+      i = j;
+      continue;
+    }
+    if (!isInsideString(out)) {
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth = Math.max(0, depth - 1);
+      else if (ch === "[")
+        depth++;
+      else if (ch === "]")
+        depth = Math.max(0, depth - 1);
+    }
+    out += ch;
+    i++;
+  }
+  let s = out.replace(/,(\s*[}\]])/g, "$1");
+  if (depth > 0 && !/[}\]]/.test(s)) {
+    s = s.replace(/,(\s*$)/, "") + "}";
+    depth = 0;
+  }
+  if (s.trim() === "") {
+    return {};
+  }
+  try {
+    return JSON.parse(s);
+  } catch (err) {
+    const msg = err.message;
+    throw new Error("parseJsonc: invalid JSON after stripping comments - " + msg);
+  }
+}
+function isInsideString(s) {
+  let inStr = false;
+  let strChar = "";
+  for (let i = 0;i < s.length; i++) {
+    const ch = s[i];
+    if (!inStr && (ch === '"' || ch === "'")) {
+      inStr = true;
+      strChar = ch;
+    } else if (inStr && ch === "\\") {
+      i++;
+    } else if (inStr && ch === strChar) {
+      inStr = false;
+      strChar = "";
+    }
+  }
+  return inStr;
+}
+function resolveConfigDir(env) {
+  const custom = env.OPENCODE_CONFIG_DIR;
+  if (custom && custom.trim() !== "") {
+    return custom;
+  }
+  const xdg = env.XDG_CONFIG_HOME;
+  if (xdg && xdg.trim() !== "") {
+    return join(xdg, OPENCODE_CONFIG_SUBDIR);
+  }
+  const home = env.HOME;
+  if (home && home.trim() !== "") {
+    return join(home, ".config", OPENCODE_CONFIG_SUBDIR);
+  }
+  return join(homedir(), ".config", OPENCODE_CONFIG_SUBDIR);
+}
+function resolveConfigPath(fs, env, basename = "opencode") {
+  const dir = resolveConfigDir(env);
+  const jsonPath = join(dir, basename + ".json");
+  const jsoncPath = join(dir, basename + ".jsonc");
+  if (fs.existsSync(jsonPath)) {
+    return { path: jsonPath, exists: true };
+  }
+  if (fs.existsSync(jsoncPath)) {
+    return { path: jsoncPath, exists: true };
+  }
+  return { path: jsonPath, exists: false };
+}
+function normalizePlugin(raw) {
+  if (raw == null) {
+    return [];
+  }
+  if (Array.isArray(raw)) {
+    return raw.filter((v) => typeof v === "string");
+  }
+  if (typeof raw === "object") {
+    const obj = raw;
+    return Object.keys(obj).filter((k) => obj[k] != null && obj[k] !== false);
+  }
+  if (typeof raw === "string") {
+    return [raw];
+  }
+  return [];
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesPlugin(entry, name = PLUGIN_NAME) {
+  if (!entry || typeof entry !== "string")
+    return false;
+  if (entry === name)
+    return true;
+  const pattern = new RegExp("^" + escapeRegex(name) + "@");
+  return pattern.test(entry);
+}
+function loadGlobalConfig(fs, env, basename = "opencode") {
+  const resolved = resolveConfigPath(fs, env, basename);
+  if (!resolved.exists) {
+    return { path: resolved.path, exists: false, data: {} };
+  }
+  const raw = fs.readFileSync(resolved.path);
+  try {
+    const data = parseJsonc(raw);
+    return { path: resolved.path, exists: true, data };
+  } catch (err) {
+    throw new Error(`config file at ${resolved.path} is malformed JSON
+` + `Fix the JSON error, or delete the file and re-run.
+` + `  error: ${err.message}`);
+  }
+}
+function timestamp() {
+  const now = new Date;
+  const y = now.getUTCFullYear();
+  const m = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(now.getUTCDate()).padStart(2, "0");
+  const hh = String(now.getUTCHours()).padStart(2, "0");
+  const mm = String(now.getUTCMinutes()).padStart(2, "0");
+  const ss = String(now.getUTCSeconds()).padStart(2, "0");
+  return "" + y + m + d + "T" + hh + mm + ss;
+}
+function backupIfWritable(fs, path) {
+  if (!fs.existsSync(path)) {
+    return;
+  }
+  try {
+    const content = fs.readFileSync(path);
+    const dir = dirname(path);
+    const segs = path.replace(/\\/g, "/").split("/");
+    const base = segs[segs.length - 1] ?? path;
+    const dot = base.lastIndexOf(".");
+    const name = dot >= 0 ? base.slice(0, dot) : base;
+    const backupPath = join(dir, name + ".bak." + timestamp());
+    fs.writeFileSync(backupPath, content);
+    return backupPath;
+  } catch {
+    return;
+  }
+}
+function rotateBackups(fs, dir, basename, limit = BACKUP_LIMIT) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  const prefix = basename + ".bak.";
+  const backups = entries.filter((e) => e.startsWith(prefix)).map((e) => ({ name: e, path: join(dir, e) })).filter(({ path }) => fs.existsSync(path)).sort((a, b) => a.name.localeCompare(b.name));
+  if (backups.length <= limit) {
+    return;
+  }
+  const toDelete = backups.slice(0, backups.length - limit);
+  for (const { path } of toDelete) {
+    try {
+      fs.unlinkSync(path);
+    } catch {}
+  }
+}
+function writeAtomically(fs, path, content) {
+  const dir = dirname(path);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {}
+  const segs = path.replace(/\\/g, "/").split("/");
+  const base = segs[segs.length - 1] ?? path;
+  const dot = base.lastIndexOf(".");
+  const name = dot >= 0 ? base.slice(0, dot) : base;
+  const ext = dot >= 0 ? base.slice(dot) : "";
+  const tmpPath = join(dir, ".tmp." + name + ext);
+  let tempCreated = false;
+  try {
+    fs.writeFileSync(tmpPath, content);
+    tempCreated = true;
+    fs.renameSync(tmpPath, path);
+  } catch (err) {
+    if (tempCreated) {
+      try {
+        fs.unlinkSync(tmpPath);
+      } catch {}
+    }
+    throw err;
+  }
+}
+
+// src/cli/registry.ts
+var REGISTRY_URL = "https://registry.npmjs.org/opencode-rules-md/latest";
+var fetchLatestVersion = async () => {
+  try {
+    const res = await fetch(REGISTRY_URL);
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+};
+var isStale = (installed, latest) => {
+  if (!installed || !latest)
+    return false;
+  return 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");
+}
+function readCacheVersion(fs, cachePath) {
+  const pkgPath = join2(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;
+  }
+}
+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"]);
+    const match = plugins.find((p) => matchesPlugin(p));
+    if (match) {
+      const atIndex = match.lastIndexOf("@");
+      installedVersion = atIndex >= 0 ? match.slice(atIndex + 1) : null;
+      break;
+    }
+  }
+  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
+  };
+};
+function purgeDirectory(fs, dirPath) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dirPath);
+  } catch {
+    return;
+  }
+  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);
+        }
+      }
+    } catch {}
+  }
+  try {
+    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;
+  }
+  const cachePath = resolveCachePath(env);
+  if (!fs.existsSync(cachePath)) {
+    return false;
+  }
+  const cacheVersion = readCacheVersion2(fs, cachePath);
+  if (cacheVersion === null || cacheVersion !== resolvedVersion) {
+    purgeDirectory(fs, cachePath);
+    return true;
+  }
+  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);
+      }
+    }
+    writeAtomically(fs, loaded.path, newContent);
+    results.push({
+      path: loaded.path,
+      status: "wrote",
+      backup: backup ?? null
+    });
+  }
+  let purged = false;
+  if (!opts.dryRun) {
+    purged = purgeCacheIfStale(fs, env, resolvedVersion);
+  }
+  return {
+    status: anyProcessed ? "wrote" : "skipped",
+    results,
+    purged
+  };
+};
+
+// 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 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)) {
+      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);
+        }
+        purged = true;
+      } catch {}
+    }
+  }
+  for (const basename of CONFIG_BASENAMES3) {
+    const loaded = loadGlobalConfig(fs, env, basename);
+    const plugins = normalizePlugin(loaded.data["plugins"]);
+    const remaining = plugins.filter((p) => !matchesPlugin(p));
+    if (remaining.length === plugins.length) {
+      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) + `
+`;
+    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);
+      }
+    }
+    writeAtomically(fs, loaded.path, newContent);
+    results.push({
+      path: loaded.path,
+      status: "wrote",
+      backup: backup ?? null
+    });
+  }
+  return {
+    status: anyProcessed || purged ? "wrote" : "skipped",
+    results,
+    purged
+  };
+};
+
+// src/cli/status.ts
+import { join as join5, dirname as dirname4 } from "path";
+import { homedir as homedir4 } from "os";
+import { extname } from "path";
+var RULE_DIR_NAME = "opencode-rules-md";
+var MIN_NODE_VERSION = 20;
+var CONFIG_BASENAMES4 = ["opencode", "tui"];
+var runStatus = async (fs, env, log) => {
+  const configs = [];
+  const latest = await fetchLatestVersion();
+  for (const basename of CONFIG_BASENAMES4) {
+    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 entry = {
+      basename,
+      path: loaded.path,
+      format,
+      installed: match ?? null,
+      notInstalled: !loaded.exists ? true : match === undefined || match === null,
+      otherPlugins: plugins.filter((p) => !matchesPlugin(p)),
+      latest,
+      isLatest: match !== undefined && latest !== null ? match === `opencode-rules-md@${latest}` : null
+    };
+    configs.push(entry);
+    if (!loaded.exists) {
+      log(`omd: ${basename}.json — config not found at ${loaded.path}`);
+      continue;
+    }
+    log(`omd: ${basename}${format} — ${loaded.path}`);
+    if (match) {
+      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`);
+    }
+    if (entry.otherPlugins.length > 0) {
+      log(`  other plugins: ${entry.otherPlugins.join(", ")}`);
+    }
+  }
+  return { configs };
+};
+var runDoctor = async (fs, env, log, error, opts = {}) => {
+  const issues = [];
+  const warnings = [];
+  const info = [];
+  const nodeVersion = opts.nodeVersion ?? process.version.slice(1);
+  const ruleDirExists = opts.ruleDirExists ?? true;
+  let hasBun = opts.hasBun;
+  if (hasBun === undefined) {
+    const pathEnv = (env.PATH ?? "").split(":");
+    hasBun = pathEnv.some((p) => {
+      try {
+        const { existsSync } = __require("node:fs");
+        return existsSync(p + "/bun");
+      } catch {
+        return false;
+      }
+    });
+  }
+  log("Checking Node version...");
+  const nodeMajor = parseInt(nodeVersion.split(".")[0] ?? "0", 10);
+  if (nodeMajor < MIN_NODE_VERSION) {
+    issues.push(`Node.js ${nodeVersion} is too old; requires Node >= ${MIN_NODE_VERSION}`);
+    error(`[ISSUE] Node.js ${nodeVersion} — requires >= ${MIN_NODE_VERSION}. Download latest from https://nodejs.org`);
+  } else {
+    log(`  Node.js ${nodeVersion} — OK`);
+  }
+  log("Checking for Bun...");
+  if (!hasBun) {
+    issues.push("Bun is not on PATH — install from https://bun.sh");
+    error("[ISSUE] Bun not found on PATH — install Bun for best performance");
+  } else {
+    log("  Bun — found on PATH");
+  }
+  for (const basename of CONFIG_BASENAMES4) {
+    log(`Checking ${basename} config...`);
+    const loaded = loadGlobalConfig(fs, env, basename);
+    if (!loaded.exists) {
+      warnings.push(`${basename} config not found at ${loaded.path}`);
+      log(`  ${basename}: not found (will be created on first install)`);
+      continue;
+    }
+    log(`  ${basename}${extname(loaded.path)}: ${loaded.path}`);
+    const plugins = normalizePlugin(loaded.data["plugins"]);
+    const match = plugins.find((p) => matchesPlugin(p));
+    if (match) {
+      info.push(`${basename}: opencode-rules-md@${match ?? "unknown"} installed`);
+      log(`  opencode-rules-md: ${match}`);
+    } else {
+      warnings.push(`${basename}: plugin 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`);
+      error(`[ISSUE] ${basename}: invalid plugin shape`);
+    } else {
+      log(`  plugins field: valid`);
+    }
+  }
+  log("Checking rule directory...");
+  const ruleBase = join5(homedir4(), ".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 config directory write access...");
+  const parentDir = dirname4(configDir);
+  if (!fs.existsSync(parentDir)) {
+    issues.push(`Config parent directory does not exist: ${parentDir}`);
+    error(`[ISSUE] Config dir parent missing: ${parentDir}`);
+  } else {
+    log(`  ${parentDir}: writable`);
+  }
+  log("");
+  if (issues.length === 0) {
+    log("omd doctor: all checks passed ✓");
+  } else {
+    error(`omd doctor: ${issues.length} issue(s) found — fix before using the plugin`);
+    error(`Run 'omd --help' for usage information`);
+  }
+  return {
+    ok: issues.length === 0,
+    issues,
+    warnings,
+    info
+  };
+};
+
+// src/cli/real-fs.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmdirSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+var createRealFs = () => ({
+  readFileSync: (path) => readFileSync(path, "utf8"),
+  writeFileSync: (path, content) => {
+    writeFileSync(path, content);
+  },
+  renameSync: (from, to) => {
+    renameSync(from, to);
+  },
+  copyFileSync: (from, to) => {
+    copyFileSync(from, to);
+  },
+  unlinkSync: (path) => {
+    unlinkSync(path);
+  },
+  mkdirSync: (path, opts) => {
+    mkdirSync(path, opts);
+  },
+  readdirSync: (path) => readdirSync(path),
+  existsSync: (path) => existsSync(path),
+  rmdirSync: (path) => {
+    rmdirSync(path);
+  }
+});
+
+// src/cli/main.ts
+var USAGE = `omd — opencode-rules-md plugin manager
+
+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
+
+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)
+  --yes        Accept all prompts automatically
+
+Examples:
+  omd               # install with defaults (latest)
+  omd install        # same as bare omd
+  omd install --dry-run
+  omd install --version 2.0.0
+  omd uninstall --purge
+`.trim();
+var printUsage = (stdout) => {
+  stdout(USAGE);
+};
+var KNOWN_FLAGS = new Set([
+  "--help",
+  "--dry-run",
+  "--latest",
+  "--purge",
+  "--yes",
+  "--version",
+  "-h",
+  "-V"
+]);
+var SHORT_OPTIONS_WITH_VALUE = new Set(["v"]);
+var LONG_OPTIONS_WITH_VALUE = new Set(["version"]);
+function extractCommand(argv) {
+  const unknownFlags = [];
+  let command = null;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      break;
+    }
+    if (!arg.startsWith("-")) {
+      if (command === null) {
+        command = arg;
+      }
+      continue;
+    }
+    if (!KNOWN_FLAGS.has(arg)) {
+      unknownFlags.push(arg);
+    }
+    const flagName = arg.startsWith("--") ? arg.slice(2) : arg.startsWith("-") ? arg.slice(1) : "";
+    if (LONG_OPTIONS_WITH_VALUE.has(flagName) || SHORT_OPTIONS_WITH_VALUE.has(flagName)) {
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        i++;
+      }
+    }
+  }
+  return { command, unknownFlags };
+}
+var runMain = async (opts, argv) => {
+  const {
+    fs = createRealFs(),
+    env = process.env,
+    stdout = (s) => console.log(s),
+    stderr = (s) => console.error(s)
+  } = opts;
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage(stdout);
+    return 0;
+  }
+  const { command, unknownFlags } = extractCommand(argv);
+  if (unknownFlags.length > 0) {
+    stderr(`omd: unknown option ${unknownFlags[0]}`);
+    stderr("Run 'omd --help' for usage.");
+    return 2;
+  }
+  const resolvedCommand = command ?? "install";
+  try {
+    switch (resolvedCommand) {
+      case "install": {
+        const remaining = argv.slice(argv.indexOf("install") + 1 || argv.indexOf(resolvedCommand) + 1);
+        const { values } = parseArgs({
+          argv: remaining,
+          allowPositionals: true,
+          strict: false,
+          options: {
+            "dry-run": { type: "boolean", default: false },
+            version: { type: "string", default: undefined },
+            latest: { type: "boolean", default: false },
+            yes: { type: "boolean", default: false }
+          }
+        });
+        const installOpts = {
+          version: values["latest"] ? "latest" : String(values["version"] ?? ""),
+          dryRun: Boolean(values["dry-run"]),
+          yes: Boolean(values["yes"]),
+          latestVersion: opts.latestVersion
+        };
+        const result = await runInstall(installOpts, fs, env);
+        if (result.status === "skipped") {
+          stdout("omd: already installed (no changes needed)");
+          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");
+        }
+        return 0;
+      }
+      case "uninstall": {
+        const remaining = argv.slice(argv.indexOf(resolvedCommand) + 1);
+        const { values } = parseArgs({
+          argv: remaining,
+          allowPositionals: true,
+          strict: false,
+          options: {
+            "dry-run": { type: "boolean", default: false },
+            purge: { type: "boolean", default: false },
+            yes: { type: "boolean", default: false }
+          }
+        });
+        const uninstallOpts = {
+          purge: Boolean(values["purge"]),
+          dryRun: Boolean(values["dry-run"]),
+          yes: Boolean(values["yes"])
+        };
+        const result = runUninstall(uninstallOpts, fs, env);
+        if (result.status === "skipped") {
+          stdout("omd: not installed (no changes needed)");
+          return 0;
+        }
+        for (const r of result.results) {
+          if (r.status === "wrote") {
+            stdout(`omd: removed from ${r.path}`);
+          } else if (r.status === "skipped") {
+            stdout(`omd: ${r.path} — not present`);
+          }
+        }
+        if (result.purged) {
+          stdout("omd: cache purged");
+        }
+        return 0;
+      }
+      case "status": {
+        await runStatus(fs, env, stdout);
+        return 0;
+      }
+      case "doctor": {
+        const docResult = await runDoctor(fs, env, stdout, stderr);
+        return docResult.ok ? 0 : 1;
+      }
+      case "update": {
+        const remaining = argv.slice(argv.indexOf(resolvedCommand) + 1);
+        const { values } = parseArgs({
+          argv: remaining,
+          allowPositionals: true,
+          strict: false,
+          options: {
+            "dry-run": { type: "boolean", default: false }
+          }
+        });
+        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");
+        }
+        return 0;
+      }
+      default:
+        stderr(`omd: unknown command '${resolvedCommand}'`);
+        stderr("Run 'omd --help' for usage.");
+        return 2;
+    }
+  } catch (err) {
+    stderr(`omd: ${err.message}`);
+    return 1;
+  }
+};
+var isMainModule = import.meta.url === `file://${process.argv[1]?.replace(/\\/g, "/")}`;
+if (isMainModule) {
+  const exitCode = await runMain({}, process.argv.slice(2));
+  process.exit(exitCode);
+}
+export {
+  runMain
+};