@ronaldjdevfs/forge 1.3.0-beta → 1.3.1

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * forge-boot.mjs — Boot orchestrator with conditional depth.
+ *
+ * Uso:
+ *   node forge-boot.mjs --depth minimal|standard|full [--command <name>] [--json] [--force]
+ *
+ * Profundidades:
+ *   minimal  → context + profile (cast, temper, smelt, relocate, reforge, inscribe)
+ *   standard → minimal + graph + chain (chain, graph)
+ *   full     → standard + ownership + inspect (inspect, quench, default)
+ *
+ * Cache:
+ *   Usa .forge/cache/ para reusar datos entre invocaciones.
+ *   Pasa --force para ignorar caché y regenerar todo.
+ */
+
+import { join } from "path";
+
+const ROOT = process.cwd();
+
+async function main() {
+  const args = process.argv.slice(2);
+  const depth = args.includes("--depth")
+    ? args[args.indexOf("--depth") + 1]
+    : "full";
+  const isJson = args.includes("--json");
+  const force = args.includes("--force");
+
+  const result = { depth, bootTime: Date.now(), context: null, profile: null, graph: null, chain: null, ownership: null, inspect: null };
+
+  // 1. Context
+  const { buildContext } = await import("./context.mjs");
+  const ctx = await buildContext(ROOT, null, { force });
+  result.context = ctx;
+
+  // 2. Profile
+  const { detectProfile, detectProfileExtended } = await import("./profile.mjs");
+  const profileExtended = detectProfileExtended(ctx);
+  result.profile = {
+    profile: profileExtended.profile,
+    hasPlatform: profileExtended.hasPlatform,
+    hasShared: profileExtended.hasShared,
+    hasInfra: profileExtended.hasInfra,
+    layers: profileExtended.layers,
+    complementary: profileExtended.complementary,
+  };
+
+  if (depth === "minimal") {
+    if (isJson) return console.log(JSON.stringify(result, null, 2));
+    console.log(`Boot [${depth}]: ${result.profile.profile} | ${ctx.features.total} features | ${ctx.framework} | ${ctx.database}`);
+    return;
+  }
+
+  // 3. Graph
+  result.graph = ctx.graph;
+
+  // 4. Chain
+  const { buildDependencyGraph } = await import("./chain.mjs");
+  const chain = buildDependencyGraph(ROOT, result.graph);
+  result.chain = {
+    features: chain.features.length,
+    hasCycles: chain.hasCycles,
+    globalCycles: chain.globalCycles,
+    illegalChains: chain.illegalChains.length,
+    isolated: chain.isolated.length,
+    topologicalOrder: chain.topologicalOrder,
+  };
+
+  if (depth === "standard") {
+    if (isJson) return console.log(JSON.stringify(result, null, 2));
+    console.log(`Boot [${depth}]: ${result.profile.profile} | ${ctx.features.total} features | ${result.graph.stats.totalNodes} nodes | chains: ${result.chain.illegalChains}`);
+    return;
+  }
+
+  // 5. Ownership (from context)
+  result.ownership = {
+    health: ctx.ownership?.health || "unknown",
+    score: ctx.ownership?.score || 0,
+    orphans: ctx.ownership?.orphans?.length || 0,
+    duplicates: ctx.ownership?.duplicates?.length || 0,
+    misplaced: ctx.ownership?.misplaced?.length || 0,
+    hasPlatform: ctx.ownership?.hasPlatform || false,
+    hasFeatures: ctx.ownership?.hasFeatures || false,
+  };
+
+  // 6. Inspect (full audit)
+  const { allChecks } = await import("./detect.mjs");
+  const checks = allChecks(ctx.features.migrated, result.graph, ctx);
+  const violations = [];
+  for (const [catName, cat] of Object.entries(checks)) {
+    for (const check of cat.checks) {
+      if (!check.pass) violations.push({ severity: check.severity, label: check.label, category: catName });
+    }
+  }
+  result.inspect = {
+    totalChecks: violations.length,
+    critical: violations.filter(v => v.severity === "CRITICAL").length,
+    errors: violations.filter(v => v.severity === "ERROR").length,
+    warnings: violations.filter(v => v.severity === "WARNING").length,
+  };
+
+  if (isJson) return console.log(JSON.stringify(result, null, 2));
+  console.log(`Boot [${depth}]: ${result.profile.profile} | features: ${ctx.features.total} | graph: ${result.graph.stats.totalNodes}n/${result.graph.stats.totalEdges}e | violations: ${result.inspect.totalChecks} [CRIT:${result.inspect.critical} ERR:${result.inspect.errors} WARN:${result.inspect.warnings}]`);
+}
+
+main().catch(console.error);

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

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
-import { join, dirname } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { join, dirname, relative } from "path";
+import { createHash } from "crypto";
 
 const ROOT = process.cwd();
 const CONFIG_DIR = join(ROOT, ".forge");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 const STATE_PATH = join(CONFIG_DIR, "state.json");
 const HISTORY_DIR = join(CONFIG_DIR, "history");
+const CACHE_DIR = join(CONFIG_DIR, "cache");
+
+const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 
 const DEFAULT_CONFIG = {
   profile: null,
@@ -23,6 +27,7 @@ const DEFAULT_CONFIG = {
 const DEFAULT_STATE = {
   lastAudit: null,
   lastScore: null,
+  lastMax: null,
   lastGrade: null,
   violationCount: 0,
   totalFeatures: 0,
@@ -78,6 +83,7 @@ export function updateStateFromAudit(auditResult) {
   const state = loadState();
   state.lastAudit = new Date().toISOString();
   state.lastScore = auditResult.total || 0;
+  state.lastMax = auditResult.max || null;
   state.lastGrade = auditResult.grade || "F";
   state.violationCount = (auditResult.violations || []).length;
   state.health = auditResult.health || "unknown";
@@ -116,7 +122,7 @@ export function displayTrend(entries) {
   console.log("─".repeat(60));
   for (const e of entries) {
     const date = (e.timestamp || "").slice(0, 19).replace("T", " ");
-    const score = e.score !== undefined ? `${e.score}/110` : "—";
+    const score = e.score !== undefined ? `${e.score}${e.max ? "/".concat(e.max) : ""}` : "—";
     const grade = e.grade || "—";
     const violations = e.violationCount !== undefined ? String(e.violationCount) : "—";
     const features = e.totalFeatures !== undefined ? `${e.migratedFeatures || 0}/${e.totalFeatures}` : "—";
@@ -173,6 +179,179 @@ export function configNeedsRefresh(config) {
   return daysSinceUpdate > 7;
 }
 
+/* ── Cache Layer ── */
+
+const CACHE_KEYS = ["context", "graph", "profile", "ownership", "chain"];
+
+function cachePath(key) {
+  mkdirSync(CACHE_DIR, { recursive: true });
+  return join(CACHE_DIR, `${key}.json`);
+}
+
+function cacheMetaPath() {
+  mkdirSync(CACHE_DIR, { recursive: true });
+  return join(CACHE_DIR, "meta.json");
+}
+
+function loadCacheMeta() {
+  try {
+    return JSON.parse(readFileSync(cacheMetaPath(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveCacheMeta(meta) {
+  const existing = loadCacheMeta();
+  writeFileSync(cacheMetaPath(), JSON.stringify({ ...existing, ...meta }, null, 2) + "\n");
+}
+
+/**
+ * Compute a hash of the src/ directory tree (file paths + mtimes).
+ * Used to detect if the project changed since last cache.
+ */
+export function hashSrcDir(projectRoot = ROOT) {
+  const src = join(projectRoot, "src");
+  if (!existsSync(src)) return null;
+  const hash = createHash("sha256");
+  const entries = [];
+  function walk(dir) {
+    let dirEntries;
+    try { dirEntries = readdirSync(dir); } catch { return; }
+    for (const entry of dirEntries.sort()) {
+      const full = join(dir, entry);
+      let st;
+      try { st = statSync(full); } catch { continue; }
+      if (st.isDirectory()) {
+        walk(full);
+      } else if (entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".tsx") || entry.endsWith(".json")) {
+        entries.push(relative(projectRoot, full) + ":" + st.mtimeMs);
+      }
+    }
+  }
+  walk(src);
+  hash.update(entries.join("\n"));
+  return hash.digest("hex").slice(0, 16);
+}
+
+/**
+ * Save a value to the cache with a src hash for invalidation.
+ */
+export function saveCache(key, data, projectRoot = ROOT) {
+  if (!CACHE_KEYS.includes(key)) return false;
+  const srcHash = hashSrcDir(projectRoot);
+  const payload = {
+    key,
+    srcHash,
+    cachedAt: Date.now(),
+    data,
+  };
+  const ok = writeJson(cachePath(key), payload);
+  if (ok) {
+    saveCacheMeta({ [key]: { srcHash, cachedAt: Date.now() } });
+  }
+  return ok;
+}
+
+/**
+ * Load a value from cache if valid (same src hash and not expired).
+ * Returns { data, valid } where valid is false if cache is stale.
+ */
+export function loadCache(key, projectRoot = ROOT) {
+  if (!CACHE_KEYS.includes(key)) return { data: null, valid: false };
+  const path = cachePath(key);
+  const cached = readJson(path);
+  if (!cached) return { data: null, valid: false };
+
+  // Check TTL
+  if (Date.now() - cached.cachedAt > CACHE_TTL_MS) {
+    return { data: null, valid: false };
+  }
+
+  // Check src hash match
+  const currentHash = hashSrcDir(projectRoot);
+  if (currentHash && currentHash !== cached.srcHash) {
+    return { data: null, valid: false };
+  }
+
+  return { data: cached.data, valid: true };
+}
+
+/**
+ * Invalidate a specific cache key or all keys.
+ */
+export function invalidateCache(key = null) {
+  if (key) {
+    const path = cachePath(key);
+    try { writeFileSync(path, JSON.stringify({}), "utf-8"); } catch {}
+  } else {
+    for (const k of CACHE_KEYS) {
+      try { writeFileSync(cachePath(k), JSON.stringify({}), "utf-8"); } catch {}
+    }
+  }
+}
+
+/**
+ * Determine required boot depth based on command.
+ * Returns 'minimal' | 'standard' | 'full'
+ * - minimal: context + profile (cast, temper, smelt, relocate, reforge, inscribe)
+ * - standard: minimal + graph + chain (chain, graph)
+ * - full: standard + armorer + inspect + detect + architecture (inspect, quench, default)
+ */
+export function getBootDepth(command) {
+  const minimal = ["cast", "temper", "smelt", "relocate", "reforge", "inscribe", "nail", "unnail", "forge-api", "forge state", "forge rollback"];
+  const standard = ["chain", "graph", "forge hook"];
+  if (minimal.includes(command)) return "minimal";
+  if (standard.includes(command)) return "standard";
+  return "full";
+}
+
+/**
+ * Try to load cached boot data up to a given depth.
+ * Returns { context, profile, graph, chain, ownership } with valid fields populated.
+ */
+export function loadCachedBoot(depth = "full", projectRoot = ROOT) {
+  const result = { context: null, profile: null, graph: null, chain: null, ownership: null };
+
+  // Always try context
+  const ctxCache = loadCache("context", projectRoot);
+  if (ctxCache.valid) result.context = ctxCache.data;
+
+  // Always try profile
+  const profCache = loadCache("profile", projectRoot);
+  if (profCache.valid) result.profile = profCache.data;
+
+  if (depth === "minimal") return result;
+
+  // Standard: add graph + chain
+  const graphCache = loadCache("graph", projectRoot);
+  if (graphCache.valid) result.graph = graphCache.data;
+
+  const chainCache = loadCache("chain", projectRoot);
+  if (chainCache.valid) result.chain = chainCache.data;
+
+  if (depth === "standard") return result;
+
+  // Full: add ownership
+  const ownCache = loadCache("ownership", projectRoot);
+  if (ownCache.valid) result.ownership = ownCache.data;
+
+  return result;
+}
+
+/**
+ * Check if cached boot is valid for a given depth.
+ */
+export function hasValidCache(depth = "full", projectRoot = ROOT) {
+  const cached = loadCachedBoot(depth, projectRoot);
+  if (!cached.context) return false;
+  if (depth === "minimal") return true;
+  if (!cached.graph) return false;
+  if (depth === "standard") return true;
+  if (!cached.ownership) return false;
+  return true;
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const isJson = args.includes("--json");

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

@@ -85,7 +85,7 @@ async function main() {
   if (isJson) {
     console.log(JSON.stringify({ state, recentHistory: history }, null, 2));
   } else {
-    const lastScore = state.lastScore !== null ? `${state.lastScore}/110` : "—";
+    const lastScore = state.lastScore !== null ? `${state.lastScore}/${state.lastMax || "?"}` : "—";
     const lastGrade = state.lastGrade || "—";
     console.log(`Forge State | Score: ${lastScore} | Grade: ${lastGrade} | Violaciones: ${state.violationCount} | Features: ${state.migratedFeatures}/${state.totalFeatures}`);
   }

package/skills/forge/scripts/forgeSentinel-lib.mjs

@@ -2,7 +2,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
-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";
@@ -18,7 +18,7 @@ export async function runSentinelCheck(files, opts = {}) {
 
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
-  const graph = buildGraph(ROOT);
+  const graph = ctx.graph || getGraph();
   const results = allChecks(features, graph, ctx);
 
   const allIgnores = loadAllInlineIgnores(join(ROOT, "src"));

package/skills/forge/scripts/forgeSentinel.mjs

@@ -3,7 +3,7 @@
 import { readFileSync, existsSync } from "fs";
 import { join } 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";
@@ -76,7 +76,7 @@ function printResult(result, opts = {}) {
   if (reminder || hook) {
     if (!hook) {
       console.log(`  ${YELLOW}Recordatorio:${RESET} ${result.total} violación(es) arquitectónica(s).`);
-      console.log(`  Ejecuta ${CYAN}forge quench${RESET} para ver el detalle completo.\n`);
+      console.log(`  Ejecuta ${CYAN}forge quench${RESET} para ver el detalle completo y pipeline de corrección.\n`);
     }
 
     if (result.hasCritical) {

package/skills/forge/scripts/forgeSmith.mjs

@@ -2,7 +2,7 @@
 
 import { existsSync } from "fs";
 import { join } from "path";
-import { buildGraph } from "./graph.mjs";
+import { getGraph } from "./graph.mjs";
 import { buildContext } from "./context.mjs";
 import { detectFeaturesOnSrc, allChecks } from "./detect.mjs";
 import { evaluateRules } from "./registry/rules.mjs";
@@ -67,7 +67,7 @@ async function checkProposedFile(filePath, content) {
 
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
-  const graph = buildGraph(ROOT);
+  const graph = ctx.graph || getGraph();
   const results = allChecks(features, graph, ctx);
 
   const violations = [];

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);