opencode-rules-md 0.6.5

package/dist/cli.mjs

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { parseArgs } from "node:util";
+
+// src/cli/config.ts
+import * as os from "node:os";
+import * as path from "node:path";
+function stripJsoncComments(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    const char = content[i];
+    if (char === '"') {
+      result += char;
+      i++;
+      while (i < content.length) {
+        const c = content[i];
+        if (c === "\\" && i + 1 < content.length) {
+          result += c + content[i + 1];
+          i += 2;
+          continue;
+        }
+        if (c === '"') {
+          result += c;
+          i++;
+          break;
+        }
+        result += c;
+        i++;
+      }
+      continue;
+    }
+    if (char === "/" && content[i + 1] === "/") {
+      while (i < content.length && content[i] !== `
+`) {
+        i++;
+      }
+      continue;
+    }
+    if (char === "/" && content[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < content.length && !(content[i] === "*" && content[i + 1] === "/")) {
+        i++;
+      }
+      if (i + 1 < content.length) {
+        i += 2;
+      }
+      continue;
+    }
+    if (char === "," && (content[i + 1] === "}" || content[i + 1] === "]")) {
+      i++;
+      continue;
+    }
+    result += char;
+    i++;
+  }
+  return result;
+}
+function resolveGlobalConfigPath(fs, opts = {}) {
+  const dir = resolveConfigDir();
+  if (opts.ensureDir && !fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return path.join(dir, "opencode.json");
+}
+function resolveConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return process.env.OPENCODE_CONFIG_DIR;
+  }
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, "opencode");
+  }
+  const home = process.env.HOME || os.homedir();
+  if (home) {
+    return path.join(home, ".config", "opencode");
+  }
+  const appdata = process.env.APPDATA;
+  if (appdata) {
+    return path.join(appdata, "opencode");
+  }
+  throw new Error("Cannot resolve config dir: none of OPENCODE_CONFIG_DIR, XDG_CONFIG_HOME, HOME, or APPDATA is set");
+}
+function loadGlobalConfig(fs) {
+  const configPath = resolveGlobalConfigPath(fs);
+  if (!fs.existsSync(configPath)) {
+    return { path: configPath, existed: false, config: {} };
+  }
+  try {
+    const raw = fs.readFileSync(configPath);
+    const stripped = stripJsoncComments(raw);
+    if (stripped.trim() === "") {
+      return { path: configPath, existed: true, config: {} };
+    }
+    const parsed = JSON.parse(stripped);
+    return { path: configPath, existed: true, config: parsed };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    return { path: configPath, existed: true, config: {}, parseError: error };
+  }
+}
+function normalizePlugin(config) {
+  const raw = Array.isArray(config["plugin"]) ? config["plugin"] : [];
+  const seen = new Map;
+  const result = [];
+  for (const item of raw) {
+    if (typeof item !== "string")
+      continue;
+    const prefix = getPluginPrefix(item);
+    seen.set(prefix, result.length);
+    result.push(item);
+  }
+  return collapseByPrefix(result, seen);
+}
+function removePlugin(config, prefix) {
+  if (!Array.isArray(config["plugin"]))
+    return;
+  const raw = config["plugin"];
+  config["plugin"] = raw.filter((item) => typeof item === "string" && !item.startsWith(prefix));
+}
+function addPlugin(config, specifier) {
+  if (!Array.isArray(config["plugin"])) {
+    config["plugin"] = [];
+  }
+  const plugin = config["plugin"];
+  const prefix = getPluginPrefix(specifier);
+  const removed = plugin.filter((p) => getPluginPrefix(p) !== prefix);
+  removed.push(specifier);
+  config["plugin"] = removed;
+}
+function rotateBackups(fs, configPath, _pluginName) {
+  const dir = path.dirname(configPath);
+  const base = path.basename(configPath);
+  const timestamp = Date.now();
+  const newBak = path.join(dir, `${base}.bak.${timestamp}`);
+  if (fs.existsSync(configPath)) {
+    fs.copyFileSync(configPath, newBak);
+  } else {
+    fs.writeFileSync(newBak, "", "utf-8");
+  }
+  const entries = fs.readdirSync(dir);
+  const bakFiles = entries.filter((e) => e.startsWith(base + ".bak.")).sort();
+  while (bakFiles.length > 3) {
+    const oldest = bakFiles.shift();
+    fs.unlinkSync(path.join(dir, oldest));
+  }
+  return newBak;
+}
+function writeAtomically(fs, configPath, content) {
+  const dir = path.dirname(configPath);
+  const base = path.basename(configPath);
+  const tmpPath = path.join(dir, `.${base}.tmp.${Date.now()}`);
+  fs.writeFileSync(tmpPath, content, "utf-8");
+  fs.renameSync(tmpPath, configPath);
+}
+function getPluginPrefix(specifier) {
+  const atIdx = specifier.indexOf("@");
+  return atIdx === -1 ? specifier : specifier.substring(0, atIdx);
+}
+function collapseByPrefix(plugins, lastSeen) {
+  const keptIndices = new Set([...lastSeen.values()]);
+  return plugins.filter((_, idx) => keptIndices.has(idx));
+}
+
+// src/cli/real-fs.ts
+import * as fs from "node:fs";
+import * as nodePath from "node:path";
+var realFs = {
+  readFileSync(filePath) {
+    return fs.readFileSync(filePath, "utf-8");
+  },
+  writeFileSync(filePath, content, _encoding) {
+    const dir = nodePath.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+  },
+  renameSync(from, to) {
+    fs.renameSync(from, to);
+  },
+  copyFileSync(from, to) {
+    fs.copyFileSync(from, to);
+  },
+  unlinkSync(filePath) {
+    fs.unlinkSync(filePath);
+  },
+  mkdirSync(filePath, opts) {
+    fs.mkdirSync(filePath, opts);
+  },
+  readdirSync(filePath) {
+    return fs.readdirSync(filePath);
+  },
+  existsSync(filePath) {
+    return fs.existsSync(filePath);
+  }
+};
+
+// src/cli/install.ts
+function runInstall(opts, fs2 = realFs) {
+  const loadResult = loadGlobalConfig(fs2);
+  if (loadResult.parseError) {
+    return {
+      status: "error",
+      path: loadResult.path,
+      specifier: buildSpecifier(opts.version),
+      parseError: loadResult.parseError
+    };
+  }
+  const configPath = loadResult.path;
+  const config = loadResult.config;
+  config["plugin"] = normalizePlugin(config);
+  const specifier = buildSpecifier(opts.version);
+  const existing = config["plugin"] ?? [];
+  if (existing.includes(specifier)) {
+    return { status: "noop", path: configPath, specifier };
+  }
+  removePlugin(config, "opencode-rules-md");
+  addPlugin(config, specifier);
+  if (opts.dryRun) {
+    const planned = JSON.stringify(config, null, 2);
+    console.log(`Planned config:
+` + planned);
+    return { status: "planned", path: configPath, specifier };
+  }
+  const backup = rotateBackups(fs2, configPath, "opencode-rules-md");
+  const serialized = JSON.stringify(config, null, 2);
+  writeAtomically(fs2, configPath, serialized);
+  console.log(`Installed ${specifier} to ${configPath}`);
+  if (backup) {
+    console.log(`Backup written to ${backup}`);
+  }
+  return { status: "wrote", path: configPath, specifier, backup };
+}
+function buildSpecifier(version) {
+  return version ? `opencode-rules-md@${version}` : "opencode-rules-md";
+}
+
+// src/cli/status.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+function runStatus(fs3 = realFs) {
+  const loadResult = loadGlobalConfig(fs3);
+  const configPath = loadResult.path;
+  if (loadResult.parseError) {
+    return {
+      installed: false,
+      path: configPath,
+      version: getVersion(),
+      parseError: loadResult.parseError
+    };
+  }
+  const config = loadResult.config;
+  const pluginList = Array.isArray(config["plugin"]) ? config["plugin"] : [];
+  const specifier = pluginList.find((p) => p.startsWith("opencode-rules-md"));
+  const result = {
+    installed: specifier !== undefined,
+    path: configPath,
+    version: getVersion()
+  };
+  if (specifier) {
+    result.specifier = specifier;
+  }
+  return result;
+}
+function getVersion() {
+  try {
+    const pkgPath = path2.resolve(process.cwd(), "package.json");
+    const content = fs2.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/cli/main.ts
+var HELP_TEXT = `opencode-rules-md CLI
+
+Usage: opencode-rules-md <command> [options]
+
+Commands:
+  install   Add opencode-rules-md to the global opencode config
+  status    Report whether opencode-rules-md is installed
+
+Options:
+  --version <v>  Specify a plugin version to install
+  --latest       Install the latest version (default)
+  --dry-run      Show what would be written, without changing files
+  --yes          Skip confirmation prompts (future use)
+  -h, --help     Show this help text
+`.trim();
+var USAGE_ERROR_TEXT = `Error: unknown command. Run 'opencode-rules-md --help' for usage.
+`.trim();
+function parseCliArgs(argv) {
+  const { positionals, values } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      version: { type: "string" },
+      latest: { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      yes: { type: "boolean" },
+      h: { type: "boolean" },
+      help: { type: "boolean" }
+    }
+  });
+  const command = positionals[0] ?? null;
+  const options = {
+    ...values.version !== undefined && { version: values.version },
+    ...values.latest && { latest: true },
+    ...values["dry-run"] && { dryRun: true },
+    ...values.yes && { yes: true },
+    ...(values.help || values.h) && { help: true }
+  };
+  const unknownFlags = [];
+  return { command, options, unknownFlags };
+}
+async function runMain(argv, fs3 = realFs) {
+  try {
+    const { command, options, unknownFlags } = parseCliArgs(argv);
+    if (options.help) {
+      console.log(HELP_TEXT);
+      return 0;
+    }
+    if (unknownFlags.length > 0) {
+      console.error(`Error: unknown option(s): ${unknownFlags.join(", ")}`);
+      console.error(USAGE_ERROR_TEXT);
+      return 2;
+    }
+    if (!command) {
+      console.error(USAGE_ERROR_TEXT);
+      return 2;
+    }
+    switch (command) {
+      case "install": {
+        const installOpts = {};
+        if (options.version !== undefined)
+          installOpts.version = options.version;
+        if (options.dryRun)
+          installOpts.dryRun = true;
+        const installResult = runInstall(installOpts, fs3);
+        if (installResult.status === "error") {
+          return 1;
+        }
+        return 0;
+      }
+      case "status": {
+        const statusResult = runStatus(fs3);
+        if (statusResult.installed) {
+          console.log(`opencode-rules-md is installed (${statusResult.specifier})`);
+        } else {
+          console.log("opencode-rules-md is not installed");
+        }
+        return 0;
+      }
+      default: {
+        console.error(`Error: unknown command '${command}'`);
+        console.error(USAGE_ERROR_TEXT);
+        return 2;
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const exitCode = await runMain(process.argv.slice(2));
+  process.exit(exitCode);
+}
+export {
+  runMain
+};

package/dist/src/active-rules-state.d.ts

@@ -0,0 +1,12 @@
+export interface ActiveRulesState {
+    sessionId: string;
+    matchedRulePaths: string[];
+    evaluatedAt: number;
+}
+/** @internal Test-only: override the state directory */
+export declare function _setStateDirForTesting(dir: string | null): void;
+export declare function resolveStateDir(): string;
+export declare function getStateFilePath(sessionId: string): string;
+export declare function writeActiveRulesState(sessionId: string, matchedPaths: string[]): void;
+export declare function readActiveRulesState(sessionId: string): Promise<ActiveRulesState | null>;
+//# sourceMappingURL=active-rules-state.d.ts.map

package/dist/src/active-rules-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-rules-state.d.ts","sourceRoot":"","sources":["../../src/active-rules-state.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;CACrB;AAeD,wDAAwD;AACxD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAE/D;AAED,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EAAE,GACrB,IAAI,CAyBN;AAqCD,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAwBlC"}

package/dist/src/active-rules-state.js

@@ -0,0 +1,118 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { createDebugLog } from './debug';
+const debugLog = createDebugLog();
+// Per-session write queue to serialize concurrent writes
+const writeQueues = new Map();
+// Allows tests to override the state directory
+let stateDirOverride = null;
+// Strict pattern for safe sessionId: alphanumeric, underscore, hyphen only
+const SAFE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+function isValidSessionId(sessionId) {
+    return SAFE_SESSION_ID_PATTERN.test(sessionId);
+}
+/** @internal Test-only: override the state directory */
+export function _setStateDirForTesting(dir) {
+    stateDirOverride = dir;
+}
+export function resolveStateDir() {
+    if (stateDirOverride !== null) {
+        return stateDirOverride;
+    }
+    return path.join(os.homedir(), '.opencode', 'state', 'opencode-rules-md');
+}
+export function getStateFilePath(sessionId) {
+    if (!isValidSessionId(sessionId)) {
+        throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path.join(resolveStateDir(), `${sessionId}.json`);
+}
+export function writeActiveRulesState(sessionId, matchedPaths) {
+    if (!isValidSessionId(sessionId)) {
+        debugLog(`Invalid sessionId rejected: ${sessionId}`);
+        return;
+    }
+    const state = {
+        sessionId,
+        matchedRulePaths: matchedPaths,
+        evaluatedAt: Date.now(),
+    };
+    // Chain onto existing queue for this session, or start fresh
+    const previousWrite = writeQueues.get(sessionId) ?? Promise.resolve();
+    const currentWrite = previousWrite.then(async () => {
+        await doAtomicWrite(sessionId, state);
+    });
+    writeQueues.set(sessionId, currentWrite);
+    // Fire-and-forget: catch errors to prevent unhandled rejection
+    currentWrite.catch(() => {
+        // Errors already logged in doAtomicWrite
+    });
+}
+async function doAtomicWrite(sessionId, state) {
+    const stateDir = resolveStateDir();
+    const finalPath = getStateFilePath(sessionId);
+    const tempPath = path.join(stateDir, `.${sessionId}-${crypto.randomBytes(8).toString('hex')}.tmp`);
+    try {
+        // Ensure directory exists
+        await fs.mkdir(stateDir, { recursive: true });
+        // Write to temp file
+        const content = JSON.stringify(state);
+        await fs.writeFile(tempPath, content, 'utf-8');
+        // Atomic rename
+        await fs.rename(tempPath, finalPath);
+    }
+    catch (error) {
+        debugLog(`Failed to write active rules state for session ${sessionId}: ${error}`);
+        // Clean up temp file if it exists
+        try {
+            await fs.unlink(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+export async function readActiveRulesState(sessionId) {
+    if (!isValidSessionId(sessionId)) {
+        debugLog(`Invalid sessionId rejected: ${sessionId}`);
+        return null;
+    }
+    const filePath = getStateFilePath(sessionId);
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (!isValidActiveRulesState(parsed)) {
+            debugLog(`Invalid active rules state format for session ${sessionId}`);
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        debugLog(`Failed to read active rules state for session ${sessionId}: ${error}`);
+        return null;
+    }
+}
+function isValidActiveRulesState(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const obj = value;
+    if (typeof obj['sessionId'] !== 'string') {
+        return false;
+    }
+    if (typeof obj['evaluatedAt'] !== 'number') {
+        return false;
+    }
+    if (!Array.isArray(obj['matchedRulePaths'])) {
+        return false;
+    }
+    for (const item of obj['matchedRulePaths']) {
+        if (typeof item !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=active-rules-state.js.map

package/dist/src/active-rules-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-rules-state.js","sourceRoot":"","sources":["../../src/active-rules-state.ts"],"names":[],"mappings":"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"}

package/dist/src/cli/config.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CLI config helpers: discovery, JSONC-safe parsing, plugin normalization,
+ * backup rotation, and atomic write.
+ *
+ * All filesystem access goes through the CliFs interface so tests can inject
+ * an in-memory implementation without touching real disk.
+ */
+import type { CliFs } from './real-fs.js';
+export interface LoadResult {
+    path: string;
+    existed: boolean;
+    config: Record<string, unknown>;
+    parseError?: Error;
+}
+/**
+ * Strip JSONC comments and trailing commas while preserving
+ * comment-like sequences inside string literals.
+ */
+export declare function stripJsoncComments(content: string): string;
+/**
+ * Resolve the global opencode config path using the same precedence as
+ * opencode itself: OPENCODE_CONFIG_DIR → XDG_CONFIG_HOME → HOME fallback.
+ *
+ * On Windows, APPDATA is tried as a last resort when XDG_CONFIG_HOME and
+ * HOME are both absent.
+ */
+export declare function resolveGlobalConfigPath(fs: CliFs, opts?: {
+    ensureDir?: boolean;
+}): string;
+/**
+ * Load and parse the global opencode config.
+ * Treats a missing file as an empty config object (not an error).
+ * Surfaces parse errors so callers can exit non-zero without corrupting data.
+ */
+export declare function loadGlobalConfig(fs: CliFs): LoadResult;
+/**
+ * Return the plugin array with opencode-rules-md* entries deduplicated by
+ * name prefix, keeping the last occurrence of each unique prefix.
+ */
+export declare function normalizePlugin(config: Record<string, unknown>): string[];
+/**
+ * Remove all plugins matching the given prefix (used to dedupe before append).
+ */
+export declare function removePlugin(config: Record<string, unknown>, prefix: string): void;
+/**
+ * Add a plugin specifier, removing any existing entry with the same prefix first
+ * so it ends up at the specified position (default: end). This makes the operation
+ * idempotent — re-adding the same specifier just moves it to the end.
+ */
+export declare function addPlugin(config: Record<string, unknown>, specifier: string): void;
+/**
+ * Write a timestamped backup of the given config path and rotate so at most
+ * 3 backups are retained (oldest deleted first).
+ * Returns the path of the newly created backup.
+ */
+export declare function rotateBackups(fs: CliFs, configPath: string, _pluginName: string): string;
+/**
+ * Write content to a temporary sibling file then rename it into place.
+ * The final path is never in a partially-written state.
+ */
+export declare function writeAtomically(fs: CliFs, configPath: string, content: string): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/cli/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAM1C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB;AAMD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAgE1D;AAMD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,KAAK,EACT,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,MAAM,CAMR;AA+BD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,KAAK,GAAG,UAAU,CAoBtD;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,EAAE,CAcV;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,EAAE,MAAM,GACb,IAAI,CAMN;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,MAAM,GAChB,IAAI,CAUN;AAMD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAyBxF;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAOpF"}