refacil-sdd-ai 5.2.2 → 5.3.0

package/lib/opencode-migrate.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { globalOpenCodeDir, legacyOpenCodeDirs } = require('./global-paths');
+
+const REFACIL_PREFIX = 'refacil-';
+const PLUGIN_FILES = ['refacil-hooks.js', 'refacil-check-review.js', 'rules.js'];
+
+function listRefacilEntries(dir) {
+  if (!fs.existsSync(dir)) return [];
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.name.startsWith(REFACIL_PREFIX));
+  } catch (_) {
+    return [];
+  }
+}
+
+function primaryHasRefacilSkills(primaryDir) {
+  const skillsDir = path.join(primaryDir, 'skills');
+  return listRefacilEntries(skillsDir).length > 0;
+}
+
+function primaryHasRefacilAgents(primaryDir) {
+  const agentsDir = path.join(primaryDir, 'agents');
+  return listRefacilEntries(agentsDir).length > 0;
+}
+
+function copyRefacilTree(srcDir, destDir) {
+  if (!fs.existsSync(srcDir)) return 0;
+  let copied = 0;
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const entry of listRefacilEntries(srcDir)) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (fs.existsSync(destPath)) continue;
+    try {
+      if (entry.isDirectory()) {
+        fs.cpSync(srcPath, destPath, { recursive: true });
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+      copied++;
+    } catch (_) {}
+  }
+  return copied;
+}
+
+function copyRefacilPlugins(srcPlugins, destPlugins) {
+  if (!fs.existsSync(srcPlugins)) return 0;
+  let copied = 0;
+  fs.mkdirSync(destPlugins, { recursive: true });
+  for (const name of PLUGIN_FILES) {
+    const src = path.join(srcPlugins, name);
+    const dest = path.join(destPlugins, name);
+    if (!fs.existsSync(src) || fs.existsSync(dest)) continue;
+    try {
+      fs.copyFileSync(src, dest);
+      copied++;
+    } catch (_) {}
+  }
+  return copied;
+}
+
+/**
+ * Non-destructive migration: copy refacil artifacts from legacy OpenCode dirs into the primary config dir.
+ * Emits stderr warnings when migration occurs. Safe to call on every install.
+ * @param {string} [homeDir] - injectable for testing
+ * @returns {{ migrated: boolean, fromDirs: string[] }}
+ */
+function migrateOpenCodeLegacyArtifacts(homeDir) {
+  const primary = globalOpenCodeDir(homeDir);
+  const needsSkills = !primaryHasRefacilSkills(primary);
+  const needsAgents = !primaryHasRefacilAgents(primary);
+  const pluginsDir = path.join(primary, 'plugins');
+  const needsPlugins = !PLUGIN_FILES.every((f) => fs.existsSync(path.join(pluginsDir, f)));
+
+  if (!needsSkills && !needsAgents && !needsPlugins) {
+    for (const legacyDir of legacyOpenCodeDirs(homeDir)) {
+      if (legacyDir === primary || !fs.existsSync(legacyDir)) continue;
+      const legacySkills = listRefacilEntries(path.join(legacyDir, 'skills'));
+      const legacyAgents = listRefacilEntries(path.join(legacyDir, 'agents'));
+      const legacyPlugins = path.join(legacyDir, 'plugins');
+      const hasLegacyPlugins = PLUGIN_FILES.some((f) => fs.existsSync(path.join(legacyPlugins, f)));
+      if (legacySkills.length > 0 || legacyAgents.length > 0 || hasLegacyPlugins) {
+        process.stderr.write(
+          `[refacil-sdd-ai] OpenCode primary config already has refacil artifacts; skipped legacy migration from ${legacyDir} (no overwrite).\n`,
+        );
+      }
+    }
+    return { migrated: false, fromDirs: [] };
+  }
+
+  const fromDirs = [];
+  let totalCopied = 0;
+
+  for (const legacyDir of legacyOpenCodeDirs(homeDir)) {
+    if (legacyDir === primary || !fs.existsSync(legacyDir)) continue;
+
+    const legacySkillsDir = path.join(legacyDir, 'skills');
+    const legacyAgentsDir = path.join(legacyDir, 'agents');
+    const legacyPluginsDir = path.join(legacyDir, 'plugins');
+    const legacySkills = listRefacilEntries(legacySkillsDir);
+    const legacyAgents = listRefacilEntries(legacyAgentsDir);
+    const hasLegacyPlugins = PLUGIN_FILES.some((f) => fs.existsSync(path.join(legacyPluginsDir, f)));
+
+    if (!needsSkills && legacySkills.length > 0) {
+      process.stderr.write(
+        `[refacil-sdd-ai] OpenCode primary config already has refacil artifacts; skipped legacy migration from ${legacyDir} (no overwrite).\n`,
+      );
+    } else if (!needsAgents && legacyAgents.length > 0) {
+      process.stderr.write(
+        `[refacil-sdd-ai] OpenCode primary config already has refacil artifacts; skipped legacy migration from ${legacyDir} (no overwrite).\n`,
+      );
+    } else if (!needsPlugins && hasLegacyPlugins) {
+      process.stderr.write(
+        `[refacil-sdd-ai] OpenCode primary config already has refacil artifacts; skipped legacy migration from ${legacyDir} (no overwrite).\n`,
+      );
+    }
+
+    let copied = 0;
+    if (needsSkills) {
+      copied += copyRefacilTree(path.join(legacyDir, 'skills'), path.join(primary, 'skills'));
+    }
+    if (needsAgents) {
+      copied += copyRefacilTree(path.join(legacyDir, 'agents'), path.join(primary, 'agents'));
+    }
+    if (needsPlugins) {
+      copied += copyRefacilPlugins(path.join(legacyDir, 'plugins'), pluginsDir);
+    }
+
+    if (copied > 0) {
+      fromDirs.push(legacyDir);
+      totalCopied += copied;
+    }
+  }
+
+  if (totalCopied > 0) {
+    process.stderr.write(
+      `[refacil-sdd-ai] Migrated OpenCode refacil artifacts from legacy path(s) to ${primary}\n`,
+    );
+    return { migrated: true, fromDirs };
+  }
+
+  return { migrated: false, fromDirs: [] };
+}
+
+module.exports = { migrateOpenCodeLegacyArtifacts };

package/lib/opencode-plugin/index.js

@@ -4,7 +4,7 @@
  * refacil-sdd-ai OpenCode plugin
  *
  * Provides 4 hook equivalents for OpenCode:
- *   - session.created       → check-update logic (sync compact-guidance + testing-policy, flag pending migrations)
+ *   - session.created       → runs `refacil-sdd-ai check-update` (same CLI as Claude/Cursor/Codex)
  *   - tui.prompt.append     → notify-update logic (prompt user to run /refacil:update if pending)
  *   - tool.execute.before   → check-review + compact-bash logic
  *
@@ -15,6 +15,39 @@
 const path = require('path');
 const fs = require('fs');
 
+/** @type {import('../check-review').evaluateGitPushReview | null} */
+let evaluateGitPushReview = null;
+
+(function loadCheckReviewModule() {
+  const candidates = [
+    // Co-installed by installOpenCodePlugin (global ~/.config/.../plugins/)
+    path.join(__dirname, 'refacil-check-review.js'),
+    // Running from package source (lib/opencode-plugin/index.js)
+    path.resolve(__dirname, '..', 'check-review.js'),
+    // Project-local node_modules
+    path.resolve(__dirname, '..', '..', 'node_modules', 'refacil-sdd-ai', 'lib', 'check-review.js'),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        evaluateGitPushReview = require(candidate).evaluateGitPushReview;
+        return;
+      }
+    } catch (_) {
+      // try next candidate
+    }
+  }
+
+  try {
+    evaluateGitPushReview = require('refacil-sdd-ai/lib/check-review').evaluateGitPushReview;
+  } catch (_) {
+    process.stderr.write(
+      '[refacil-sdd-ai] WARNING: Could not load check-review.js — git push review gate disabled.\n',
+    );
+  }
+})();
+
 // ── Resolve compact rules ────────────────────────────────────────────────────
 // When installed, this file lives at .opencode/plugins/refacil-hooks.js.
 // The compact rules live at <package>/lib/compact/rules.js.
@@ -25,10 +58,13 @@ let findRule = null;
 
 (function loadCompactRules() {
   const candidates = [
+    // Co-installed beside refacil-hooks.js (global ~/.config/opencode/plugins/)
+    path.join(__dirname, 'rules.js'),
     // Installed as plugin in .opencode/plugins/ — package is in node_modules
     path.resolve(__dirname, '..', '..', 'node_modules', 'refacil-sdd-ai', 'lib', 'compact', 'rules.js'),
     // Running from source (lib/opencode-plugin/index.js)
     path.resolve(__dirname, '..', 'compact', 'rules.js'),
+    path.resolve(__dirname, 'rules.js'),
   ];
 
   for (const candidate of candidates) {
@@ -66,12 +102,6 @@ function readPendingUpdateFlag(projectRoot) {
   }
 }
 
-function writePendingUpdateFlag(projectRoot, from, to) {
-  try {
-    fs.writeFileSync(getPendingUpdateFlagPath(projectRoot), JSON.stringify({ from, to }));
-  } catch (_) {}
-}
-
 function clearPendingUpdateFlag(projectRoot) {
   try {
     const flagPath = getPendingUpdateFlagPath(projectRoot);
@@ -79,17 +109,6 @@ function clearPendingUpdateFlag(projectRoot) {
   } catch (_) {}
 }
 
-function readRepoVersion(projectRoot) {
-  const versionFiles = ['.opencode/.sdd-version', '.claude/.sdd-version', '.cursor/.sdd-version'];
-  for (const rel of versionFiles) {
-    try {
-      const raw = fs.readFileSync(path.join(projectRoot, rel), 'utf8').trim();
-      if (raw) return raw;
-    } catch (_) {}
-  }
-  return null;
-}
-
 /** Same resolution strategy as `lib/session-repo-sync.js` (kept local so the copied plugin stays self-contained). */
 function resolveRefacilPackageRootForOpenCode(projectRoot) {
   const marker = path.join('templates', 'testing-policy.md');
@@ -127,66 +146,58 @@ function loadMethodologyMigrationPending(projectRoot) {
   }
 }
 
-// ── Hook handlers ────────────────────────────────────────────────────────────
-
 /**
- * session.created — equivalent of check-update (SessionStart hook)
- * Syncs compact-guidance + testing-policy like `refacil-sdd-ai check-update`, then flags pending methodology migrations.
+ * Run the same entrypoint as Claude/Cursor/Codex SessionStart hooks.
+ * Prefers `node <package>/bin/cli.js check-update` when the package resolves from the repo;
+ * falls back to global `refacil-sdd-ai check-update`.
  */
-async function checkUpdateHandler(event) {
-  const projectRoot = event.projectRoot || process.cwd();
-
+function runCheckUpdateCli(projectRoot) {
+  const { execFileSync, execSync } = require('child_process');
   const pkgRoot = resolveRefacilPackageRootForOpenCode(projectRoot);
-  if (pkgRoot) {
-    try {
-      const { syncRepoSessionMarkers } = require(path.join(pkgRoot, 'lib', 'session-repo-sync.js'));
-      const out = syncRepoSessionMarkers(projectRoot, pkgRoot);
-      if (out.compact && out.compact.status === 'error') {
-        process.stderr.write(`[refacil-sdd-ai] compact-guidance: ${out.compact.message}\n`);
-      }
-      if (out.testing && out.testing.status === 'error') {
-        process.stderr.write(`[refacil-sdd-ai] testing-policy: ${out.testing.message}\n`);
-      } else if (
-        out.testing &&
-        ['created-file', 'appended', 'replaced', 'written-empty'].includes(out.testing.status)
-      ) {
-        process.stderr.write(`[refacil-sdd-ai] testing-policy: ${out.testing.status} (.agents/testing.md)\n`);
-      }
-    } catch (err) {
-      process.stderr.write(`[refacil-sdd-ai] session repo sync: ${err.message}\n`);
-    }
-  }
+  const opts = {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    timeout: 120000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    // Mirror workspace into the same env vars Cursor/Claude hooks set (child-only).
+    env: {
+      ...process.env,
+      CURSOR_PROJECT_DIR: projectRoot,
+      CLAUDE_PROJECT_DIR: projectRoot,
+    },
+  };
 
-  // Check if there is a pending methodology migration
   try {
-    const migFn = loadMethodologyMigrationPending(projectRoot);
-    if (!migFn) return;
-    const mig = migFn(projectRoot);
-    const repoVersion = readRepoVersion(projectRoot);
-
-    // Try to get the current package version via refacil-sdd-ai CLI
-    let packageVersion = null;
-    try {
-      const { execSync } = require('child_process');
-      packageVersion = execSync('refacil-sdd-ai --version', {
-        encoding: 'utf8',
-        timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-    } catch (_) {}
-
-    const existingFlag = readPendingUpdateFlag(projectRoot);
-
-    if (mig.pending) {
-      writePendingUpdateFlag(projectRoot, repoVersion, packageVersion);
-    } else if (existingFlag) {
-      clearPendingUpdateFlag(projectRoot);
+    if (pkgRoot) {
+      const cliPath = path.join(pkgRoot, 'bin', 'cli.js');
+      const stdout = execFileSync(process.execPath, [cliPath, 'check-update'], opts);
+      if (stdout) process.stderr.write(String(stdout));
+      return;
     }
+    const stdout = execSync('refacil-sdd-ai check-update', { ...opts, shell: true });
+    if (stdout) process.stderr.write(String(stdout));
   } catch (err) {
-    process.stderr.write(`[refacil-sdd-ai] check-update handler error: ${err.message}\n`);
+    if (err.stdout) process.stderr.write(String(err.stdout));
+    if (err.stderr) process.stderr.write(String(err.stderr));
+    if (err.status !== undefined && err.status !== 0) {
+      process.stderr.write(`[refacil-sdd-ai] check-update exited with code ${err.status}\n`);
+    } else if (err.message) {
+      process.stderr.write(`[refacil-sdd-ai] check-update: ${err.message}\n`);
+    }
   }
 }
 
+// ── Hook handlers ────────────────────────────────────────────────────────────
+
+/**
+ * session.created — equivalent of check-update (SessionStart hook)
+ * Delegates to `refacil-sdd-ai check-update` for full parity (npm/skills sync, compact-guidance, CodeGraph reindex).
+ */
+async function checkUpdateHandler(event) {
+  const projectRoot = event.projectRoot || process.cwd();
+  runCheckUpdateCli(projectRoot);
+}
+
 /**
  * tui.prompt.append — equivalent of notify-update (UserPromptSubmit hook)
  * Returns an instruction string if there is a pending update, otherwise returns nothing.
@@ -224,7 +235,7 @@ async function notifyUpdateHandler(event) {
 
 /**
  * tool.execute.before — handles Bash tool calls:
- *   (a) check-review: blocks git push if any active change is missing .review-passed
+ *   (a) check-review: blocks git push if an active change has started implementation without .review-passed
  *   (b) compact-bash: rewrites matched commands to reduce token usage
  */
 async function toolExecuteBeforeHandler(event) {
@@ -236,41 +247,10 @@ async function toolExecuteBeforeHandler(event) {
 
   const projectRoot = event.projectRoot || process.cwd();
 
-  // (a) check-review: block git push if missing .review-passed
-  if (/git\s+push/.test(command)) {
-    const sddChangesDir = path.join(projectRoot, 'refacil-sdd', 'changes');
-    if (fs.existsSync(sddChangesDir)) {
-      let entries;
-      try {
-        entries = fs.readdirSync(sddChangesDir, { withFileTypes: true });
-      } catch (_) {
-        entries = [];
-      }
-
-      const activeChanges = entries.filter(
-        (e) => e.isDirectory() && e.name !== 'archive',
-      );
-
-      if (activeChanges.length > 0) {
-        const missing = activeChanges.filter(
-          (e) => !fs.existsSync(path.join(sddChangesDir, e.name, '.review-passed')),
-        );
-
-        if (missing.length > 0) {
-          const names = missing.map((e) => e.name).join(', ');
-          const reason =
-            missing.length === 1
-              ? `[refacil-sdd-ai] Review pending for: ${names}. ` +
-                'Stop the push and run /refacil:review on that change before pushing code. ' +
-                'If the review passes, retry the git push.'
-              : `[refacil-sdd-ai] Multiple changes without approved review: ${names}. ` +
-                'Stop the push and ask the user to explicitly select which change they want to push. ' +
-                'Then run /refacil:review <change-name> for that specific change and retry the push.';
-
-          throw new Error(reason);
-        }
-      }
-    }
+  // (a) check-review: same rules as refacil-sdd-ai check-review CLI (shared lib/check-review.js)
+  if (evaluateGitPushReview) {
+    const block = evaluateGitPushReview(command, projectRoot);
+    if (block) throw new Error(block.reason);
   }
 
   // (b) compact-bash: rewrite matched commands to reduce token usage

package/lib/opencode-plugin/rules.js

@@ -0,0 +1,236 @@
+function hasFlagAfterBase(cmd, baseTokens) {
+  const tokens = cmd.trim().split(/\s+/);
+  return tokens.slice(baseTokens).some((t) => t.startsWith('-'));
+}
+
+function hasPipeOrRedirect(cmd) {
+  return /[|><]/.test(cmd);
+}
+
+const RULES = [
+  // --- Fase 1: git / tests / docker logs ---
+  {
+    id: 'git-log',
+    match: (cmd) =>
+      /^\s*git\s+log(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) =>
+      /^\s*git\s+log(\s|$)/.test(cmd) &&
+      (/--oneline\b/.test(cmd) || /(^|\s)-\d+\b/.test(cmd)),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+log)/, '$1 --oneline -20'),
+    reason: 'git log → --oneline -20',
+    savedTokensEst: 850,
+  },
+  {
+    id: 'git-status',
+    match: (cmd) =>
+      /^\s*git\s+status(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) =>
+      /^\s*git\s+status(\s|$)/.test(cmd) &&
+      (/\s-s(\s|$)/.test(cmd) || /--short\b/.test(cmd)),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+status)/, '$1 -s'),
+    reason: 'git status → -s',
+    savedTokensEst: 120,
+  },
+  {
+    id: 'git-diff',
+    match: (cmd) => /^\s*git\s+diff\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*git\s+diff(\s|$)/.test(cmd) && /--stat\b/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+diff)\s*$/, '$1 --stat'),
+    reason: 'git diff → --stat',
+    savedTokensEst: 400,
+  },
+  {
+    id: 'git-show',
+    match: (cmd) =>
+      /^\s*git\s+show(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) => /^\s*git\s+show(\s|$)/.test(cmd) && /--stat\b/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+show)/, '$1 --stat'),
+    reason: 'git show → --stat',
+    savedTokensEst: 200,
+  },
+  {
+    id: 'docker-logs',
+    match: (cmd) => {
+      if (!/^\s*docker\s+logs(\s|$)/.test(cmd)) return false;
+      if (/\s--tail\b/.test(cmd)) return false;
+      if (/\s-n\s+\d/.test(cmd)) return false;
+      if (/\s--since\b/.test(cmd)) return false;
+      return true;
+    },
+    compactMatch: (cmd) =>
+      /^\s*docker\s+logs(\s|$)/.test(cmd) &&
+      (/\s--tail\b/.test(cmd) || /\s-n\s+\d/.test(cmd) || /\s--since\b/.test(cmd)),
+    rewrite: (cmd) => cmd.replace(/^(\s*docker\s+logs)/, '$1 --tail 100'),
+    reason: 'docker logs → --tail 100',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'pkg-test',
+    match: (cmd) => /^\s*(npm|yarn|pnpm)\s+(test|t)\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(npm|yarn|pnpm)\s+(test|t)\b/.test(cmd) &&
+      (hasPipeOrRedirect(cmd) || /--silent\b/.test(cmd) || /\b-q\b/.test(cmd)),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
+    reason: 'test bare → tail -80',
+    savedTokensEst: 2400,
+  },
+  {
+    id: 'jest-bare',
+    match: (cmd) => /^\s*(npx\s+)?jest\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?jest(\s|$)/.test(cmd) &&
+      (/--silent\b/.test(cmd) || /--reporters=summary\b/.test(cmd)),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*(?:npx\s+)?jest)\s*$/, '$1 --silent --reporters=summary'),
+    reason: 'jest → silent summary',
+    savedTokensEst: 1800,
+  },
+  {
+    id: 'pytest-bare',
+    match: (cmd) => /^\s*pytest\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*pytest(\s|$)/.test(cmd) && /(^|\s)-q(\s|$)/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*pytest)\s*$/, '$1 -q'),
+    reason: 'pytest → -q',
+    savedTokensEst: 600,
+  },
+  // --- Fase 2A: linters / type checkers / build ---
+  {
+    id: 'eslint',
+    match: (cmd) => /^\s*eslint(\s+[^-]\S*)*\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*eslint(\s|$)/.test(cmd) &&
+      (/--format\s+compact\b/.test(cmd) || /--quiet\b/.test(cmd)),
+    rewrite: (cmd) => {
+      const tokens = cmd.trim().split(/\s+/);
+      if (tokens.length === 1) {
+        return 'eslint . --format compact --quiet';
+      }
+      return `${cmd.trim()} --format compact`;
+    },
+    reason: 'eslint → --format compact',
+    savedTokensEst: 700,
+  },
+  {
+    id: 'biome-check',
+    match: (cmd) =>
+      /^\s*biome\s+check(\s|$)/.test(cmd) && !/--reporter\b/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*biome\s+check(\s|$)/.test(cmd) && /--reporter=summary\b/.test(cmd),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*biome\s+check)/, '$1 --reporter=summary'),
+    reason: 'biome check → --reporter=summary',
+    savedTokensEst: 500,
+  },
+  {
+    id: 'tsc',
+    match: (cmd) => {
+      if (!/^\s*(npx\s+)?tsc(\s|$)/.test(cmd)) return false;
+      if (/(^|\s)--watch\b|(^|\s)-w\b/.test(cmd)) return false;
+      if (hasPipeOrRedirect(cmd)) return false;
+      return true;
+    },
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?tsc(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | head -80`,
+    reason: 'tsc → head -80',
+    savedTokensEst: 1200,
+  },
+  {
+    id: 'prettier-check',
+    match: (cmd) =>
+      /^\s*prettier\s+--check\b/.test(cmd) && !/--loglevel\b/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*prettier\s+--check\b/.test(cmd) && /--loglevel\b/.test(cmd),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*prettier\s+--check)/, '$1 --loglevel warn'),
+    reason: 'prettier --check → --loglevel warn',
+    savedTokensEst: 300,
+  },
+  {
+    id: 'npm-audit',
+    match: (cmd) => /^\s*npm\s+audit\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*npm\s+audit(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -10`,
+    reason: 'npm audit → tail -10',
+    savedTokensEst: 900,
+  },
+  {
+    id: 'npm-ls',
+    match: (cmd) => /^\s*npm\s+ls\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*npm\s+ls(\s|$)/.test(cmd) && /--depth=0\b/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*npm\s+ls)/, '$1 --depth=0'),
+    reason: 'npm ls → --depth=0',
+    savedTokensEst: 700,
+  },
+  {
+    id: 'cargo-bare',
+    match: (cmd) => /^\s*cargo\s+(build|test|check)\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*cargo\s+(build|test|check)(\s|$)/.test(cmd) && /--quiet\b/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} --quiet`,
+    reason: 'cargo → --quiet',
+    savedTokensEst: 400,
+  },
+  {
+    id: 'go-test',
+    match: (cmd) => {
+      if (!/^\s*go\s+test\b/.test(cmd)) return false;
+      const rest = cmd.trim().substring('go test'.length);
+      if (/\s-\S/.test(rest)) return false;
+      if (hasPipeOrRedirect(cmd)) return false;
+      return true;
+    },
+    compactMatch: (cmd) => /^\s*go\s+test(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
+    reason: 'go test → tail -80',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'mvn-test',
+    match: (cmd) => /^\s*mvn\s+test\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*mvn\s+test(\s|$)/.test(cmd) && /(^|\s)-q(\s|$)/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} -q`,
+    reason: 'mvn test → -q',
+    savedTokensEst: 1800,
+  },
+  {
+    id: 'gradle-test',
+    match: (cmd) => /^\s*(\.\/gradlew|gradle)\s+test\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(\.\/gradlew|gradle)\s+test(\s|$)/.test(cmd) &&
+      /(^|\s)-q(\s|$)/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} -q`,
+    reason: 'gradle test → -q',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'ps-aux',
+    // Unix-only: en Windows `ps` mapea a PowerShell Get-Process y no entiende estos flags
+    match: (cmd) =>
+      process.platform !== 'win32' && /^\s*ps\s+aux\s*$/.test(cmd),
+    rewrite: () => 'ps -eo pid,pcpu,pmem,comm | head -30',
+    reason: 'ps aux → compact columns + head -30',
+    savedTokensEst: 800,
+  },
+];
+
+function findRule(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  if (/\bCOMPACT=0\b/.test(cmd)) return null;
+  for (const rule of RULES) {
+    if (rule.match(cmd)) return rule;
+  }
+  return null;
+}
+
+function findAlreadyCompactRule(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  for (const rule of RULES) {
+    if (typeof rule.compactMatch === 'function' && rule.compactMatch(cmd)) {
+      return rule;
+    }
+  }
+  return null;
+}
+
+module.exports = { RULES, findRule, findAlreadyCompactRule };