opencode-rules-md 0.6.5 → 0.7.0

package/src/cli/config.ts

@@ -10,6 +10,19 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import type { CliFs } from './real-fs.js';
 
+// ---------------------------------------------------------------------------
+// Public constants
+// ---------------------------------------------------------------------------
+
+/** npm package name for this plugin. */
+export const PLUGIN_NAME = 'opencode-rules-md';
+
+/** Filename for the OpenCode server config. */
+export const SERVER_CONFIG_FILENAME = 'opencode.json';
+
+/** Filename for the OpenCode TUI config. */
+export const TUI_CONFIG_FILENAME = 'tui.json';
+
 // ---------------------------------------------------------------------------
 // Public types
 // ---------------------------------------------------------------------------
@@ -22,77 +35,112 @@ export interface LoadResult {
 }
 
 // ---------------------------------------------------------------------------
-// JSONC comment stripper
+// JSONC comment stripper — two-pass
 // ---------------------------------------------------------------------------
 
 /**
  * Strip JSONC comments and trailing commas while preserving
  * comment-like sequences inside string literals.
+ *
+ * Pass 1: strip `//` and `/* * /` comments (string-aware).
+ * Pass 2: strip trailing commas before `}` or `]`, skipping whitespace.
  */
 export function stripJsoncComments(content: string): string {
+  // Pass 1 — strip comments while preserving string contents
   let result = '';
   let i = 0;
-  while (i < content.length) {
-    const char = content[i];
+  let inString = false;
+  let escaped = false;
+  const len = content.length;
+
+  while (i < len) {
+    const char = content[i]!;
+
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
 
-    // Start of string (double-quoted only — JSON only supports double quotes)?
     if (char === '"') {
+      inString = true;
       result += char;
       i++;
-      while (i < content.length) {
-        const c = content[i];
-        if (c === '\\' && i + 1 < content.length) {
-          // Escape sequence — copy both chars verbatim
-          result += c + content[i + 1];
-          i += 2;
-          continue;
-        }
-        if (c === '"') {
-          result += c;
-          i++;
-          break;
-        }
-        result += c;
-        i++;
-      }
       continue;
     }
 
-    // Line comment?
+    // Line comment: // until newline
     if (char === '/' && content[i + 1] === '/') {
-      while (i < content.length && content[i] !== '\n') {
-        i++;
-      }
+      i += 2;
+      while (i < len && content[i] !== '\n') i++;
       continue;
     }
 
-    // Block comment?
+    // Block comment: /* until */
     if (char === '/' && content[i + 1] === '*') {
       i += 2;
-      while (i + 1 < content.length && !(content[i] === '*' && content[i + 1] === '/')) {
-        i++;
-      }
-      // Only skip past */ if we actually found it
-      if (i + 1 < content.length) {
-        i += 2; // skip */
+      while (i < len && !(content[i] === '*' && content[i + 1] === '/')) i++;
+      if (i < len) i += 2; // skip past */
+      continue;
+    }
+
+    result += char;
+    i++;
+  }
+
+  // Pass 2 — strip trailing commas (with whitespace skip) before } or ]
+  let out = '';
+  let inStr = false;
+  let esc = false;
+  let j = 0;
+  const outLen = result.length;
+
+  while (j < outLen) {
+    const ch = result[j]!;
+
+    if (inStr) {
+      out += ch;
+      if (esc) {
+        esc = false;
+      } else if (ch === '\\') {
+        esc = true;
+      } else if (ch === '"') {
+        inStr = false;
       }
+      j++;
       continue;
     }
 
-    // Trailing comma before } or ]
-    if (
-      char === ',' &&
-      (content[i + 1] === '}' || content[i + 1] === ']')
-    ) {
-      i++;
+    if (ch === '"') {
+      inStr = true;
+      out += ch;
+      j++;
       continue;
     }
 
-    result += char;
-    i++;
+    if (ch === ',') {
+      // Skip whitespace before checking for } or ]
+      let k = j + 1;
+      while (k < outLen && /\s/.test(result[k]!)) k++;
+      if (k < outLen && /[}\]]/.test(result[k]!)) {
+        // Drop the comma; jump to the bracket
+        j = k;
+        continue;
+      }
+    }
+
+    out += ch;
+    j++;
   }
 
-  return result;
+  return out;
 }
 
 // ---------------------------------------------------------------------------
@@ -108,13 +156,14 @@ export function stripJsoncComments(content: string): string {
  */
 export function resolveGlobalConfigPath(
   fs: CliFs,
-  opts: { ensureDir?: boolean } = {}
+  opts: { ensureDir?: boolean; filename?: string } = {}
 ): string {
   const dir = resolveConfigDir();
   if (opts.ensureDir && !fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  return path.join(dir, 'opencode.json');
+  const filename = opts.filename ?? SERVER_CONFIG_FILENAME;
+  return path.join(dir, filename);
 }
 
 function resolveConfigDir(): string {
@@ -147,12 +196,15 @@ function resolveConfigDir(): string {
 // ---------------------------------------------------------------------------
 
 /**
- * Load and parse the global opencode config.
+ * Load and parse a global OpenCode config file.
  * 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 function loadGlobalConfig(fs: CliFs): LoadResult {
-  const configPath = resolveGlobalConfigPath(fs);
+export function loadGlobalConfig(fs: CliFs, opts: { filename?: string } = {}): LoadResult {
+  const configPath = resolveGlobalConfigPath(
+    fs,
+    opts.filename ? { filename: opts.filename } : {}
+  );
 
   if (!fs.existsSync(configPath)) {
     return { path: configPath, existed: false, config: {} };
@@ -240,19 +292,19 @@ export function addPlugin(
 /**
  * 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.
+ * Returns the path of the newly created backup, or null if no backup was created.
  */
-export function rotateBackups(fs: CliFs, configPath: string, _pluginName: string): string {
+export function rotateBackups(fs: CliFs, configPath: string, _pluginName: string): string | null {
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
   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');
-  }
+  fs.copyFileSync(configPath, newBak);
 
   // Collect existing backups sorted by timestamp (lexical sort on numeric suffix)
   const entries = fs.readdirSync(dir);
@@ -280,7 +332,7 @@ export function rotateBackups(fs: CliFs, configPath: string, _pluginName: string
 export function writeAtomically(fs: CliFs, configPath: string, content: string): void {
   const dir = path.dirname(configPath);
   const base = path.basename(configPath);
-  const tmpPath = path.join(dir, `.${base}.tmp.${Date.now()}`);
+  const tmpPath = path.join(dir, `.${base}.tmp.${Date.now()}-${process.pid}`);
 
   fs.writeFileSync(tmpPath, content, 'utf-8');
   fs.renameSync(tmpPath, configPath);
@@ -309,4 +361,4 @@ function collapseByPrefix(
   const keptIndices = new Set([...lastSeen.values()]);
 
   return plugins.filter((_, idx) => keptIndices.has(idx));
-}
+}

package/src/cli/install.ts

@@ -1,13 +1,28 @@
 /**
- * install command: idempotently append opencode-rules-md to the global config.
+ * install command: idempotently append opencode-rules-md to the global configs.
  *
- * Pipeline:
- *   loadGlobalConfig → abort if parseError → dedupe → append specifier
+ * Registers the plugin in BOTH:
+ *   - Server config:  ~/.config/opencode/opencode.json
+ *   - TUI config:     ~/.config/opencode/tui.json
+ *
+ * Pipeline (per config):
+ *   loadGlobalConfig → abort if parseError (throw) → normalizePlugin
  *   → check no-op → (dry-run? print & return "planned")
  *   → rotateBackups → writeAtomically → print & return "wrote"
+ *
+ * Errors are surfaced as exceptions instead of silent status returns so
+ * the CLI dispatcher can print them.
  */
 
-import { loadGlobalConfig, normalizePlugin, removePlugin, addPlugin, rotateBackups, writeAtomically } from './config.js';
+import {
+  loadGlobalConfig,
+  normalizePlugin,
+  removePlugin,
+  addPlugin,
+  rotateBackups,
+  writeAtomically,
+  TUI_CONFIG_FILENAME,
+} from './config.js';
 import type { CliFs } from './real-fs.js';
 import { realFs } from './real-fs.js';
 
@@ -15,12 +30,18 @@ import { realFs } from './real-fs.js';
 // Result types
 // ---------------------------------------------------------------------------
 
-export interface InstallResult {
-  status: 'wrote' | 'planned' | 'noop' | 'error';
+export interface ConfigUpdateResult {
+  status: 'wrote' | 'planned' | 'noop';
   path: string;
   specifier: string;
   backup?: string;
-  parseError?: Error;
+}
+
+export interface InstallResult {
+  status: 'wrote' | 'planned' | 'noop';
+  specifier: string;
+  server: ConfigUpdateResult;
+  tui: ConfigUpdateResult;
 }
 
 // ---------------------------------------------------------------------------
@@ -31,17 +52,54 @@ export function runInstall(
   opts: { version?: string; dryRun?: boolean },
   fs: CliFs = realFs
 ): InstallResult {
-  // Load config
-  const loadResult = loadGlobalConfig(fs);
+  const specifier = buildSpecifier(opts.version);
+
+  const server = updateConfig(specifier, opts.dryRun ?? false, fs);
+  const tui = updateConfig(specifier, opts.dryRun ?? false, fs, {
+    filename: TUI_CONFIG_FILENAME,
+  });
+
+  const aggregate: InstallResult['status'] =
+    server.status === 'wrote' || tui.status === 'wrote'
+      ? 'wrote'
+      : server.status === 'planned' || tui.status === 'planned'
+        ? 'planned'
+        : 'noop';
+
+  printSummary(aggregate, specifier, server, tui);
 
-  // Abort on parse error — do not corrupt malformed config
+  return { status: aggregate, specifier, server, tui };
+}
+
+// ---------------------------------------------------------------------------
+// Internal: update a single config file
+// ---------------------------------------------------------------------------
+
+interface UpdateOpts {
+  filename?: string;
+}
+
+function updateConfig(
+  specifier: string,
+  dryRun: boolean,
+  fs: CliFs,
+  opts: UpdateOpts = {}
+): ConfigUpdateResult {
+  const loadResult = loadGlobalConfig(
+    fs,
+    opts.filename ? { filename: opts.filename } : {}
+  );
+
+  // Throw on parse error — better to fail fast than to silently corrupt config
   if (loadResult.parseError) {
-    return {
-      status: 'error',
-      path: loadResult.path,
-      specifier: buildSpecifier(opts.version),
-      parseError: loadResult.parseError,
-    };
+    const filename = opts.filename ?? 'opencode.json';
+    const err: Error & { configPath?: string } = new Error(
+      `opencode-rules-md: ${filename} is malformed — aborting to avoid data loss.\n` +
+        `  path:  ${loadResult.path}\n` +
+        `  error: ${loadResult.parseError.message}`
+    );
+    err.configPath = loadResult.path;
+    throw err;
   }
 
   const configPath = loadResult.path;
@@ -50,9 +108,6 @@ export function runInstall(
   // Normalize plugin array (dedupe by prefix)
   config['plugin'] = normalizePlugin(config);
 
-  // Build the specifier
-  const specifier = buildSpecifier(opts.version);
-
   // Check if already installed with the same specifier — no-op
   const existing = (config['plugin'] as string[] | undefined) ?? [];
   if (existing.includes(specifier)) {
@@ -66,9 +121,9 @@ export function runInstall(
   addPlugin(config, specifier);
 
   // Dry-run: serialize and print planned content, make no changes
-  if (opts.dryRun) {
+  if (dryRun) {
     const planned = JSON.stringify(config, null, 2);
-    console.log('Planned config:\n' + planned);
+    console.log(`Planned ${configPath}:\n${planned}`);
     return { status: 'planned', path: configPath, specifier };
   }
 
@@ -77,12 +132,9 @@ export function runInstall(
   const serialized = JSON.stringify(config, null, 2);
   writeAtomically(fs, configPath, serialized);
 
-  console.log(`Installed ${specifier} to ${configPath}`);
-  if (backup) {
-    console.log(`Backup written to ${backup}`);
-  }
-
-  return { status: 'wrote', path: configPath, specifier, backup };
+  const result: ConfigUpdateResult = { status: 'wrote', path: configPath, specifier };
+  if (backup) result.backup = backup;
+  return result;
 }
 
 // ---------------------------------------------------------------------------
@@ -92,3 +144,28 @@ export function runInstall(
 function buildSpecifier(version?: string): string {
   return version ? `opencode-rules-md@${version}` : 'opencode-rules-md';
 }
+
+function printSummary(
+  status: InstallResult['status'],
+  specifier: string,
+  server: ConfigUpdateResult,
+  tui: ConfigUpdateResult
+): void {
+  if (status === 'noop') {
+    console.log(`Already installed (${specifier})`);
+    console.log(`  server config: ${server.path}`);
+    console.log(`  tui config:    ${tui.path}`);
+    return;
+  }
+
+  if (status === 'planned') {
+    console.log('Dry run complete — no files written.');
+    return;
+  }
+
+  console.log(`Installed ${specifier}`);
+  console.log(`  server config: ${server.path}`);
+  if (server.backup) console.log(`    backup:      ${server.backup}`);
+  console.log(`  tui config:    ${tui.path}`);
+  if (tui.backup) console.log(`    backup:      ${tui.backup}`);
+}

package/src/cli/main.ts

@@ -3,7 +3,7 @@
  * CLI entrypoint for opencode-rules-md installer.
  *
  * Supports:
- *   install   — add opencode-rules-md to the global opencode config
+ *   install   — add opencode-rules-md to the global opencode + tui configs
  *   status    — report whether opencode-rules-md is installed
  *
  * Flags:
@@ -15,6 +15,8 @@
  */
 
 import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { realpathSync } from 'node:fs';
 import { runInstall } from './install.js';
 import { runStatus } from './status.js';
 import type { CliFs } from './real-fs.js';
@@ -29,7 +31,7 @@ const HELP_TEXT = `opencode-rules-md CLI
 Usage: opencode-rules-md <command> [options]
 
 Commands:
-  install   Add opencode-rules-md to the global opencode config
+  install   Add opencode-rules-md to the global opencode + tui configs
   status    Report whether opencode-rules-md is installed
 
 Options:
@@ -40,8 +42,7 @@ Options:
   -h, --help     Show this help text
 `.trim();
 
-const USAGE_ERROR_TEXT = `Error: unknown command. Run 'opencode-rules-md --help' for usage.
-`.trim();
+const USAGE_ERROR_TEXT = `Error: unknown command. Run 'opencode-rules-md --help' for usage.`.trim();
 
 // ---------------------------------------------------------------------------
 // Argument parsing
@@ -82,9 +83,6 @@ function parseCliArgs(argv: string[]): { command: string | null; options: CliOpt
     ...((values.help || values.h) && { help: true }),
   };
 
-  // Detect unknown flags (tokens that look like flags but aren't recognized)
-  // parseArgs already filters known tokens, so we check if any positional
-  // looks like an unknown option
   const unknownFlags: string[] = [];
 
   return { command, options, unknownFlags };
@@ -124,26 +122,19 @@ export async function runMain(argv: string[], fs: CliFs = realFs): Promise<ExitC
         const installOpts: { version?: string; dryRun?: boolean } = {};
         if (options.version !== undefined) installOpts.version = options.version;
         if (options.dryRun) installOpts.dryRun = true;
-        const installResult = runInstall(installOpts, fs);
-        // Map install status to exit code
-        if (installResult.status === 'error') {
-          return 1;
-        }
+        runInstall(installOpts, fs);
         return 0;
       }
-
       case 'status': {
         const statusResult = runStatus(fs);
-        // Print status to stdout
         if (statusResult.installed) {
-          console.log(`opencode-rules-md is installed (${statusResult.specifier})`);
+          const spec = statusResult.serverSpecifier ?? statusResult.tuiSpecifier;
+          console.log(`opencode-rules-md is installed (${spec})`);
         } else {
           console.log('opencode-rules-md is not installed');
         }
-        // Exit code 0 regardless of install state (status is read-only)
         return 0;
       }
-
       default: {
         console.error(`Error: unknown command '${command}'`);
         console.error(USAGE_ERROR_TEXT);
@@ -151,7 +142,8 @@ export async function runMain(argv: string[], fs: CliFs = realFs): Promise<ExitC
       }
     }
   } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
     return 1;
   }
 }
@@ -160,8 +152,27 @@ export async function runMain(argv: string[], fs: CliFs = realFs): Promise<ExitC
 // Entry point
 // ---------------------------------------------------------------------------
 
-// Only run if executed directly (not imported as a module)
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const exitCode = await runMain(process.argv.slice(2));
-  process.exit(exitCode);
+/**
+ * Determine whether the current module is being executed as the main entry.
+ * Uses realpathSync + pathToFileURL so symlinked invocations (e.g. npx)
+ * are matched correctly.
+ */
+function isInvokedAsMain(): boolean {
+  if (!process.argv[1]) return false;
+
+  try {
+    const realArgv = pathToFileURL(realpathSync(process.argv[1])).href;
+    return import.meta.url === realArgv;
+  } catch {
+    try {
+      return import.meta.url === pathToFileURL(process.argv[1]).href;
+    } catch {
+      return false;
+    }
+  }
 }
+
+// Only run if executed directly (not imported as a module)
+if (isInvokedAsMain()) {
+  void runMain(process.argv.slice(2)).then(code => process.exit(code));
+}

package/src/cli/status.ts

@@ -1,14 +1,16 @@
 /**
  * status command: read-only probe that reports install state.
  *
- * Reports:
- *   - installed: yes/no
- *   - specifier: the registered opencode-rules-md entry (or undefined)
- *   - path: config file path
- *   - version: bundled CLI version from package.json
+ * Reports install state across BOTH the server and TUI configs:
+ *   - installed: yes/no (true only when present in both configs)
+ *   - serverSpecifier: the registered entry in opencode.json (or undefined)
+ *   - tuiSpecifier:    the registered entry in tui.json (or undefined)
+ *   - serverPath:      path to the server config
+ *   - tuiPath:         path to the TUI config
+ *   - version:         bundled CLI version from package.json
  */
 
-import { loadGlobalConfig } from './config.js';
+import { loadGlobalConfig, TUI_CONFIG_FILENAME } from './config.js';
 import type { CliFs } from './real-fs.js';
 import { realFs } from './real-fs.js';
 import * as fs from 'node:fs';
@@ -19,10 +21,23 @@ import * as path from 'node:path';
 // ---------------------------------------------------------------------------
 
 export interface StatusResult {
+  /** True only when the plugin is registered in both server and TUI configs. */
   installed: boolean;
-  path: string;
-  specifier?: string;
+  /** Server config path. */
+  serverPath: string;
+  /** TUI config path. */
+  tuiPath: string;
+  /** Registered specifier in the server config, if any. */
+  serverSpecifier?: string;
+  /** Registered specifier in the TUI config, if any. */
+  tuiSpecifier?: string;
+  /** Whether the server config existed on disk before the probe. */
+  serverExisted: boolean;
+  /** Whether the TUI config existed on disk before the probe. */
+  tuiExisted: boolean;
+  /** Bundled CLI version from package.json. */
   version: string;
+  /** First parse error encountered, if any (server takes priority). */
   parseError?: Error;
 }
 
@@ -30,35 +45,30 @@ export interface StatusResult {
 // Run status
 // ---------------------------------------------------------------------------
 
-export function runStatus(fs: CliFs = realFs): StatusResult {
-  const loadResult = loadGlobalConfig(fs);
-  const configPath = loadResult.path;
+export function runStatus(cliFs: CliFs = realFs): StatusResult {
+  const serverLoad = loadGlobalConfig(cliFs);
+  const tuiLoad = loadGlobalConfig(cliFs, { filename: TUI_CONFIG_FILENAME });
 
-  // Surface parse errors as installed=false
-  if (loadResult.parseError) {
-    return {
-      installed: false,
-      path: configPath,
-      version: getVersion(),
-      parseError: loadResult.parseError,
-    };
-  }
-
-  const config = loadResult.config;
-  const pluginList: string[] = Array.isArray(config['plugin']) ? (config['plugin'] as string[]) : [];
+  const serverSpecifier = findSpecifier(serverLoad);
+  const tuiSpecifier = findSpecifier(tuiLoad);
 
-  // Find the opencode-rules-md entry (exact match for idempotency)
-  const specifier = pluginList.find(p => p.startsWith('opencode-rules-md'));
+  const installed = serverSpecifier !== undefined && tuiSpecifier !== undefined;
 
   const result: StatusResult = {
-    installed: specifier !== undefined,
-    path: configPath,
+    installed,
+    serverPath: serverLoad.path,
+    tuiPath: tuiLoad.path,
+    serverExisted: serverLoad.existed,
+    tuiExisted: tuiLoad.existed,
     version: getVersion(),
   };
 
-  if (specifier) {
-    result.specifier = specifier;
-  }
+  if (serverSpecifier) result.serverSpecifier = serverSpecifier;
+  if (tuiSpecifier) result.tuiSpecifier = tuiSpecifier;
+
+  // Surface the first parse error so callers can warn the user
+  const parseError = serverLoad.parseError ?? tuiLoad.parseError;
+  if (parseError) result.parseError = parseError;
 
   return result;
 }
@@ -67,6 +77,15 @@ export function runStatus(fs: CliFs = realFs): StatusResult {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
+function findSpecifier(load: ReturnType<typeof loadGlobalConfig>): string | undefined {
+  if (load.parseError) return undefined;
+  const config = load.config;
+  const pluginList: string[] = Array.isArray(config['plugin'])
+    ? (config['plugin'] as string[])
+    : [];
+  return pluginList.find(p => p.startsWith('opencode-rules-md'));
+}
+
 function getVersion(): string {
   try {
     // Read package.json relative to the project root
@@ -77,4 +96,4 @@ function getVersion(): string {
   } catch {
     return 'unknown';
   }
-}
+}