@ronaldjdevfs/forge 1.0.2 → 1.1.0

package/skills/forge/scripts/posttool.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+/**
+ * posttool.mjs — PostToolUse hook para Forge.
+ *
+ * Se ejecuta después de que el agente escribe código. Analiza los archivos
+ * modificados y reporta violaciones arquitectónicas.
+ *
+ * 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
+ */
+
+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`);
+
+  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`);
+
+    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;
+  }
+
+  // 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() {
+  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);
+  }
+}
+
+if (process.argv[1]?.endsWith("posttool.mjs")) {
+  main().catch(console.error);
+}

package/skills/forge/scripts/profile.mjs

@@ -1,64 +1,142 @@
 #!/usr/bin/env node
 
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
 import { buildContext } from "./context.mjs";
 
+const ROOT = process.cwd();
+
 const PROFILES = [
   {
     name: "express-mongodb",
-    match: (ctx) =>
-      ctx.framework === "Express" &&
-      ctx.database === "MongoDB" &&
-      ctx.orm === "Mongoose",
+    match: (ctx) => ctx.framework === "Express" && ctx.database === "MongoDB" && ctx.orm === "Mongoose",
+    deps: ["express", "mongoose"],
+    opts: { di: "tsyringe|awilix", test: "vitest|jest", validation: "zod|joi", logger: "pino|winston" },
   },
   {
     name: "express-prisma",
-    match: (ctx) =>
-      ctx.framework === "Express" &&
-      ctx.orm === "Prisma",
+    match: (ctx) => ctx.framework === "Express" && ctx.orm === "Prisma",
+    deps: ["express", "@prisma/client"],
+    opts: { di: "tsyringe|awilix", test: "vitest|jest", validation: "zod|joi", logger: "pino|winston" },
   },
   {
     name: "express-postgres",
-    match: (ctx) =>
-      ctx.framework === "Express" &&
-      ctx.database === "PostgreSQL" &&
-      ctx.orm === "native",
+    match: (ctx) => ctx.framework === "Express" && ctx.database === "PostgreSQL" && ctx.orm === "native",
+    deps: ["express", "pg"],
+    opts: { di: "tsyringe|awilix", test: "vitest|jest", validation: "zod|joi", logger: "pino|winston" },
+  },
+  {
+    name: "express-drizzle",
+    match: (ctx) => ctx.framework === "Express" && ctx.orm === "Drizzle",
+    deps: ["express", "drizzle-orm"],
+    opts: { di: "tsyringe|awilix", test: "vitest|jest", validation: "zod|joi", logger: "pino|winston" },
   },
   {
     name: "fastify-postgres",
-    match: (ctx) =>
-      ctx.framework === "Fastify" &&
-      ctx.database === "PostgreSQL" &&
-      ctx.orm === "Prisma",
+    match: (ctx) => ctx.framework === "Fastify" && ctx.database === "PostgreSQL" && ctx.orm === "Prisma",
+    deps: ["fastify", "@prisma/client"],
+    opts: { test: "vitest|jest", validation: "zod|typebox", logger: "pino" },
+  },
+  {
+    name: "fastify-prisma",
+    match: (ctx) => ctx.framework === "Fastify" && ctx.orm === "Prisma",
+    deps: ["fastify", "@prisma/client"],
+    opts: { test: "vitest|jest", validation: "zod|typebox", logger: "pino" },
+  },
+  {
+    name: "fastify-mongodb",
+    match: (ctx) => ctx.framework === "Fastify" && ctx.database === "MongoDB" && ctx.orm === "Mongoose",
+    deps: ["fastify", "mongoose"],
+    opts: { test: "vitest|jest", validation: "zod|typebox", logger: "pino" },
   },
   {
     name: "nestjs-prisma",
-    match: (ctx) =>
-      ctx.framework === "NestJS" &&
-      ctx.orm === "Prisma",
+    match: (ctx) => ctx.framework === "NestJS" && ctx.orm === "Prisma",
+    deps: ["@nestjs/core", "@prisma/client"],
+    opts: { test: "vitest|jest", validation: "class-validator|zod" },
+  },
+  {
+    name: "nestjs-postgres",
+    match: (ctx) => ctx.framework === "NestJS" && ctx.database === "PostgreSQL" && (ctx.orm === "native" || ctx.orm === "TypeORM"),
+    deps: ["@nestjs/core", "pg"],
+    opts: { test: "vitest|jest", validation: "class-validator|zod" },
+  },
+  {
+    name: "nestjs-mongodb",
+    match: (ctx) => ctx.framework === "NestJS" && ctx.database === "MongoDB" && ctx.orm === "Mongoose",
+    deps: ["@nestjs/core", "mongoose"],
+    opts: { test: "vitest|jest", validation: "class-validator|zod" },
   },
 ];
 
+function readPkg() {
+  try {
+    const raw = readFileSync(join(ROOT, "package.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function findInstalled(depPattern, pkg) {
+  if (!pkg) return false;
+  const all = { ...pkg.dependencies, ...pkg.devDependencies };
+  const parts = depPattern.split("|");
+  return parts.some((p) => all[p]);
+}
+
 export function detectProfile(ctx) {
   for (const profile of PROFILES) {
     if (profile.match(ctx)) return profile.name;
   }
-
   if (ctx.framework !== "unknown") {
     return `${ctx.framework.toLowerCase()}-${ctx.database.toLowerCase()}`;
   }
-
   return "unknown";
 }
 
 export function detectProfileExtended(ctx) {
   const profile = detectProfile(ctx);
+  const profileDef = PROFILES.find((p) => p.name === profile);
 
+  const pkg = readPkg();
   const diStrategy = ctx.diStrategy || "manual";
   const hasPlatform = ctx.platform?.exists || false;
   const hasShared = ctx.shared?.exists || false;
   const hasInfra = ctx.infra?.exists || false;
   const platformComponents = ctx.platform?.components || [];
 
+  // Detección de librerías complementarias
+  const hasTest = pkg ? findInstalled("vitest|jest|mocha|ava", pkg) : false;
+  const hasValidation = pkg ? findInstalled("zod|joi|class-validator|typebox|yup", pkg) : false;
+  const hasLogger = pkg ? findInstalled("pino|winston|log4js", pkg) : false;
+  const hasAuth = pkg ? findInstalled("bcrypt|argon2|jsonwebtoken|jose|passport", pkg) : false;
+  const hasHelmet = pkg ? findInstalled("helmet|cors", pkg) : false;
+  const hasRateLimit = pkg ? findInstalled("express-rate-limit|rate-limiter-flexible|@fastify/rate-limit", pkg) : false;
+  const hasSwagger = pkg ? findInstalled("swagger-ui-express|@nestjs/swagger|@fastify/swagger|openapi", pkg) : false;
+  const hasEvents = pkg ? findInstalled("eventemitter3|kafkajs|amqplib|ioredis|bull|bullmq|@nestjs/event-emitter", pkg) : false;
+
+  // Sugerencias de paquetes faltantes
+  const suggestions = [];
+  if (!hasTest) suggestions.push("Agregar framework de testing: vitest o jest");
+  if (!hasValidation) suggestions.push("Agregar validación: zod o class-validator");
+  if (!hasLogger) suggestions.push("Agregar logger: pino (recomendado) o winston");
+  if (!hasAuth) suggestions.push("Agregar autenticación: bcrypt + jsonwebtoken o jose");
+  if (!hasHelmet) suggestions.push("Agregar seguridad HTTP: helmet + cors");
+  if (!hasRateLimit) suggestions.push("Agregar rate limiting: express-rate-limit o rate-limiter-flexible");
+  if (!hasSwagger) suggestions.push("Agregar documentación API: OpenAPI con zod-to-openapi o @nestjs/swagger");
+  if (!hasEvents) suggestions.push("Agregar event bus: eventemitter3 (local) o kafkajs (distribuido)");
+
+  // Validación de dependencias del perfil detectado
+  const depIssues = [];
+  if (profileDef && pkg) {
+    for (const dep of profileDef.deps) {
+      if (!findInstalled(dep, pkg)) {
+        depIssues.push(`Falta dependencia requerida: ${dep}`);
+      }
+    }
+  }
+
   return {
     profile,
     hasPlatform,
@@ -72,6 +150,18 @@ export function detectProfileExtended(ctx) {
       shared: hasShared,
       infra: hasInfra,
     },
+    complementary: {
+      test: hasTest,
+      validation: hasValidation,
+      logger: hasLogger,
+      auth: hasAuth,
+      helmet: hasHelmet,
+      rateLimit: hasRateLimit,
+      swagger: hasSwagger,
+      events: hasEvents,
+    },
+    suggestions,
+    depIssues,
   };
 }
 
@@ -80,8 +170,22 @@ async function main() {
   const profile = detectProfile(ctx);
   const extended = detectProfileExtended(ctx);
   const args = process.argv.slice(2);
+
   if (args.includes("--extended")) {
     console.log(JSON.stringify(extended, null, 2));
+  } else if (args.includes("--suggest")) {
+    if (extended.suggestions.length === 0 && extended.depIssues.length === 0) {
+      console.log(`✓ Perfil "${profile}" — todas las dependencias y complementos detectados`);
+    } else {
+      if (extended.depIssues.length > 0) {
+        console.log(`⚠ Perfil "${profile}" — problemas de dependencias:`);
+        extended.depIssues.forEach((d) => console.log(`   ✘ ${d}`));
+      }
+      if (extended.suggestions.length > 0) {
+        console.log(`\n💡 Sugerencias para complementar "${profile}":`);
+        extended.suggestions.forEach((s, i) => console.log(`   ${i + 1}. ${s}`));
+      }
+    }
   } else {
     console.log(profile);
   }