@ronaldjdevfs/forge 1.2.0 → 1.3.1

package/skills/forge/scripts/forgeSmith-admin.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+
+const ROOT = process.cwd();
+const FORGE_DIR = join(ROOT, ".forge");
+const CONFIG_PATH = join(FORGE_DIR, "hooks-config.json");
+const AUDIT_DIR = join(FORGE_DIR, "audit");
+
+const DEFAULT_CONFIG = {
+  forgeSentinel: { enabled: true },
+  forgeSmith: { enabled: true },
+};
+
+function readConfig() {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      const data = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      return { ...DEFAULT_CONFIG, ...data };
+    }
+  } catch {}
+  return { ...DEFAULT_CONFIG };
+}
+
+function writeConfig(config) {
+  mkdirSync(FORGE_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+function cmdStatus() {
+  const config = readConfig();
+  const auditPath = join(AUDIT_DIR, "forgeSentinel.json");
+  let lastRun = null;
+  try {
+    if (existsSync(auditPath)) {
+      const log = JSON.parse(readFileSync(auditPath, "utf-8"));
+      if (Array.isArray(log) && log.length > 0) {
+        lastRun = log[log.length - 1];
+      }
+    }
+  } catch {}
+
+  console.log("── forgeSmith-admin ──");
+  console.log(`  forgeSentinel (PostToolUse): ${config.forgeSentinel.enabled ? "✓ activo" : "✘ inactivo"}`);
+  console.log(`  forgeSmith (preToolUse):     ${config.forgeSmith.enabled ? "✓ activo" : "✘ inactivo"}`);
+  if (lastRun) {
+    console.log(`  Último forgeSentinel: ${lastRun.ts} (${lastRun.filesChecked || 0} archivos, ${lastRun.total || 0} violaciones)`);
+  }
+  console.log(`  Config: ${CONFIG_PATH}`);
+}
+
+function cmdOn(hookName) {
+  const config = readConfig();
+  if (hookName === "all" || hookName === "forgeSentinel") {
+    config.forgeSentinel.enabled = true;
+  }
+  if (hookName === "all" || hookName === "forgeSmith") {
+    config.forgeSmith.enabled = true;
+  }
+  writeConfig(config);
+  console.log(`forgeSmith-admin: hooks activados (${hookName})`);
+}
+
+function cmdOff(hookName) {
+  const config = readConfig();
+  if (hookName === "all" || hookName === "forgeSentinel") {
+    config.forgeSentinel.enabled = false;
+  }
+  if (hookName === "all" || hookName === "forgeSmith") {
+    config.forgeSmith.enabled = false;
+  }
+  writeConfig(config);
+  console.log(`forgeSmith-admin: hooks desactivados (${hookName})`);
+}
+
+function cmdReset() {
+  writeConfig(DEFAULT_CONFIG);
+  console.log("forgeSmith-admin: configuración restaurada a valores por defecto");
+}
+
+const [,, action, arg] = process.argv;
+
+switch (action) {
+  case "status":
+    cmdStatus();
+    break;
+  case "on":
+    cmdOn(arg || "all");
+    break;
+  case "off":
+    cmdOff(arg || "all");
+    break;
+  case "reset":
+    cmdReset();
+    break;
+  default:
+    console.log("Uso: node forgeSmith-admin.mjs <status|on|off|reset> [hook-name]");
+    console.log("\n  status              Mostrar estado de hooks");
+    console.log("  on [forgeSentinel|forgeSmith|all]  Activar hook(s)");
+    console.log("  off [forgeSentinel|forgeSmith|all] Desactivar hook(s)");
+    console.log("  reset               Restaurar configuración por defecto");
+    process.exit(1);
+}

package/skills/forge/scripts/forgeSmith.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { getGraph } 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 = ctx.graph || getGraph();
+  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/graph.mjs

@@ -3,6 +3,7 @@
 import { join, relative, dirname, basename } from "path";
 import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { parseImportPaths } from "./parse-imports.mjs";
+import { saveCache, loadCache } from "./forge-config.mjs";
 
 const ROOT = process.cwd();
 const SRC = join(ROOT, "src");
@@ -308,7 +309,7 @@ export function buildGraph(projectRoot = ROOT) {
     const gImports = parseImportPaths(content, filePath);
     const seenTargets = new Set();
 
-    for (const imp of imports) {
+    for (const imp of gImports) {
       let targetId = resolveNodeId(imp, featureMap);
 
       if (!targetId) {
@@ -421,7 +422,7 @@ export function buildGraph(projectRoot = ROOT) {
     if (directedEdges[e.from]) directedEdges[e.from].push(e.to);
   }
 
-  let hasCycle = false;
+  let hasCycles = false;
   function dfs(node, visited, stack) {
     if (stack.has(node)) return true;
     if (visited.has(node)) return false;
@@ -436,20 +437,28 @@ export function buildGraph(projectRoot = ROOT) {
 
   const visited = new Set();
   for (const n of allNodeIds) {
-    if (hasCycle) break;
+    if (hasCycles) break;
     if (!visited.has(n)) {
       if (dfs(n, visited, new Set())) {
-        hasCycle = true;
+        hasCycles = true;
       }
     }
   }
 
-  if (hasCycle) {
+  if (hasCycles) {
     addViolation("(cycle)", "(cycle)", SEVERITY.ERROR, "R9",
       "Ciclo de dependencia detectado en el grafo global");
   }
 
-  /* ── 8. Stats ── */
+  /* ── 7a. Summary output (compact) ── */
+function buildSummary(graph) {
+  return {
+    stats: graph.stats,
+    violations: graph.violations.map(v => ({ rule: v.rule, severity: v.severity, from: v.from, to: v.to, description: v.description })),
+  };
+}
+
+/* ── 8. Stats ── */
   const bySeverity = { CRITICAL: 0, ERROR: 0, WARNING: 0 };
   for (const v of violations) {
     bySeverity[v.severity] = (bySeverity[v.severity] || 0) + 1;
@@ -488,6 +497,7 @@ export function buildGraph(projectRoot = ROOT) {
       criticalViolations: bySeverity.CRITICAL || 0,
       errorViolations: bySeverity.ERROR || 0,
       warningViolations: bySeverity.WARNING || 0,
+      hasCycles,
       riskScore,
       health,
       dependencyHealth,
@@ -504,6 +514,42 @@ export function validateGraph(graph) {
   };
 }
 
+/**
+ * getGraph — Cache-aware graph builder.
+ * Uses cached graph if src/ hasn't changed, builds fresh otherwise.
+ * Call with { force: true } to always rebuild.
+ */
+let _graphCache = null;
+
+export function getGraph(projectRoot = ROOT, opts = {}) {
+  const { force = false } = opts;
+
+  // Return memoized in-memory graph (same process)
+  if (_graphCache && !force) return _graphCache;
+
+  // Try disk cache
+  if (!force) {
+    const cached = loadCache("graph", projectRoot);
+    if (cached.valid && cached.data) {
+      _graphCache = cached.data;
+      return _graphCache;
+    }
+  }
+
+  // Build fresh and cache
+  const graph = buildGraph(projectRoot);
+  saveCache("graph", graph, projectRoot);
+  _graphCache = graph;
+  return graph;
+}
+
+/**
+ * Reset in-memory cache (for testing or forced refresh).
+ */
+export function resetGraphCache() {
+  _graphCache = null;
+}
+
 export function exportGraph(graph) {
   let out = "## Architecture Graph\n\n";
   out += `**Nodes:** ${graph.stats.totalNodes}  \n`;
@@ -565,11 +611,21 @@ export function exportGraph(graph) {
 async function main() {
   const args = process.argv.slice(2);
   const format = args.includes("--json") ? "json" : "text";
-  const graph = buildGraph();
+  const summary = args.includes("--summary");
+  const force = args.includes("--force");
+  const graph = getGraph(ROOT, { force });
   if (format === "json") {
-    console.log(JSON.stringify(graph, null, 2));
+    if (summary) {
+      console.log(JSON.stringify(buildSummary(graph), null, 2));
+    } else {
+      console.log(JSON.stringify(graph, null, 2));
+    }
   } else {
-    console.log(exportGraph(graph));
+    if (summary) {
+      console.log(`Graph: ${graph.stats.totalNodes} nodes, ${graph.stats.totalEdges} edges, ${graph.stats.violations} violations, risk ${graph.stats.riskScore}/100, health: ${graph.stats.health}`);
+    } else {
+      console.log(exportGraph(graph));
+    }
   }
 }
 

package/skills/forge/scripts/hook.mjs

@@ -150,11 +150,11 @@ async function cmdCheck() {
 
   // Run detect only over the staged source files
   const { allChecks, detectFeaturesOnSrc } = await import("./detect.mjs");
-  const { buildGraph } = await import("./graph.mjs");
+  const { getGraph } = await import("./graph.mjs");
   const { buildContext } = await import("./context.mjs");
 
   const ctx = await buildContext();
-  const graph = buildGraph(ROOT);
+  const graph = ctx.graph || getGraph();
   const features = detectFeaturesOnSrc();
   const results = allChecks(features, graph, ctx);
 

package/skills/forge/scripts/inspect.mjs

@@ -7,6 +7,7 @@ import { detectProfile, detectProfileExtended } from "./profile.mjs";
 import { buildDependencyGraph } from "./chain.mjs";
 import { allChecks, checkStructure, checkLayers, checkDecorators } from "./detect.mjs";
 import { saveHistory, updateStateFromAudit } from "./forge-config.mjs";
+import { buildPipeline, printPipeline } from "./recommendation-engine.mjs";
 
 const ROOT = process.cwd();
 
@@ -22,12 +23,15 @@ const CAT_NAMES = {
 };
 
 const CAT_MAX = {
-  structure: 20,
-  layers: 20,
+  structure: 30,
+  layers: 25,
+  decorators: 20,
   ownership: 20,
   platform: 15,
   dependencies: 15,
   graph: 20,
+  customRules: 5,
+  naming: 10,
 };
 
 function countBySeverity(checks) {
@@ -64,8 +68,8 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
   const barLen = 40;
   const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
 
-  function scoreBar(score, max) {
-    const p = max > 0 ? Math.round((score / max) * barLen) : 0;
+  function renderScoreBar(score, max) {
+    const p = Math.min(max > 0 ? Math.round((score / max) * barLen) : 0, barLen);
     const filled = "█".repeat(p);
     const empty = "░".repeat(barLen - p);
     const color = score >= max * 0.8 ? GREEN : score >= max * 0.5 ? YELLOW : RED;
@@ -128,7 +132,7 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
     const name = CAT_NAMES[key] || key;
     const cmax = CAT_MAX[key] || cat.max || 10;
     console.log(`  ${BOLD}${name} (${cat.score}/${cmax})${RESET}`);
-    console.log(`  ${scoreBar(cat.score, cmax)}`);
+    console.log(`  ${renderScoreBar(cat.score, cmax)}`);
 
     for (const check of cat.checks) {
       const icon = check.pass ? `${GREEN}✔${RESET}` : `${RED}✘${RESET}`;
@@ -142,41 +146,16 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
     console.log();
   }
 
-  if (report.recommendations.length > 0) {
-    console.log(`  ${BOLD}${YELLOW}Recomendaciones${RESET}`);
-    const unique = [...new Set(report.recommendations)];
-    unique.forEach((r, i) => console.log(`   ${i + 1}. ${r}`));
-    console.log();
-  }
-
-  /* Contextual suggestions */
-  const suggestions = [];
-  const v = report.severityCounts;
-  if ((v.CRITICAL || 0) > 0) suggestions.push("forge quench — revisar reglas CRITICAL en detalle");
-  if ((v.ERROR || 0) > 0) suggestions.push("forge quench — corregir violaciones ERROR antes de avanzar");
-  if (graph.hasCycles) suggestions.push("forge reforge — eliminar ciclos del grafo de dependencias");
-  if (ctx.platform.exists && ctx.platform.components.length < 3) suggestions.push("forge forge — bootstrap de componentes platform faltantes");
-  if (!ctx.platform.exists) suggestions.push("forge forge — iniciar bootstrap de platform");
-  if (ctx.features.legacy.length > 0) suggestions.push(`forge relocate — migrar ${ctx.features.legacy.length} feature(s) legacy a estructura hexagonal`);
-  if (archGraph && archGraph.stats.dependencyHealth < 70) suggestions.push("forge temper — endurecer inyección de dependencias");
-  if (archGraph && archGraph.stats.riskScore > 50) suggestions.push("forge reforge — reducir riesgo arquitectónico");
-  if (pct >= 80) suggestions.push("forge inspect — mantener auditoría periódica");
-  if (pct < 50) suggestions.push("forge inspect — auditoría focalizada tras correcciones");
-
-  // Profile-derived suggestions
-  if (profileExtended) {
-    for (const dep of profileExtended.depIssues || []) {
-      suggestions.push(`profiler: ${dep}`);
-    }
-    for (const s of profileExtended.suggestions || []) {
-      suggestions.push(`profiler: ${s}`);
+  /* Unified pipeline recommendation */
+  const allViolations = [];
+  for (const [, cat] of Object.entries(report.categories)) {
+    for (const c of cat.checks) {
+      if (!c.pass) allViolations.push(c);
     }
   }
-
-  if (suggestions.length > 0) {
-    console.log(`  ${BOLD}${CYAN}Siguientes pasos sugeridos${RESET}`);
-    suggestions.forEach((s, i) => console.log(`   ${i + 1}. ${s}`));
-    console.log();
+  const pipeline = buildPipeline(allViolations, graph, ctx.ownership, profileExtended, ctx);
+  if (pipeline.length > 0) {
+    printPipeline(pipeline);
   }
 
   console.log("═".repeat(58) + "\n");
@@ -234,16 +213,38 @@ function getChangedFeatures(changedFiles, allFeatures) {
 async function main() {
   const args = process.argv.slice(2);
   const isJson = args.includes("--json");
-  const isDiff = args.includes("--diff");
+  const isDiff = args.includes("--diff") || !args.includes("--full");
+  const isSummary = args.includes("--summary");
+  const force = args.includes("--force");
   const filterSeverity = args.includes("--severity") ? args[args.indexOf("--severity") + 1] : null;
 
-  const ctx = await buildContext();
+  const ctx = await buildContext(ROOT, null, { force });
   const profileExtended = detectProfileExtended(ctx);
   const profile = profileExtended.profile;
-  const chainGraph = buildDependencyGraph();
   const archGraph = ctx.graph;
+  const chainGraph = buildDependencyGraph(process.cwd(), archGraph);
   const features = ctx.features.migrated;
 
+  if (isSummary) {
+    const result = allChecks(features, archGraph, ctx);
+    const report = buildReport({ categories: result });
+    const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
+    if (isJson) {
+      console.log(JSON.stringify({
+        score: report.total,
+        max: report.max,
+        pct,
+        grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
+        severityCounts: report.severityCounts,
+        violations: report.violations.length,
+        health: pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor",
+      }, null, 2));
+    } else {
+      console.log(`Score: ${report.total}/${report.max} (${pct}%) | Violations: ${report.violations.length} | Health: ${pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor"}`);
+    }
+    return;
+  }
+
   if (isDiff) {
     const changedFiles = getChangedFiles();
     const changedFeatures = getChangedFeatures(changedFiles, features);
@@ -282,8 +283,12 @@ async function main() {
     };
 
     // Provide a simpler report
-    let totalScore = result.structure.score + result.layers.score + (result.decorators?.score || 0);
-    const maxScore = 60; // structure 20 + layers 20 + decorators 20
+    let totalScore = 0;
+    let maxScore = 0;
+    for (const [key, cat] of Object.entries(result)) {
+      totalScore += cat.score;
+      maxScore += CAT_MAX[key] || 20;
+    }
     const pct = Math.round((totalScore / maxScore) * 100);
 
     if (!isJson) {
@@ -291,7 +296,8 @@ async function main() {
 
       for (const [key, cat] of Object.entries(result)) {
         const name = key.charAt(0).toUpperCase() + key.slice(1);
-        console.log(`  ${BOLD}${name} (${cat.score}/${cat.score === 0 && cat.checks.length > 0 ? "—" : maxScore})${RESET}`);
+        const cmax = CAT_MAX[key] || cat.max || 20;
+        console.log(`  ${BOLD}${name} (${cat.score}/${cat.score === 0 && cat.checks.length > 0 ? "—" : cmax})${RESET}`);
         for (const check of cat.checks) {
           const icon = check.pass ? `${GREEN}✔${RESET}` : `${RED}✘${RESET}`;
           const sev = check.pass ? "" : ` ${SEVERITY_COLORS[check.severity]}[${check.severity}]${RESET}`;
@@ -309,24 +315,26 @@ async function main() {
         categories: result,
       }, null, 2));
     }
-    updateStateFromAudit({ total: totalScore, grade: `${pct}%`, violations: [], health: "diff", context: { features: { total: features.length, migrated: features, legacy: [] } } });
+    updateStateFromAudit({ total: totalScore, max: maxScore, grade: `${pct}%`, violations: [], health: "diff", context: { features: { total: features.length, migrated: features, legacy: [] } } });
     saveHistory({ score: totalScore, grade: `${pct}%`, violationCount: 0, totalFeatures: features.length, migratedFeatures: features.length });
     process.exit(0);
   }
 
   const result = allChecks(features, archGraph, ctx);
   const report = buildReport({ categories: result });
+  const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
 
   updateStateFromAudit({
     total: report.total,
-    grade: report.grade,
+    max: report.max,
+    grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
     violations: report.violations || [],
-    health: report.total >= 80 ? "healthy" : report.total >= 50 ? "fair" : "poor",
+    health: pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor",
     context: { features: { total: features.length, migrated: features, legacy: ctx.features?.legacy || [] } },
   });
   saveHistory({
     score: report.total,
-    grade: report.grade,
+    grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
     violationCount: (report.violations || []).length,
     totalFeatures: features.length,
     migratedFeatures: features.length,

package/skills/forge/scripts/parse-imports.mjs

@@ -214,8 +214,6 @@ function parseWithRegexLines(content, filePath) {
 export function parseImportPaths(content, filePath) {
   const astResult = filePath ? parseWithAST(content, filePath) : null;
   if (astResult) return astResult;
-  const regexResult = parseWithAST(content); // second try without filePath hint
-  if (regexResult) return regexResult;
   return parseWithRegex(content);
 }
 

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

@@ -25,7 +25,7 @@
 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 { getGraph } from "./graph.mjs";
 import { buildContext } from "./context.mjs";
 import { detectFeaturesOnSrc, allChecks, loadAllInlineIgnores, isIgnored } from "./detect.mjs";
 import { evaluateRules } from "./registry/rules.mjs";
@@ -82,7 +82,7 @@ export async function postToolCheck(files, opts = {}) {
   // Build context and run full audit
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
-  const graph = buildGraph(ROOT);
+  const graph = ctx.graph || getGraph();
   const results = allChecks(features, graph, ctx);
 
   // Load inline ignores