opencode-rules-md 0.8.4 → 0.8.6

package/dist/cli.mjs

@@ -0,0 +1,906 @@
+#!/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/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";
+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 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, "\\$&");
+}
+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/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 () => {
+  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
+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 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 [];
+    }
+  }
+  return [
+    join2(packagesDir, CACHE_DIR_BASENAME),
+    join2(packagesDir, `${CACHE_DIR_BASENAME}@latest`)
+  ];
+}
+function findInstalledSpecifier(loaded) {
+  for (const cfg of loaded) {
+    const plugins = readInstalledPlugins(cfg);
+    const match = plugins.find((p) => matchesPlugin(p));
+    if (match)
+      return match;
+  }
+  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 {
+    entries = fs.readdirSync(dirPath);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = join2(dirPath, entry);
+    try {
+      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 {}
+  }
+  try {
+    fs.rmdirSync(dirPath);
+  } catch {}
+}
+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 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: "" };
+  }
+  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 };
+  }
+  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}`);
+      }
+    } catch {}
+  }
+  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: "stale", cachePaths, instruction: "" };
+};
+
+// src/cli/uninstall.ts
+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 cachePaths = resolveCachePaths(env, fs);
+    for (const cachePath of cachePaths) {
+      try {
+        if (fs.existsSync(cachePath)) {
+          purgeDirectory(fs, cachePath);
+          purged = true;
+        }
+      } catch {}
+    }
+  }
+  for (const basename of CONFIG_BASENAMES2) {
+    const loaded = loadGlobalConfig(fs, env, basename);
+    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 newContent = JSON.stringify(next, null, 2) + `
+`;
+    if (opts.dryRun) {
+      results.push({ path: loaded.path, status: "wrote", backup: null });
+      continue;
+    }
+    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({
+      path: loaded.path,
+      status: "wrote",
+      backup: backup ?? null
+    });
+  }
+  return {
+    status: anyProcessed || purged ? "wrote" : "skipped",
+    results,
+    purged
+  };
+};
+
+// src/cli/status.ts
+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_BASENAMES3 = ["opencode", "tui"];
+var runStatus = async (fs, env, log, opts = {}) => {
+  const configs = [];
+  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 = readInstalledPlugins(loaded);
+    const match = plugins.find((p) => matchesPlugin(p)) ?? null;
+    const entry = {
+      basename,
+      path: loaded.path,
+      format,
+      installed: match,
+      notInstalled: !loaded.exists || match === null,
+      otherPlugins: plugins.filter((p) => !matchesPlugin(p)),
+      latest,
+      isLatest: match !== null && 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_BASENAMES3) {
+    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 = readInstalledPlugins(loaded);
+    const match = plugins.find((p) => matchesPlugin(p)) ?? null;
+    if (match) {
+      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");
+    }
+    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("  plugin field: valid");
+    }
+  }
+  log("Checking rule directory...");
+  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`);
+  }
+  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 = dirname2(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 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/packages/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({
+          args: remaining,
+          allowPositionals: true,
+          strict: false,
+          options: {
+            "dry-run": { type: "boolean", default: false },
+            version: { type: "string", default: "" },
+            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,
+          ...opts.spawn ? { spawn: opts.spawn } : {}
+        };
+        const result = await runInstall(installOpts, fs, env);
+        if (result.status === "skipped") {
+          stdout(`omd: install skipped (dry-run) — would run: opencode plugin ${result.specifier} --global`);
+          return 0;
+        }
+        stdout(`omd: installed via opencode plugin ${result.specifier} --global`);
+        return 0;
+      }
+      case "uninstall": {
+        const remaining = argv.slice(argv.indexOf(resolvedCommand) + 1);
+        const { values } = parseArgs({
+          args: 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, opts.latestVersion !== undefined ? { latestVersion: opts.latestVersion } : {});
+        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({
+          args: 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,
+          ...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;
+      }
+      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
+};