@ronaldjdevfs/forge 1.0.2 → 1.1.0

package/skills/forge/scripts/inspect.mjs

@@ -1,29 +1,16 @@
 #!/usr/bin/env node
 
-import { join, basename } from "path";
+import { join, basename, relative } from "path";
+import { execFileSync } from "child_process";
 import { buildContext } from "./context.mjs";
 import { detectProfile, detectProfileExtended } from "./profile.mjs";
 import { buildDependencyGraph } from "./chain.mjs";
-import { allChecks } from "./detect.mjs";
+import { allChecks, checkStructure, checkLayers, checkDecorators } from "./detect.mjs";
+import { saveHistory, updateStateFromAudit } from "./forge-config.mjs";
 
 const ROOT = process.cwd();
 
-const CYAN = "\x1b[36m";
-const GREEN = "\x1b[32m";
-const RED = "\x1b[31m";
-const YELLOW = "\x1b[33m";
-const BOLD = "\x1b[1m";
-const RESET = "\x1b[0m";
-const DIM = "\x1b[2m";
-const GRAY = "\x1b[90m";
-
-const SEVERITY_COLORS = {
-  CRITICAL: RED,
-  ERROR: RED,
-  WARNING: YELLOW,
-  INFO: CYAN,
-  SUGGESTION: GRAY,
-};
+import { CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM, GRAY, SEVERITY_COLORS, col, formatJson, formatCheck, scoreBar, formatReport } from "./formatter.mjs";
 
 const CAT_NAMES = {
   structure: "Estructura",
@@ -73,7 +60,7 @@ function buildReport(result) {
   return { total, max: maxTotal, categories: result.categories, violations, recommendations, severityCounts: countBySeverity(violations) };
 }
 
-function printReport(report, ctx, profile, graph, archGraph) {
+function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
   const barLen = 40;
   const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
 
@@ -162,6 +149,36 @@ function printReport(report, ctx, profile, graph, archGraph) {
     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}`);
+    }
+  }
+
+  if (suggestions.length > 0) {
+    console.log(`  ${BOLD}${CYAN}Siguientes pasos sugeridos${RESET}`);
+    suggestions.forEach((s, i) => console.log(`   ${i + 1}. ${s}`));
+    console.log();
+  }
+
   console.log("═".repeat(58) + "\n");
 }
 
@@ -169,24 +186,156 @@ function printJson(report, ctx, profile, graph, archGraph) {
   console.log(JSON.stringify({ ...report, profile, context: ctx, dependencies: graph, architectureGraph: archGraph }, null, 2));
 }
 
+/**
+ * Get files changed vs default branch (or working tree as fallback).
+ */
+function getChangedFiles() {
+  // Try 1: changes vs default branch (committed but not merged)
+  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 {}
+
+  // Try 2: working tree changes (unstaged + uncommitted)
+  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 {}
+  }
+
+  // Try 3: staged changes only
+  if (files.length === 0) {
+    try {
+      const raw = execFileSync("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      files = raw.trim().split("\n").filter(Boolean);
+    } catch {}
+  }
+
+  return files;
+}
+
+/**
+ * Determine which features are affected by changed files.
+ */
+function getChangedFeatures(changedFiles, allFeatures) {
+  if (changedFiles.length === 0) return [];
+  const affected = new Set();
+  for (const file of changedFiles) {
+    const match = file.match(/src\/features\/([^/]+)\//);
+    if (match) affected.add(match[1]);
+  }
+  return allFeatures.filter(f => affected.has(f));
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const isJson = args.includes("--json");
+  const isDiff = args.includes("--diff");
   const filterSeverity = args.includes("--severity") ? args[args.indexOf("--severity") + 1] : null;
 
   const ctx = await buildContext();
-  const profile = detectProfile(ctx);
+  const profileExtended = detectProfileExtended(ctx);
+  const profile = profileExtended.profile;
   const chainGraph = buildDependencyGraph();
   const archGraph = ctx.graph;
   const features = ctx.features.migrated;
-  const result = allChecks(features, archGraph, ctx);
 
+  if (isDiff) {
+    const changedFiles = getChangedFiles();
+    const changedFeatures = getChangedFeatures(changedFiles, features);
+
+    if (!isJson) {
+      console.log(`\n${CYAN}═══ Diff-Aware Audit ═══${RESET}`);
+      console.log(`${DIM}Archivos cambiados: ${changedFiles.length}${RESET}`);
+      if (changedFiles.length > 0) {
+        for (const f of changedFiles.slice(0, 10)) {
+          console.log(`  ${DIM}${f}${RESET}`);
+        }
+        if (changedFiles.length > 10) console.log(`  ${DIM}... (+${changedFiles.length - 10})${RESET}`);
+      }
+    }
+
+    if (changedFeatures.length === 0) {
+      if (!isJson) {
+        console.log(`\n${YELLOW}⚠ No hay features afectados por los cambios.${RESET}`);
+        console.log(`${DIM}Los cambios están fuera de src/features/ o no hay features migrados.${RESET}\n`);
+      } else {
+        console.log(JSON.stringify({ diff: { changedFiles: changedFiles.length, changedFeatures: [], affectedFeatures: false } }));
+      }
+      process.exit(0);
+    }
+
+    if (!isJson) {
+      console.log(`${DIM}Features afectados: ${changedFeatures.join(", ")}${RESET}\n`);
+    }
+
+    // Run only feature-specific checks on changed features
+    const result = {
+      structure: checkStructure(changedFeatures),
+      layers: checkLayers(changedFeatures),
+      decorators: checkDecorators(changedFeatures),
+      graph: archGraph ? { score: 0, checks: [{ severity: "INFO", label: `Grafo: ${archGraph.stats.totalNodes} nodos, ${archGraph.stats.violations} violaciones (global)`, pass: true }] } : { score: 0, checks: [] },
+    };
+
+    // 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
+    const pct = Math.round((totalScore / maxScore) * 100);
+
+    if (!isJson) {
+      console.log(`${BOLD}Score en features afectados: ${pct >= 80 ? GREEN : pct >= 50 ? YELLOW : RED}${totalScore}/${maxScore} (${pct}%)${RESET}\n`);
+
+      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}`);
+        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}`;
+          const detail = check.detail ? ` ${GRAY}— ${check.detail}${RESET}` : "";
+          console.log(`   ${icon}${sev} ${check.label}${detail}`);
+          if (!check.pass && check.fix) {
+            console.log(`     ${DIM}→ Fix: ${check.fix}${RESET}`);
+          }
+        }
+        console.log();
+      }
+    } else {
+      console.log(JSON.stringify({
+        diff: { changedFiles: changedFiles.length, changedFeatures, totalScore, maxScore, pct },
+        categories: result,
+      }, null, 2));
+    }
+    updateStateFromAudit({ total: totalScore, 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 });
 
+  updateStateFromAudit({
+    total: report.total,
+    grade: report.grade,
+    violations: report.violations || [],
+    health: report.total >= 80 ? "healthy" : report.total >= 50 ? "fair" : "poor",
+    context: { features: { total: features.length, migrated: features, legacy: ctx.features?.legacy || [] } },
+  });
+  saveHistory({
+    score: report.total,
+    grade: report.grade,
+    violationCount: (report.violations || []).length,
+    totalFeatures: features.length,
+    migratedFeatures: features.length,
+  });
+
   if (isJson) {
     printJson(report, ctx, profile, chainGraph, archGraph);
   } else {
-    printReport(report, ctx, profile, chainGraph, archGraph);
+    printReport(report, ctx, profile, chainGraph, archGraph, profileExtended);
   }
 }
 

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

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+/**
+ * Shared import parser for Forge.
+ * Uses @typescript-eslint/parser (AST) when available, falls back to regex.
+ * Handles imports, re-exports, dynamic imports, type-only imports, barrel exports.
+ */
+
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { createRequire } from "module";
+
+const ROOT = process.cwd();
+
+// ── AST Parser (try to load from project or skill node_modules) ──
+let tsParser = null;
+
+function tryLoadTSParser() {
+  if (tsParser !== null) return tsParser;
+
+  const candidates = [
+    join(ROOT, "node_modules", "@typescript-eslint", "parser"),
+    join(dirname(new URL(import.meta.url).pathname), "..", "node_modules", "@typescript-eslint", "parser"),
+  ];
+
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "package.json"))) {
+      try {
+        const req = createRequire(dir);
+        const parser = req("@typescript-eslint/parser");
+        tsParser = parser;
+        return parser;
+      } catch {
+        // fall through
+      }
+    }
+  }
+
+  tsParser = false; // not available
+  return null;
+}
+
+function parseWithAST(content, filePath) {
+  const parser = tryLoadTSParser();
+  if (!parser) return null;
+
+  try {
+    const ast = parser.parse(content, {
+      jsx: filePath?.endsWith(".tsx") || filePath?.endsWith(".jsx") || undefined,
+      range: false,
+      loc: false,
+      tokens: false,
+      comment: false,
+      errorOnUnknownASTType: false,
+    });
+
+    const imports = [];
+
+    for (const node of ast.body) {
+      // import ... from '...'
+      if (node.type === "ImportDeclaration" && node.source?.value) {
+        imports.push(node.source.value);
+      }
+      // export { ... } from '...', export * from '...'
+      if (
+        (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") &&
+        node.source?.value
+      ) {
+        imports.push(node.source.value);
+      }
+    }
+
+    // Dynamic imports — walk the tree
+    function walk(node) {
+      if (!node || typeof node !== "object") return;
+      if (Array.isArray(node)) {
+        for (const child of node) walk(child);
+        return;
+      }
+
+      // ImportExpression (import('...'))
+      if (node.type === "ImportExpression" && node.source?.value) {
+        imports.push(node.source.value);
+      }
+
+      // Legacy CallExpression dynamic import
+      if (node.type === "CallExpression" && node.callee?.name === "import" && node.arguments?.[0]?.value) {
+        imports.push(node.arguments[0].value);
+      }
+
+      for (const key of Object.keys(node)) {
+        walk(node[key]);
+      }
+    }
+
+    walk(ast);
+
+    return [...new Set(imports)];
+  } catch {
+    return null;
+  }
+}
+
+function parseWithASTWithLines(content, filePath) {
+  const parser = tryLoadTSParser();
+  if (!parser) return null;
+
+  try {
+    const ast = parser.parse(content, {
+      jsx: filePath?.endsWith(".tsx") || filePath?.endsWith(".jsx") || undefined,
+      range: true,
+      loc: true,
+      tokens: false,
+      comment: false,
+      errorOnUnknownASTType: false,
+    });
+
+    const imports = [];
+
+    function addSource(node, source) {
+      if (source?.value && node.loc) {
+        imports.push({ file: filePath, source: source.value, line: node.loc.start.line });
+      }
+    }
+
+    for (const node of ast.body) {
+      if (node.type === "ImportDeclaration" && node.source?.value) {
+        imports.push({ file: filePath, source: node.source.value, line: node.loc.start.line });
+      }
+      if (node.type === "ExportNamedDeclaration" && node.source?.value) {
+        imports.push({ file: filePath, source: node.source.value, line: node.loc.start.line });
+      }
+      if (node.type === "ExportAllDeclaration" && node.source?.value) {
+        imports.push({ file: filePath, source: node.source.value, line: node.loc.start.line });
+      }
+    }
+
+    function walk(node) {
+      if (!node || typeof node !== "object") return;
+      if (Array.isArray(node)) {
+        for (const child of node) walk(child);
+        return;
+      }
+      if (node.type === "ImportExpression" && node.source?.value && node.loc) {
+        imports.push({ file: filePath, source: node.source.value, line: node.loc.start.line });
+      }
+      if (node.type === "CallExpression" && node.callee?.name === "import" && node.arguments?.[0]?.value && node.loc) {
+        imports.push({ file: filePath, source: node.arguments[0].value, line: node.loc.start.line });
+      }
+      for (const key of Object.keys(node)) {
+        walk(node[key]);
+      }
+    }
+    walk(ast);
+
+    return imports;
+  } catch {
+    return null;
+  }
+}
+
+// ── Regex fallback (same as before) ──
+
+const PATTERNS = [
+  /import\s+(?:type\s+)?(?:\{[^}]*\}|[^;{]+?)\s+from\s+['"]([^'"]+)['"]/g,
+  /export\s+(?:type\s+)?(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g,
+  /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /import\s+['"]([^'"]+)['"]/g,
+];
+
+function parseWithRegex(content) {
+  const imports = [];
+  const seen = new Set();
+  for (const re of PATTERNS) {
+    re.lastIndex = 0;
+    let match;
+    while ((match = re.exec(content)) !== null) {
+      const path = match[1];
+      if (path && !seen.has(path)) {
+        seen.add(path);
+        imports.push(path);
+      }
+    }
+  }
+  return imports;
+}
+
+function parseWithRegexLines(content, filePath) {
+  const imports = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const re of PATTERNS) {
+      re.lastIndex = 0;
+      const matches = [...line.matchAll(re)];
+      for (const m of matches) {
+        const path = m[1];
+        if (path) {
+          imports.push({ file: filePath, source: path, line: i + 1 });
+        }
+      }
+    }
+  }
+  return imports;
+}
+
+// ── Public API ──
+
+/**
+ * Parse import/export paths from source code.
+ * Returns array of unique import path strings.
+ * Uses AST parser when available, falls back to regex.
+ */
+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);
+}
+
+/**
+ * Parse import/export statements with line numbers.
+ * Returns array of { file, source, line }.
+ * Uses AST parser when available, falls back to regex.
+ */
+export function parseImportsWithLines(content, filePath) {
+  const astResult = parseWithASTWithLines(content, filePath);
+  if (astResult) return astResult;
+  return parseWithRegexLines(content, filePath);
+}
+
+/* ── CLI test ── */
+if (process.argv[1] && process.argv[1].endsWith("parse-imports.mjs")) {
+  const fs = await import("fs");
+  const target = process.argv[2];
+  if (!target) {
+    console.error("Usage: node parse-imports.mjs <file>");
+    process.exit(1);
+  }
+  const content = fs.readFileSync(target, "utf-8");
+  const paths = parseImportPaths(content, target);
+  const lines = parseImportsWithLines(content, target);
+  console.log("── Import paths ──");
+  for (const p of paths) console.log(`  ${p}`);
+  console.log(`\n── With line numbers ──`);
+  for (const l of lines) console.log(`  ${l.line}: ${l.source}`);
+  console.log(`\nParser: ${tryLoadTSParser() ? "AST" : "regex (fallback)"}`);
+}

package/skills/forge/scripts/pin.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * Nail/unnail Forge sub-commands as standalone skill shortcuts.
+ *
+ * Usage:
+ *   node pin.mjs nail <command>
+ *   node pin.mjs unnail <command>
+ *
+ * `nail cast` creates a lightweight /cast skill that redirects to /forge cast.
+ * `unnail cast` removes that shortcut.
+ *
+ * Scans harness directories and creates/removes the pin in all of them.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+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 PIN_MARKER = '<!-- forge-pinned-skill -->';
+
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  while (dir !== '/') {
+    if (existsSync(join(dir, 'package.json')) || existsSync(join(dir, '.git'))) {
+      return dir;
+    }
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(startDir);
+}
+
+function findHarnessDirs(projectRoot) {
+  const dirs = [];
+  for (const harness of HARNESS_DIRS) {
+    const skillsDir = join(projectRoot, harness, 'skills');
+    const forgeDir = join(skillsDir, 'forge');
+    if (existsSync(forgeDir) || existsSync(join(skillsDir, 'i-forge'))) {
+      dirs.push(skillsDir);
+    }
+  }
+  return dirs;
+}
+
+function nail(command, projectRoot) {
+  const harnessDirs = findHarnessDirs(projectRoot);
+  if (harnessDirs.length === 0) {
+    console.log('No harness directories with Forge installed found.');
+    return false;
+  }
+
+  const content = `---
+name: ${command}
+description: "Shortcut for /forge ${command}."
+argument-hint: ""
+user-invocable: true
+---
+
+${PIN_MARKER}
+
+This is a pinned shortcut for \`{{command_prefix}}forge ${command}\`.
+
+Invoke {{command_prefix}}forge ${command}, passing along any arguments provided here, and follow its instructions.
+`;
+
+  let created = 0;
+  for (const skillsDir of harnessDirs) {
+    const skillDir = join(skillsDir, command);
+    if (existsSync(skillDir)) {
+      const existingMd = join(skillDir, 'SKILL.md');
+      if (existsSync(existingMd)) {
+        const existing = readFileSync(existingMd, 'utf-8');
+        if (!existing.includes(PIN_MARKER)) {
+          console.log(`  SKIP: ${skillDir} (non-pinned skill already exists)`);
+          continue;
+        }
+      }
+    }
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), content, 'utf-8');
+    console.log(`  + ${skillDir}`);
+    created++;
+  }
+
+  if (created > 0) {
+    console.log(`\nPinned '${command}' as a standalone shortcut in ${created} location(s).`);
+    console.log(`You can now use /${command} directly.`);
+  }
+  return created > 0;
+}
+
+function unnail(command, projectRoot) {
+  const harnessDirs = findHarnessDirs(projectRoot);
+  let removed = 0;
+
+  for (const skillsDir of harnessDirs) {
+    const skillDir = join(skillsDir, command);
+    if (!existsSync(skillDir)) continue;
+    const skillMd = join(skillDir, 'SKILL.md');
+    if (!existsSync(skillMd)) continue;
+    const content = readFileSync(skillMd, 'utf-8');
+    if (!content.includes(PIN_MARKER)) {
+      console.log(`  SKIP: ${skillDir} (not a pinned skill)`);
+      continue;
+    }
+    rmSync(skillDir, { recursive: true, force: true });
+    console.log(`  - ${skillDir}`);
+    removed++;
+  }
+
+  if (removed > 0) {
+    console.log(`\nUnpinned '${command}' from ${removed} location(s).`);
+  } else {
+    console.log(`No pinned '${command}' shortcut found.`);
+  }
+  return removed > 0;
+}
+
+const [,, action, command] = process.argv;
+
+if (!action || !command) {
+  console.log('Usage: node pin.mjs <nail|unnail> <command>');
+  console.log(`\nAvailable: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+if (action !== 'nail' && action !== 'unnail') {
+  console.error(`Unknown action: ${action}. Use 'nail' or 'unnail'.`);
+  process.exit(1);
+}
+
+if (!VALID_COMMANDS.includes(command)) {
+  console.error(`Unknown command: ${command}`);
+  console.error(`Available: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+const root = findProjectRoot();
+
+if (action === 'nail') {
+  nail(command, root);
+} else {
+  unnail(command, root);
+}