@ronaldjdevfs/forge 1.2.0 → 1.3.0-beta

package/skills/forge/scripts/forgeSmith.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { buildGraph } from "./graph.mjs";
+import { buildContext } from "./context.mjs";
+import { detectFeaturesOnSrc, allChecks } from "./detect.mjs";
+import { evaluateRules } from "./registry/rules.mjs";
+import {
+  CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM,
+} from "./formatter.mjs";
+import { writeAuditLog } from "./forgeSentinel-lib.mjs";
+
+const ROOT = process.cwd();
+
+const ALLOWED_EXTS = [".ts", ".mjs", ".js", ".tsx", ".jsx"];
+
+/**
+ * Parse Cursor preToolUse event from stdin.
+ * Cursor sends: { toolName, args: { filePath, content } }
+ */
+function parseCursorEvent(stdin) {
+  if (!stdin) return null;
+  try {
+    const event = JSON.parse(stdin);
+
+    // Cursor preToolUse format
+    if (event.toolName && event.args?.filePath) {
+      return { filePath: event.args.filePath, content: event.args.content || "" };
+    }
+
+    // Alternative: direct filePath + content
+    if (event.filePath && event.content !== undefined) {
+      return { filePath: event.filePath, content: event.content };
+    }
+
+    // Array of proposed edits
+    if (Array.isArray(event.edits)) {
+      return event.edits.map(e => ({
+        filePath: e.filePath || e.path || "",
+        content: e.content || e.newContent || "",
+      })).filter(e => e.filePath)[0] || null;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function isSourceFile(filePath) {
+  return filePath.startsWith("src/") && ALLOWED_EXTS.some(ext => filePath.endsWith(ext));
+}
+
+function hasCriticalViolations(result) {
+  return result.violations.some(v => v.severity === "CRITICAL" || v.severity === "ERROR");
+}
+
+/**
+ * Quick check against proposed content.
+ * Returns violations that would be introduced by the proposed content.
+ */
+async function checkProposedFile(filePath, content) {
+  if (!isSourceFile(filePath)) {
+    return { violations: [], total: 0, hasCritical: false, hasErrors: false };
+  }
+
+  const ctx = await buildContext();
+  const features = detectFeaturesOnSrc();
+  const graph = buildGraph(ROOT);
+  const results = allChecks(features, graph, ctx);
+
+  const violations = [];
+  for (const [, cat] of Object.entries(results)) {
+    for (const check of cat.checks) {
+      if (check.pass) continue;
+
+      const touchesFile = (check.detail && check.detail.includes(filePath)) ||
+                          (check.label && check.label.includes(filePath));
+
+      if (!touchesFile) continue;
+
+      violations.push(check);
+    }
+  }
+
+  const graphViolations = evaluateRules(graph, ctx).filter(v => {
+    return (v.file && v.file.includes(filePath)) ||
+           (v.from && v.from.includes(filePath)) ||
+           (v.to && v.to.includes(filePath));
+  });
+
+  const allViolations = [...violations, ...graphViolations];
+  const hasCritical = allViolations.some(v => v.severity === "CRITICAL");
+  const hasErrors = allViolations.some(v => v.severity === "ERROR");
+
+  return { violations: allViolations, total: allViolations.length, hasCritical, hasErrors };
+}
+
+function buildDenyPayload(result) {
+  const criticalCount = result.violations.filter(v => v.severity === "CRITICAL").length;
+  const errorCount = result.violations.filter(v => v.severity === "ERROR").length;
+
+  return {
+    deny: true,
+    severity: criticalCount > 0 ? "CRITICAL" : "ERROR",
+    message: `[forgeSmith] ⚠ ${result.total} violación(es) arquitectónica(s) (${criticalCount} CRITICAL, ${errorCount} ERROR). Corregí antes de escribir.`,
+    violations: result.violations.slice(0, 10).map(v => ({
+      severity: v.severity,
+      label: v.label,
+      rule: v.rule,
+      fix: v.fix,
+    })),
+  };
+}
+
+function buildAllowPayload() {
+  return { deny: false };
+}
+
+async function main() {
+  const chunks = [];
+  if (!process.stdin.isTTY) {
+    for await (const chunk of process.stdin) chunks.push(chunk);
+  }
+  const stdin = Buffer.concat(chunks).toString("utf-8");
+
+  if (!stdin) {
+    process.stdout.write(JSON.stringify(buildAllowPayload()));
+    process.exit(0);
+  }
+
+  const edit = parseCursorEvent(stdin);
+  if (!edit || !edit.filePath) {
+    process.stdout.write(JSON.stringify(buildAllowPayload()));
+    process.exit(0);
+  }
+
+  const result = await checkProposedFile(edit.filePath, edit.content || "");
+
+  writeAuditLog(process.env, {
+    ts: new Date().toISOString(),
+    hook: "forgeSmith",
+    file: edit.filePath,
+    total: result.total,
+    hasCritical: result.hasCritical,
+    hasErrors: result.hasErrors,
+  }, ROOT);
+
+  if (result.total > 0 && hasCriticalViolations(result)) {
+    process.stdout.write(JSON.stringify(buildDenyPayload(result)));
+  } else {
+    process.stdout.write(JSON.stringify(buildAllowPayload()));
+  }
+
+  process.exit(0);
+}
+
+if (process.argv[1]?.endsWith("forgeSmith.mjs")) {
+  main().catch(() => {
+    process.stdout.write(JSON.stringify({ deny: false }));
+    process.exit(0);
+  });
+}

package/skills/forge/scripts/pin.mjs

@@ -18,9 +18,16 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
-const HARNESS_DIRS = ['.claude', '.cursor', '.gemini', '.codex', '.agents', '.opencode', '.kiro'];
-
-const VALID_COMMANDS = ['forge', 'cast', 'inspect', 'quench', 'temper', 'chain', 'graph', 'relocate', 'reforge', 'smelt', 'inscribe'];
+const HARNESS_DIRS = [
+  '.claude', '.cursor', '.gemini', '.codex', '.agents',
+  '.opencode', '.kiro', '.rovodev', '.trae', '.trae-cn', '.pi',
+];
+
+const VALID_COMMANDS = [
+  'forge', 'cast', 'inspect', 'quench', 'temper', 'chain', 'graph',
+  'relocate', 'reforge', 'smelt', 'inscribe', 'armorer',
+  'assay', 'nail', 'unnail', 'hook', 'api', 'rollback', 'state',
+];
 
 const PIN_MARKER = '<!-- forge-pinned-skill -->';
 

package/skills/forge/scripts/posttool.mjs

@@ -1,224 +1,30 @@
 #!/usr/bin/env node
 
 /**
- * posttool.mjs — PostToolUse hook para Forge.
+ * posttool.mjs — DEPRECATED: Backward-compat wrapper.
  *
- * Se ejecuta después de que el agente escribe código. Analiza los archivos
- * modificados y reporta violaciones arquitectónicas.
+ * Use forgeSentinel.mjs en su lugar.
+ *   node forgeSentinel.mjs [options]
  *
- * Uso (CLI):
- *   node posttool.mjs                                    → analiza archivos changed en git
- *   node posttool.mjs <file1> [file2...]                 → analiza archivos específicos
- *   node posttool.mjs --diff                             → solo archivos changed vs default branch
- *   node posttool.mjs --json                             → salida JSON
- *   node posttool.mjs --strict                           → exit code 1 si hay CRITICAL/ERROR
- *   node posttool.mjs --reminder                         → solo recordatorio (no bloquea)
- *
- * Uso (API):
- *   import { postToolCheck } from "./posttool.mjs";
- *   const result = await postToolCheck([...files]);
- *
- * Integración en SKILL.md (Fase 7 del pipeline):
- *   node .opencode/skills/forge/scripts/posttool.mjs --reminder
+ * Este wrapper delega en forgeSentinel.mjs para mantener compatibilidad
+ * con scripts y referencias existentes.
  */
 
-import { readFileSync, existsSync, statSync, readdirSync } from "fs";
-import { join, relative, resolve, extname } from "path";
-import { execFileSync } from "child_process";
-import { buildGraph } from "./graph.mjs";
-import { buildContext } from "./context.mjs";
-import { detectFeaturesOnSrc, allChecks, loadAllInlineIgnores, isIgnored } from "./detect.mjs";
-import { evaluateRules } from "./registry/rules.mjs";
-import {
-  CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM, GRAY,
-  formatViolation, formatCheck, formatJson,
-} from "./formatter.mjs";
-
-const ROOT = process.cwd();
-
-function getChangedFiles() {
-  let files = [];
-  try {
-    const defaultBranch = execFileSync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] })
-      .trim().replace("refs/remotes/origin/", "");
-    const raw = execFileSync("git", ["diff", "--name-only", "--diff-filter=ACMR", `${defaultBranch}...HEAD`], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
-    files = raw.trim().split("\n").filter(Boolean);
-  } catch {}
-
-  if (files.length === 0) {
-    try {
-      const raw = execFileSync("git", ["status", "--porcelain"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
-      files = raw.split("\n").filter(Boolean).map(l => l.slice(3));
-    } catch {}
-  }
-
-  return files.filter(f => f.startsWith("src/"));
-}
-
-function readFile(path) {
-  try { return readFileSync(path, "utf-8"); } catch { return null; }
-}
-
-/**
- * Check modified files for violations.
- * Returns { violations, graphViolations, total, hasCritical, hasErrors, summary }
- */
-export async function postToolCheck(files, opts = {}) {
-  const { strict = false, reminder = false } = opts;
-
-  if (!files || files.length === 0) {
-    files = getChangedFiles();
-  }
-
-  // Only check source files
-  files = files.filter(f =>
-    f.endsWith(".ts") || f.endsWith(".mjs") || f.endsWith(".js") || f.endsWith(".tsx")
-  );
-
-  if (files.length === 0) {
-    return { violations: [], graphViolations: [], total: 0, hasCritical: false, hasErrors: false, filesChecked: 0, summary: "Sin archivos fuente modificados" };
-  }
-
-  // Build context and run full audit
-  const ctx = await buildContext();
-  const features = detectFeaturesOnSrc();
-  const graph = buildGraph(ROOT);
-  const results = allChecks(features, graph, ctx);
-
-  // Load inline ignores
-  const allIgnores = loadAllInlineIgnores(join(ROOT, "src"));
-
-  // Collect violations that touch the modified files
-  const violations = [];
-  for (const [, cat] of Object.entries(results)) {
-    for (const check of cat.checks) {
-      if (check.pass) continue;
-
-      // Only include violations touching modified files
-      const touchesFile = files.some(f =>
-        (check.detail && check.detail.includes(f)) ||
-        (check.label && check.label.includes(f))
-      );
-
-      if (!touchesFile && !reminder) continue;
-
-      // Check inline ignores
-      if (isIgnored(check, allIgnores)) continue;
-
-      violations.push(check);
-    }
-  }
-
-  // Also evaluate graph rules for changed files
-  const graphViolations = evaluateRules(graph, ctx).filter(v => {
-    const touchesFile = files.some(f =>
-      (v.file && v.file.includes(f)) ||
-      (v.from && v.from.includes(f)) ||
-      (v.to && v.to.includes(f))
-    );
-    return touchesFile || reminder;
-  });
-
-  const allViolations = [...violations, ...graphViolations];
-  const hasCritical = allViolations.some(v => v.severity === "CRITICAL");
-  const hasErrors = allViolations.some(v => v.severity === "ERROR");
-
-  return {
-    violations: allViolations,
-    total: allViolations.length,
-    hasCritical,
-    hasErrors,
-    filesChecked: files.length,
-    summary: hasCritical
-      ? `⚠ ${allViolations.length} violación(es) — ${allViolations.filter(v => v.severity === "CRITICAL").length} CRITICAL, ${allViolations.filter(v => v.severity === "ERROR").length} ERROR`
-      : hasErrors
-        ? `⚠ ${allViolations.length} violación(es) — ${allViolations.filter(v => v.severity === "ERROR").length} ERROR`
-        : `${allViolations.length} violación(es) menores (WARNING/INFO)`,
-  };
-}
-
-function printResult(result, opts = {}) {
-  const { reminder = false } = opts;
-
-  console.log(`\n${BOLD}${CYAN}═══ Forge PostTool Hook ═══${RESET}`);
-
-  if (result.total === 0) {
-    console.log(` ${GREEN}✔${RESET} Sin violaciones arquitectónicas en archivos modificados`);
-    console.log(` ${DIM}Archivos revisados: ${result.filesChecked}${RESET}\n`);
-    return;
-  }
-
-  console.log(` ${DIM}Archivos revisados: ${result.filesChecked}${RESET}`);
-  console.log(` ${DIM}Violaciones: ${result.total}${RESET}\n`);
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 
-  if (reminder) {
-    console.log(`  ${YELLOW}Recordatorio:${RESET} Los archivos modificados tienen ${result.total} violación(es) arquitectónica(s).`);
-    console.log(`  Ejecuta ${CYAN}forge quench${RESET} para ver el detalle completo.\n`);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
-    if (result.hasCritical) {
-      const criticalCount = result.violations.filter(v => v.severity === "CRITICAL").length;
-      console.log(`  ${RED}⚠ ${criticalCount} violación(es) CRITICAL detectadas${RESET}`);
-    }
-    if (result.hasErrors) {
-      const errorCount = result.violations.filter(v => v.severity === "ERROR").length;
-      console.log(`  ${RED}⚠ ${errorCount} violación(es) ERROR detectadas${RESET}`);
-    }
-
-    // Print first 5 violations as summary
-    const toShow = result.violations.slice(0, 5);
-    for (const v of toShow) {
-      console.log(formatCheck(v));
-    }
-    if (result.violations.length > 5) {
-      console.log(`  ${DIM}... y ${result.violations.length - 5} más${RESET}`);
-    }
-    console.log();
-    return;
-  }
+// Re-export for backward compat
+export { runSentinelCheck as postToolCheck } from "./forgeSentinel-lib.mjs";
 
-  // Full output
-  for (const v of result.violations) {
-    console.log(formatCheck(v));
-  }
-
-  console.log(`\n  ${BOLD}Resumen:${RESET} ${result.summary}`);
-  if (result.hasCritical) {
-    console.log(`  ${RED}⚠ Se requiere acción correctiva antes de continuar${RESET}`);
-  }
-  console.log();
-}
-
-async function main() {
+if (process.argv[1]?.endsWith("posttool.mjs")) {
+  const forgeSentinel = join(__dirname, "forgeSentinel.mjs");
   const args = process.argv.slice(2);
-  const isJson = args.includes("--json");
-  const strict = args.includes("--strict");
-  const reminder = args.includes("--reminder");
-  const isDiff = args.includes("--diff");
-
-  let files;
-  if (isDiff) {
-    files = getChangedFiles();
-  } else {
-    // Files passed as arguments
-    files = args.filter(a => !a.startsWith("--"));
-    if (files.length === 0) {
-      files = getChangedFiles();
-    }
-  }
-
-  const result = await postToolCheck(files, { strict, reminder });
-
-  if (isJson) {
-    console.log(formatJson(result));
-  } else {
-    printResult(result, { reminder });
-  }
-
-  if (strict && (result.hasCritical || result.hasErrors)) {
-    process.exit(1);
+  const { execFileSync } = await import("child_process");
+  try {
+    execFileSync(process.execPath, [forgeSentinel, ...args], { stdio: "inherit" });
+  } catch {
+    process.exit(0);
   }
 }
-
-if (process.argv[1]?.endsWith("posttool.mjs")) {
-  main().catch(console.error);
-}