@ronaldjdevfs/forge 1.2.0 → 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

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { getGraph } from "./graph.mjs";
+import { buildContext } from "./context.mjs";
+import { detectFeaturesOnSrc, allChecks, loadAllInlineIgnores, isIgnored } from "./detect.mjs";
+import { evaluateRules } from "./registry/rules.mjs";
+
+const ROOT = process.cwd();
+
+export async function runSentinelCheck(files, opts = {}) {
+  const { strict = false, reminder = false } = opts;
+
+  if (!files || files.length === 0) {
+    return { violations: [], graphViolations: [], total: 0, hasCritical: false, hasErrors: false, filesChecked: 0, summary: "Sin archivos fuente modificados" };
+  }
+
+  const ctx = await buildContext();
+  const features = detectFeaturesOnSrc();
+  const graph = ctx.graph || getGraph();
+  const results = allChecks(features, graph, ctx);
+
+  const allIgnores = loadAllInlineIgnores(join(ROOT, "src"));
+
+  const violations = [];
+  for (const [, cat] of Object.entries(results)) {
+    for (const check of cat.checks) {
+      if (check.pass) continue;
+
+      const touchesFile = files.some(f =>
+        (check.detail && check.detail.includes(f)) ||
+        (check.label && check.label.includes(f))
+      );
+
+      if (!touchesFile && !reminder) continue;
+
+      if (isIgnored(check, allIgnores)) continue;
+
+      violations.push(check);
+    }
+  }
+
+  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)`,
+  };
+}
+
+export function writeAuditLog(env, data, cwd) {
+  try {
+    const dir = join(cwd, ".forge", "audit");
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "forgeSentinel.json");
+    const log = [];
+    if (existsSync(path)) {
+      try {
+        const existing = JSON.parse(readFileSync(path, "utf-8"));
+        if (Array.isArray(existing)) log.push(...existing);
+      } catch {}
+    }
+    log.push({ ...data, ts: data.ts || new Date().toISOString() });
+    writeFileSync(path, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  } catch {}
+}

package/skills/forge/scripts/forgeSentinel.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { execFileSync } from "child_process";
+import { getGraph } 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,
+  formatCheck, formatJson,
+} from "./formatter.mjs";
+import { runSentinelCheck, writeAuditLog } from "./forgeSentinel-lib.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 parseHookEvent(stdin) {
+  if (!stdin) return null;
+  try {
+    const event = JSON.parse(stdin);
+    let files = [];
+
+    // Claude Code format: { toolUse: { name, input: { filePath, content } } }
+    if (event.toolUse?.input?.filePath) {
+      files = [event.toolUse.input.filePath];
+    }
+
+    // Cursor/Codex format: may have files array or filePath property
+    if (Array.isArray(event.files)) {
+      files = event.files.map(f => typeof f === "string" ? f : f.filePath).filter(Boolean);
+    }
+    if (event.filePath) {
+      files.push(event.filePath);
+    }
+
+    return files.length > 0 ? [...new Set(files)] : null;
+  } catch {
+    return null;
+  }
+}
+
+function printResult(result, opts = {}) {
+  const { reminder = false, hook = false } = opts;
+
+  const prefix = hook ? "" : `\n${BOLD}${CYAN}═══ forgeSentinel ═══${RESET}`;
+  if (!hook) console.log(prefix);
+
+  if (result.total === 0) {
+    if (!hook) {
+      console.log(` ${GREEN}✔${RESET} Sin violaciones arquitectónicas en archivos modificados`);
+      console.log(` ${DIM}Archivos revisados: ${result.filesChecked}${RESET}\n`);
+    }
+    return;
+  }
+
+  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 y pipeline de corrección.\n`);
+    }
+
+    if (result.hasCritical) {
+      const c = result.violations.filter(v => v.severity === "CRITICAL").length;
+      if (hook) {
+        const lines = [`[forgeSentinel] ⚠ ${c} CRITICAL, ${result.violations.filter(v => v.severity === "ERROR").length} ERROR`];
+        const toShow = result.violations.slice(0, 5);
+        for (const v of toShow) {
+          lines.push(`  [${v.severity}] ${v.label}${v.file ? ` (${v.file})` : ""}`);
+        }
+        if (result.violations.length > 5) {
+          lines.push(`  ${DIM}... y ${result.violations.length - 5} más. Ejecutá 'forge quench' para el detalle completo.${RESET}`);
+        }
+        console.log(lines.join("\n"));
+      } else {
+        console.log(`  ${RED}⚠ ${c} violación(es) CRITICAL detectadas${RESET}`);
+      }
+    }
+    if (result.hasErrors) {
+      const e = result.violations.filter(v => v.severity === "ERROR").length;
+      console.log(`  ${RED}⚠ ${e} violación(es) ERROR detectadas${RESET}`);
+    }
+
+    if (!hook) {
+      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;
+  }
+
+  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() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+  const isHook = args.includes("--hook");
+  const reminder = args.includes("--reminder");
+  const isDiff = args.includes("--diff");
+
+  let files;
+  if (isHook) {
+    const chunks = [];
+    if (!process.stdin.isTTY) {
+      for await (const chunk of process.stdin) chunks.push(chunk);
+    }
+    const stdin = Buffer.concat(chunks).toString("utf-8");
+    const hookFiles = parseHookEvent(stdin);
+    if (hookFiles) {
+      files = hookFiles;
+    }
+  }
+
+  if (!files || files.length === 0) {
+    if (isDiff) {
+      files = getChangedFiles();
+    } else {
+      files = args.filter(a => !a.startsWith("--"));
+      if (files.length === 0) {
+        files = getChangedFiles();
+      }
+    }
+  }
+
+  files = (files || []).filter(f =>
+    f.endsWith(".ts") || f.endsWith(".mjs") || f.endsWith(".js") || f.endsWith(".tsx")
+  );
+
+  const result = await runSentinelCheck(files, { strict: false, reminder: reminder || isHook });
+
+  writeAuditLog(process.env, {
+    ts: new Date().toISOString(),
+    hook: isHook ? "forgeSentinel" : "cli",
+    total: result.total,
+    hasCritical: result.hasCritical,
+    hasErrors: result.hasErrors,
+    filesChecked: result.filesChecked,
+  }, ROOT);
+
+  if (isJson) {
+    console.log(formatJson(result));
+  } else {
+    printResult(result, { reminder: reminder || isHook, hook: isHook });
+  }
+
+  process.exit(0);
+}
+
+if (process.argv[1]?.endsWith("forgeSentinel.mjs")) {
+  main().catch(() => process.exit(0));
+}