@ronaldjdevfs/forge 1.0.1 → 1.1.0

package/skills/forge/scripts/forge-signals.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { loadConfig, loadState } from "./forge-config.mjs";
+
+const ROOT = process.cwd();
+
+function gitSignals(cwd) {
+  const run = (args, { trim = true } = {}) => {
+    try {
+      const out = execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      return trim ? out.trim() : out;
+    } catch {
+      return null;
+    }
+  };
+
+  const branch = run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const defaultBranch = run(["symbolic-ref", "refs/remotes/origin/HEAD"])?.replace("refs/remotes/origin/", "") || "main";
+  const topLevel = run(["rev-parse", "--show-toplevel"]);
+
+  let changedFiles = [];
+  try {
+    const raw = run(["diff", "--name-only", "--diff-filter=ACMR", `${defaultBranch}...HEAD`], { trim: false });
+    if (raw) changedFiles = raw.split("\n").filter(Boolean);
+  } catch {
+    // fallback to working tree
+    try {
+      const raw = run(["status", "--porcelain"]);
+      if (raw) changedFiles = raw.split("\n").filter(Boolean).map(l => l.slice(3));
+    } catch {}
+  }
+
+  return {
+    branch: branch ?? "unknown",
+    defaultBranch,
+    changedFiles,
+    hasChanges: changedFiles.length > 0,
+    isRepo: branch !== null,
+    topLevel,
+  };
+}
+
+function contextSignals(cwd) {
+  const config = loadConfig();
+  const state = loadState();
+
+  const hasFeatures = existsSync(join(cwd, "src", "features"));
+  const hasPlatform = existsSync(join(cwd, "src", "platform"));
+  const hasShared = existsSync(join(cwd, "src", "shared"));
+  const hasInfra = existsSync(join(cwd, "src", "infra"));
+  const hasLegacy = existsSync(join(cwd, "src", "application")) || existsSync(join(cwd, "src", "adapters", "in", "http", "controllers"));
+
+  return {
+    setup: {
+      hasFeatures,
+      hasPlatform,
+      hasShared,
+      hasInfra,
+      hasLegacy,
+      hasSrc: existsSync(join(cwd, "src")),
+      hasPackageJson: existsSync(join(cwd, "package.json")),
+    },
+    config: {
+      exists: !!config.profile,
+      profile: config.profile,
+      framework: config.framework,
+      needsRefresh: config.lastContextUpdate ? (Date.now() - new Date(config.lastContextUpdate).getTime()) / 86400000 > 7 : true,
+    },
+    audit: {
+      lastScore: state.lastScore,
+      lastGrade: state.lastGrade,
+      lastAudit: state.lastAudit,
+      violationCount: state.violationCount,
+      health: state.health,
+      totalFeatures: state.totalFeatures,
+      migratedFeatures: state.migratedFeatures,
+      legacyFeatures: state.legacyFeatures,
+      hasAudit: !!state.lastAudit,
+    },
+  };
+}
+
+function buildSignals(cwd) {
+  const signals = {};
+
+  // Check tsconfig exists
+  signals.hasTsConfig = existsSync(join(cwd, "tsconfig.json"));
+
+  // Check for common build artifacts
+  signals.hasDist = existsSync(join(cwd, "dist"));
+  signals.hasNext = existsSync(join(cwd, ".next"));
+
+  return signals;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+  const isMinimal = args.includes("--minimal");
+
+  const git = gitSignals(ROOT);
+  const ctx = contextSignals(ROOT);
+  const build = buildSignals(ROOT);
+
+  const signals = { git, context: ctx, build };
+
+  if (isJson) {
+    console.log(JSON.stringify(signals, null, 2));
+  } else if (isMinimal) {
+    const lines = [];
+    if (git.branch) lines.push(`Branch: ${git.branch}`);
+    if (git.hasChanges) lines.push(`Cambios: ${git.changedFiles.length} archivos`);
+    if (ctx.audit.hasAudit) lines.push(`Score: ${ctx.audit.lastGrade} (${ctx.audit.lastScore})`);
+    if (!ctx.setup.hasFeatures) lines.push("⚠ Sin src/features/");
+    if (ctx.config.needsRefresh) lines.push("⚠ Config necesita refresco");
+    lines.push(`Features: ${ctx.audit.migratedFeatures} migrados + ${ctx.audit.legacyFeatures} legacy = ${ctx.audit.totalFeatures} total`);
+    console.log(lines.join(" | "));
+  } else {
+    console.log("── Forge Signals ──");
+    console.log(`Git: ${git.branch} (${git.changedFiles.length} cambios)`);
+    console.log(`Audit: ${ctx.audit.lastGrade ?? "—"} (${ctx.audit.lastScore ?? "—"}) — ${ctx.audit.health}`);
+    console.log(`Features: ${ctx.audit.totalFeatures} total (${ctx.audit.migratedFeatures} migrados, ${ctx.audit.legacyFeatures} legacy)`);
+    console.log(`Layers: platform=${ctx.setup.hasPlatform} shared=${ctx.setup.hasShared} infra=${ctx.setup.hasInfra}`);
+    console.log(`Config: ${ctx.config.profile ?? "pendiente"} | Refresh: ${ctx.config.needsRefresh ? "necesario" : "ok"}`);
+  }
+}
+
+main().catch(console.error);

package/skills/forge/scripts/forge-state.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * forge-state.mjs — Wrapper de estado post-auditoría.
+ *
+ * Delega toda la lógica de persistencia en forge-config.mjs.
+ * Existe como CLI independiente para compatibilidad con SKILL.md
+ * y comandos ad-hoc.
+ *
+ * Uso:
+ *   node forge-state.mjs --show
+ *   node forge-state.mjs --save <score> <grade> <violations> <features> [migrated]
+ *   node forge-state.mjs --history
+ *   node forge-state.mjs --json
+ */
+
+import { loadState, saveState, saveHistory, loadHistory, displayTrend } from "./forge-config.mjs";
+import { existsSync } from "fs";
+import { join } from "path";
+
+const ROOT = process.cwd();
+
+async function main() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+
+  if (args.includes("--show")) {
+    const state = loadState();
+    if (isJson) {
+      console.log(JSON.stringify(state, null, 2));
+    } else {
+      console.log("── Forge State ──");
+      for (const [k, v] of Object.entries(state)) {
+        console.log(`  ${k}: ${v ?? "(sin datos)"}`);
+      }
+    }
+    process.exit(0);
+  }
+
+  if (args.includes("--save")) {
+    const scoreIdx = args.indexOf("--save") + 1;
+    const score = parseInt(args[scoreIdx], 10);
+    const grade = args[scoreIdx + 1] || "—";
+    const violations = parseInt(args[scoreIdx + 2] || "0", 10);
+    const features = parseInt(args[scoreIdx + 3] || "0", 10);
+    const migrated = parseInt(args[scoreIdx + 4] || "0", 10);
+    const platform = args.includes("--platform");
+
+    const state = {
+      lastAudit: new Date().toISOString(),
+      lastScore: isNaN(score) ? null : score,
+      lastGrade: grade,
+      violationCount: isNaN(violations) ? 0 : violations,
+      totalFeatures: isNaN(features) ? 0 : features,
+      migratedFeatures: isNaN(migrated) ? 0 : migrated,
+      legacyFeatures: isNaN(features) ? 0 : features - (isNaN(migrated) ? 0 : migrated),
+      platformExists: platform || existsSync(join(ROOT, "src", "platform")),
+      health: score >= 80 ? "healthy" : score >= 50 ? "fair" : "poor",
+    };
+
+    saveState(state);
+    saveHistory({ score, grade, violationCount: state.violationCount, totalFeatures: features, migratedFeatures: migrated });
+
+    if (isJson) {
+      console.log(JSON.stringify({ saved: true, state }, null, 2));
+    } else {
+      console.log(`forge-state: estado guardado (score: ${score}, grade: ${grade})`);
+    }
+    process.exit(0);
+  }
+
+  if (args.includes("--history")) {
+    const entries = loadHistory(isJson ? 999 : 20);
+    if (isJson) {
+      console.log(JSON.stringify(entries, null, 2));
+    } else {
+      displayTrend(entries);
+    }
+    process.exit(0);
+  }
+
+  // Default: show
+  const state = loadState();
+  const history = loadHistory(1);
+  if (isJson) {
+    console.log(JSON.stringify({ state, recentHistory: history }, null, 2));
+  } else {
+    const lastScore = state.lastScore !== null ? `${state.lastScore}/110` : "—";
+    const lastGrade = state.lastGrade || "—";
+    console.log(`Forge State | Score: ${lastScore} | Grade: ${lastGrade} | Violaciones: ${state.violationCount} | Features: ${state.migratedFeatures}/${state.totalFeatures}`);
+  }
+  process.exit(0);
+}
+
+if (process.argv[1] && (process.argv[1].endsWith("forge-state.mjs") || process.argv[1].endsWith("forge-state.js"))) {
+  main().catch(console.error);
+}

package/skills/forge/scripts/formatter.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+export const CYAN = "\x1b[36m";
+export const GREEN = "\x1b[32m";
+export const RED = "\x1b[31m";
+export const YELLOW = "\x1b[33m";
+export const BOLD = "\x1b[1m";
+export const RESET = "\x1b[0m";
+export const DIM = "\x1b[2m";
+export const GRAY = "\x1b[90m";
+
+export const SEVERITY_COLORS = {
+  CRITICAL: RED,
+  ERROR: RED,
+  WARNING: YELLOW,
+  INFO: CYAN,
+  SUGGESTION: GRAY,
+};
+
+export function col(sev) {
+  return SEVERITY_COLORS[sev] || RESET;
+}
+
+export function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+export function formatTable(rows, columns) {
+  const colWidths = columns.map((col, i) => {
+    const header = col.label || col;
+    const maxVal = Math.max(header.length, ...rows.map(r => String(r[col.key || col] || "").length));
+    return maxVal;
+  });
+
+  const line = (parts) => {
+    const inner = parts.map((p, i) => String(p).padEnd(colWidths[i])).join(" │ ");
+    return ` ${inner} `;
+  };
+
+  const sep = () => "─" + colWidths.map(w => "─".repeat(w)).join("─┼─") + "─";
+
+  const out = [];
+  out.push(line(columns.map(c => c.label || c)));
+  out.push(sep());
+  for (const row of rows) {
+    out.push(line(columns.map(c => String(row[c.key || c] ?? ""))));
+  }
+  return out.join("\n");
+}
+
+export function formatViolation({ severity, label, detail, fix }, _opts = {}) {
+  const color = col(severity);
+  const parts = [`${color}[${severity}]${RESET} ${label}`];
+  if (detail) parts.push(` ${GRAY}— ${detail}${RESET}`);
+  if (fix) parts.push(`\n     ${DIM}→ Fix: ${fix}${RESET}`);
+  return parts.join("");
+}
+
+export function formatCheck(check, opts = {}) {
+  const icon = check.pass ? `${GREEN}✔${RESET}` : `${RED}✘${RESET}`;
+  const sev = check.pass ? "" : ` ${col(check.severity)}[${check.severity}]${RESET}`;
+  const detail = check.detail ? ` ${GRAY}— ${check.detail}${RESET}` : "";
+  let out = `   ${icon}${sev} ${check.label}${detail}`;
+  if (!check.pass && check.fix && opts.showFixes !== false) {
+    out += `\n     ${DIM}→ Fix: ${check.fix}${RESET}`;
+  }
+  return out;
+}
+
+export function scoreBar(score, max, barLen = 40) {
+  const p = max > 0 ? Math.round((score / max) * barLen) : 0;
+  const filled = "█".repeat(p);
+  const empty = "░".repeat(barLen - p);
+  const color = score >= max * 0.8 ? GREEN : score >= max * 0.5 ? YELLOW : RED;
+  return `${color}${filled}${RESET}${DIM}${empty}${RESET}`;
+}
+
+export function formatReport(report, opts = {}) {
+  const { total, max, categories, violations, recommendations, severityCounts } = report;
+  const barLen = opts.barLen || 40;
+  const pct = max > 0 ? Math.round((total / max) * 100) : 0;
+  const lines = [];
+
+  const grade = pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F";
+  const gradeColor = pct >= 80 ? GREEN : pct >= 50 ? YELLOW : RED;
+
+  lines.push(`\n${BOLD}Puntaje total: ${gradeColor}${total}/${max} (${pct}%) — ${grade}${RESET}\n`);
+
+  if (Object.keys(severityCounts || {}).length > 0) {
+    lines.push(`  ${BOLD}Resumen por severidad${RESET}`);
+    for (const [sev, count] of Object.entries(severityCounts)) {
+      lines.push(`   ${col(sev)}${sev}${RESET}: ${count}`);
+    }
+    lines.push("");
+  }
+
+  for (const [key, cat] of Object.entries(categories || {})) {
+    const cmax = opts.catMax?.[key] || cat.max || 10;
+    const name = opts.catNames?.[key] || key;
+    lines.push(`  ${BOLD}${name} (${cat.score}/${cmax})${RESET}`);
+    lines.push(`  ${scoreBar(cat.score, cmax, barLen)}`);
+    for (const check of cat.checks) {
+      lines.push(formatCheck(check, opts));
+    }
+    lines.push("");
+  }
+
+  if (recommendations && recommendations.length > 0) {
+    lines.push(`  ${BOLD}${YELLOW}Recomendaciones${RESET}`);
+    const unique = [...new Set(recommendations)];
+    unique.forEach((r, i) => lines.push(`   ${i + 1}. ${r}`));
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function printViolations(violations) {
+  for (const v of violations) {
+    console.log(formatViolation(v));
+  }
+}
+
+if (process.argv[1]?.endsWith("formatter.mjs")) {
+  const args = process.argv.slice(2);
+  if (args.includes("--test")) {
+    console.log(formatViolation({ severity: "ERROR", label: "Test violation", detail: "src/test.ts:42", fix: "Do something" }));
+    console.log(formatCheck({ severity: "WARNING", label: "Test check", pass: false, detail: "detail", fix: "fix it" }));
+    console.log(formatCheck({ severity: "INFO", label: "Passing check", pass: true }));
+    console.log(scoreBar(15, 20));
+    console.log(formatJson({ test: true, items: [1, 2, 3] }));
+  }
+}

package/skills/forge/scripts/graph.mjs

@@ -2,12 +2,11 @@
 
 import { join, relative, dirname, basename } from "path";
 import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { parseImportPaths } from "./parse-imports.mjs";
 
 const ROOT = process.cwd();
 const SRC = join(ROOT, "src");
 
-const IMPORT_RE = /import\s+(?:type\s+)?(?:\{[^}]*\}|[^;{]+)\s+from\s+['"]([^'"]+)['"]/g;
-
 const INFRA_PACKAGES = {
   "prisma": "infra:prisma",
   "@prisma/client": "infra:prisma",
@@ -66,21 +65,6 @@ function findFiles(dir, exts, maxDepth = 6) {
   return results;
 }
 
-function parseImports(content) {
-  const imports = [];
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const m = lines[i].match(IMPORT_RE);
-    if (m) {
-      for (const full of m) {
-        const src = full.match(/from\s+['"]([^'"]+)['"]/);
-        if (src) imports.push(src[1]);
-      }
-    }
-  }
-  return imports;
-}
-
 function classifyPath(relPath) {
   const parts = relPath.split("/");
   if (parts.includes("platform")) return "platform";
@@ -264,9 +248,9 @@ export function buildGraph(projectRoot = ROOT) {
 
   /* 6a. Detect used infra packages first */
   const usedPackages = new Set();
-  for (const { content } of fileContents) {
-    const imports = parseImports(content);
-    for (const imp of imports) {
+  for (const { file: filePath, content } of fileContents) {
+    const gImports = parseImportPaths(content, filePath);
+    for (const imp of gImports) {
       for (const [pkg, id] of Object.entries(INFRA_PACKAGES)) {
         if (imp === pkg || imp.startsWith(pkg + "/")) usedPackages.add(id);
       }
@@ -321,7 +305,7 @@ export function buildGraph(projectRoot = ROOT) {
 
     if (!sourceId || !idSet.has(sourceId)) continue;
 
-    const imports = parseImports(content);
+    const gImports = parseImportPaths(content, filePath);
     const seenTargets = new Set();
 
     for (const imp of imports) {

package/skills/forge/scripts/hook.mjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+/**
+ * hook.mjs — Git pre-commit hook para validación arquitectónica.
+ *
+ * Instala/uninstall un hook de git pre-commit que ejecuta forge detect
+ * sobre los archivos staged y bloquea el commit si hay violaciones CRITICAL
+ * o ERROR en los archivos tocados.
+ *
+ * Uso:
+ *   node hook.mjs install              → Instalar hook pre-commit
+ *   node hook.mjs uninstall            → Eliminar hook pre-commit
+ *   node hook.mjs status               → Mostrar estado del hook
+ *   node hook.mjs check                → Ejecutar validación sobre staged files
+ *   node hook.mjs ignore <rule-id>     → Ignorar regla específica
+ *   node hook.mjs unignore <rule-id>   → Dejar de ignorar regla
+ *   node hook.mjs list-ignored         → Listar reglas ignoradas
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "fs";
+import { join, relative, resolve } from "path";
+import { execFileSync } from "child_process";
+
+const ROOT = process.cwd();
+const HOOKS_DIR = join(ROOT, ".git", "hooks");
+const HOOK_PATH = join(HOOKS_DIR, "pre-commit");
+const IGNORE_PATH = join(ROOT, ".forge", "hooks-ignore.json");
+const SCRIPT_DIR = new URL(".", import.meta.url).pathname;
+
+const HOOK_TEMPLATE = `#!/bin/sh
+# forge pre-commit hook — valida arquitectura antes de cada commit
+# Instalado por: node .opencode/skills/forge/scripts/hook.mjs install
+
+FORGE_SCRIPTS="${SCRIPT_DIR}"
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACMR -- "*.ts" "*.js" "*.mjs" "*.tsx" "*.jsx" 2>/dev/null)
+
+if [ -z "$STAGED_FILES" ]; then
+  exit 0
+fi
+
+# Ejecutar detect sobre los archivos staged
+node "$FORGE_SCRIPTS/hook.mjs" check
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+  echo ""
+  echo "✘ [forge] Commit bloqueado por violaciones arquitectónicas."
+  echo "  Para ignorar: node .opencode/skills/forge/scripts/hook.mjs ignore <rule-id>"
+  echo "  Para saltar: git commit --no-verify"
+  exit 1
+fi
+
+exit 0
+`;
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, "utf-8")); } catch { return null; }
+}
+
+function writeJson(path, data) {
+  try {
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    return true;
+  } catch { return false; }
+}
+
+function shell(cmd, args, opts = {}) {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], ...opts }).trim();
+  } catch { return ""; }
+}
+
+function getStagedFiles() {
+  const raw = shell("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR", "--", "*.ts", "*.js", "*.mjs", "*.tsx", "*.jsx"]);
+  return raw ? raw.split("\n").filter(Boolean) : [];
+}
+
+function isGitRepo() {
+  return shell("git", ["rev-parse", "--git-dir"]) !== "";
+}
+
+function loadIgnored() {
+  const data = readJson(IGNORE_PATH);
+  return Array.isArray(data?.ignored) ? data.ignored : [];
+}
+
+function saveIgnored(ignored) {
+  return writeJson(IGNORE_PATH, { ignored });
+}
+
+function hookInstalled() {
+  if (!existsSync(HOOK_PATH)) return false;
+  const content = readFileSync(HOOK_PATH, "utf-8");
+  return content.includes("# forge pre-commit hook");
+}
+
+// ── Actions ──
+
+function cmdInstall() {
+  if (!isGitRepo()) {
+    console.error("forge-hooks: no es un repositorio git");
+    process.exit(1);
+  }
+
+  if (hookInstalled()) {
+    console.log("forge-hooks: pre-commit hook ya instalado en .git/hooks/pre-commit");
+    process.exit(0);
+  }
+
+  mkdirSync(HOOKS_DIR, { recursive: true });
+  writeFileSync(HOOK_PATH, HOOK_TEMPLATE, { mode: 0o755 });
+  console.log("forge-hooks: pre-commit hook instalado en .git/hooks/pre-commit");
+}
+
+function cmdUninstall() {
+  if (!existsSync(HOOK_PATH)) {
+    console.log("forge-hooks: no hay hook pre-commit instalado");
+    process.exit(0);
+  }
+
+  rmSync(HOOK_PATH, { force: true });
+  console.log("forge-hooks: pre-commit hook eliminado");
+}
+
+function cmdStatus() {
+  const installed = hookInstalled();
+  const ignored = loadIgnored();
+  console.log("── Forge Hooks ──");
+  console.log(`  Pre-commit hook: ${installed ? "✓ instalado" : "✘ no instalado"}`);
+  console.log(`  Reglas ignoradas: ${ignored.length > 0 ? ignored.join(", ") : "(ninguna)"}`);
+  console.log(`  Hook path: ${HOOK_PATH}`);
+  console.log(`  Ignore file: ${IGNORE_PATH}`);
+}
+
+async function cmdCheck() {
+  if (!isGitRepo()) {
+    console.error("forge-hooks: no es un repositorio git");
+    process.exit(1);
+  }
+
+  const stagedFiles = getStagedFiles();
+  if (stagedFiles.length === 0) {
+    process.exit(0);
+  }
+
+  const ignored = loadIgnored();
+  const srcFiles = stagedFiles.filter(f => f.startsWith("src/"));
+  if (srcFiles.length === 0) process.exit(0);
+
+  // Run detect only over the staged source files
+  const { allChecks, detectFeaturesOnSrc } = await import("./detect.mjs");
+  const { buildGraph } = await import("./graph.mjs");
+  const { buildContext } = await import("./context.mjs");
+
+  const ctx = await buildContext();
+  const graph = buildGraph(ROOT);
+  const features = detectFeaturesOnSrc();
+  const results = allChecks(features, graph, ctx);
+
+  let violations = [];
+  for (const [, cat] of Object.entries(results)) {
+    for (const check of cat.checks) {
+      if (!check.pass && (check.severity === "CRITICAL" || check.severity === "ERROR")) {
+        // Check if this violation touches a staged file
+        const touchesStaged = !check.detail || srcFiles.some(sf => check.detail.includes(sf) || check.label.includes(sf));
+        if (touchesStaged) {
+          // Check if rule is ignored
+          const ruleMatch = check.label.match(/\[([^\]]+)\]/);
+          const ruleId = ruleMatch ? ruleMatch[1] : null;
+          if (!ruleId || !ignored.includes(ruleId)) {
+            violations.push(check);
+          }
+        }
+      }
+    }
+  }
+
+  if (violations.length > 0) {
+    console.log(`\n✘ [forge-hooks] ${violations.length} violacion(es) CRITICAL/ERROR bloquean el commit:\n`);
+    for (const v of violations) {
+      console.log(`  [${v.severity}] ${v.label}`);
+      if (v.fix) console.log(`       → Fix: ${v.fix}`);
+    }
+    console.log(`\n  Para ignorar: node .opencode/skills/forge/scripts/hook.mjs ignore <rule-id>`);
+    console.log(`  Para saltar: git commit --no-verify\n`);
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+function cmdIgnore(ruleId) {
+  if (!ruleId) {
+    console.error("Uso: node hook.mjs ignore <rule-id>");
+    process.exit(1);
+  }
+  const ignored = loadIgnored();
+  if (ignored.includes(ruleId)) {
+    console.log(`forge-hooks: regla "${ruleId}" ya está ignorada`);
+  } else {
+    ignored.push(ruleId);
+    saveIgnored(ignored);
+    console.log(`forge-hooks: regla "${ruleId}" añadida a ignorados`);
+  }
+}
+
+function cmdUnignore(ruleId) {
+  if (!ruleId) {
+    console.error("Uso: node hook.mjs unignore <rule-id>");
+    process.exit(1);
+  }
+  const ignored = loadIgnored().filter(r => r !== ruleId);
+  saveIgnored(ignored);
+  console.log(`forge-hooks: regla "${ruleId}" eliminada de ignorados`);
+}
+
+function cmdListIgnored() {
+  const ignored = loadIgnored();
+  if (ignored.length === 0) {
+    console.log("forge-hooks: no hay reglas ignoradas");
+  } else {
+    console.log("── Reglas ignoradas ──");
+    for (const r of ignored) console.log(`  ${r}`);
+  }
+}
+
+// ── CLI ──
+
+const [,, action, arg] = process.argv;
+
+switch (action) {
+  case "install":    cmdInstall(); break;
+  case "uninstall":  cmdUninstall(); break;
+  case "status":     cmdStatus(); break;
+  case "check":      await cmdCheck(); break;
+  case "ignore":     cmdIgnore(arg); break;
+  case "unignore":   cmdUnignore(arg); break;
+  case "list-ignored": cmdListIgnored(); break;
+  default:
+    console.log("Uso: node hook.mjs <install|uninstall|status|check|ignore|unignore|list-ignored>");
+    console.log("\n  install           → Instalar hook pre-commit");
+    console.log("  uninstall         → Eliminar hook pre-commit");
+    console.log("  status            → Mostrar estado del hook");
+    console.log("  check             → Validar archivos staged");
+    console.log("  ignore <rule-id>  → Ignorar regla específica");
+    console.log("  unignore <rule-id>→ Dejar de ignorar regla");
+    console.log("  list-ignored      → Listar reglas ignoradas");
+    process.exit(1);
+}