@ronaldjdevfs/forge 1.0.1

package/skills/forge/scripts/inspect.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { join, basename } from "path";
+import { buildContext } from "./context.mjs";
+import { detectProfile, detectProfileExtended } from "./profile.mjs";
+import { buildDependencyGraph } from "./chain.mjs";
+import { allChecks } from "./detect.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,
+};
+
+const CAT_NAMES = {
+  structure: "Estructura",
+  layers: "Capas",
+  ownership: "Ownership",
+  platform: "Platform",
+  dependencies: "Dependencias",
+  graph: "Grafo",
+};
+
+const CAT_MAX = {
+  structure: 20,
+  layers: 20,
+  ownership: 20,
+  platform: 15,
+  dependencies: 15,
+  graph: 20,
+};
+
+function countBySeverity(checks) {
+  const counts = {};
+  for (const c of checks) {
+    if (!c.pass) {
+      counts[c.severity] = (counts[c.severity] || 0) + 1;
+    }
+  }
+  return counts;
+}
+
+function buildReport(result) {
+  let total = 0;
+  let maxTotal = 0;
+  const violations = [];
+  const recommendations = [];
+
+  for (const [name, cat] of Object.entries(result.categories)) {
+    total += cat.score;
+    maxTotal += CAT_MAX[name] || 10;
+    for (const check of cat.checks) {
+      if (!check.pass) {
+        violations.push({ category: name, ...check });
+        if (check.fix) recommendations.push(check.fix);
+      }
+    }
+  }
+
+  return { total, max: maxTotal, categories: result.categories, violations, recommendations, severityCounts: countBySeverity(violations) };
+}
+
+function printReport(report, ctx, profile, graph, archGraph) {
+  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;
+    const filled = "█".repeat(p);
+    const empty = "░".repeat(barLen - p);
+    const color = score >= max * 0.8 ? GREEN : score >= max * 0.5 ? YELLOW : RED;
+    return `${color}${filled}${RESET}${DIM}${empty}${RESET}`;
+  }
+
+  console.log("\n" + "═".repeat(58));
+  console.log(`${BOLD}${CYAN}   FORGE AUDIT — Reporte Hexagonal${RESET}`);
+  console.log(`   ${DIM}Proyecto: ${basename(ROOT)}${RESET}`);
+  console.log(`   ${DIM}Perfil:   ${profile}${RESET}`);
+  console.log(`   ${DIM}Framework: ${ctx.framework} | DB: ${ctx.database} | ORM: ${ctx.orm} | DI: ${ctx.diStrategy}${RESET}`);
+  console.log(`   ${DIM}Fecha:    ${new Date().toISOString().slice(0, 10)}${RESET}`);
+  console.log("═".repeat(58) + "\n");
+
+  const gradeColor = pct >= 80 ? GREEN : pct >= 50 ? YELLOW : RED;
+  const grade = pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F";
+  console.log(`  ${BOLD}Puntaje total: ${gradeColor}${report.total}/${report.max} (${pct}%) — ${grade}${RESET}\n`);
+
+  /* Severity summary */
+  if (Object.keys(report.severityCounts).length > 0) {
+    console.log(`  ${BOLD}Resumen por severidad${RESET}`);
+    for (const [sev, count] of Object.entries(report.severityCounts)) {
+      const color = SEVERITY_COLORS[sev] || GRAY;
+      console.log(`   ${color}${sev}${RESET}: ${count}`);
+    }
+    console.log();
+  }
+
+  /* Context summary */
+  console.log(`  ${BOLD}Contexto del proyecto${RESET}`);
+  console.log(`   Features migrados: ${ctx.features.migrated.length}`);
+  console.log(`   Features legacy:   ${ctx.features.legacy.length}`);
+  console.log(`   Platform:          ${ctx.platform.exists ? ctx.platform.components.join(", ") : "(no detectado)"}`);
+  console.log(`   Shared:            ${ctx.shared.exists ? ctx.shared.components.join(", ") : "(no detectado)"}`);
+  console.log(`   Infra:             ${ctx.infra.exists ? ctx.infra.components.join(", ") : "(no detectado)"}`);
+  console.log(`   Dependencias:      ${graph.edges.length} edges entre ${graph.nodes.length} features`);
+  if (graph.hasCycles) console.log(`   ${RED}Ciclos detectados en el grafo de dependencias${RESET}`);
+  if (graph.edges.length > 0) {
+    for (const edge of graph.edges) {
+      console.log(`   ${GRAY}→ ${edge.source} depende de ${edge.target} (${edge.file})${RESET}`);
+    }
+  }
+
+  /* Architecture Graph summary */
+  if (archGraph) {
+    const ag = archGraph.stats;
+    console.log(`\n  ${BOLD}Grafo Arquitectónico${RESET}`);
+    console.log(`   Nodos: ${ag.totalNodes} | Edges: ${ag.totalEdges} | Violaciones: ${ag.violations}`);
+    console.log(`   Risk Score: ${ag.riskScore}/100 | Health: ${ag.health}`);
+    console.log(`   Dependency Health: ${ag.dependencyHealth}%`);
+    if (ag.layers) {
+      console.log(`   Capas: Platform=${ag.layers.platform}, Feature=${ag.layers.feature}, Shared=${ag.layers.shared}, Infra=${ag.layers.infra}`);
+    }
+    if (ag.health === "critical") console.log(`   ${RED}⚠ Salud crítica — se requieren acciones correctivas${RESET}`);
+  }
+  console.log();
+
+  /* Categories */
+  for (const [key, cat] of Object.entries(report.categories)) {
+    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)}`);
+
+    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();
+  }
+
+  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();
+  }
+
+  console.log("═".repeat(58) + "\n");
+}
+
+function printJson(report, ctx, profile, graph, archGraph) {
+  console.log(JSON.stringify({ ...report, profile, context: ctx, dependencies: graph, architectureGraph: archGraph }, null, 2));
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+  const filterSeverity = args.includes("--severity") ? args[args.indexOf("--severity") + 1] : null;
+
+  const ctx = await buildContext();
+  const profile = detectProfile(ctx);
+  const chainGraph = buildDependencyGraph();
+  const archGraph = ctx.graph;
+  const features = ctx.features.migrated;
+  const result = allChecks(features, archGraph, ctx);
+
+  const report = buildReport({ categories: result });
+
+  if (isJson) {
+    printJson(report, ctx, profile, chainGraph, archGraph);
+  } else {
+    printReport(report, ctx, profile, chainGraph, archGraph);
+  }
+}
+
+main().catch(console.error);

package/skills/forge/scripts/profile.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { buildContext } from "./context.mjs";
+
+const PROFILES = [
+  {
+    name: "express-mongodb",
+    match: (ctx) =>
+      ctx.framework === "Express" &&
+      ctx.database === "MongoDB" &&
+      ctx.orm === "Mongoose",
+  },
+  {
+    name: "express-prisma",
+    match: (ctx) =>
+      ctx.framework === "Express" &&
+      ctx.orm === "Prisma",
+  },
+  {
+    name: "express-postgres",
+    match: (ctx) =>
+      ctx.framework === "Express" &&
+      ctx.database === "PostgreSQL" &&
+      ctx.orm === "native",
+  },
+  {
+    name: "fastify-postgres",
+    match: (ctx) =>
+      ctx.framework === "Fastify" &&
+      ctx.database === "PostgreSQL" &&
+      ctx.orm === "Prisma",
+  },
+  {
+    name: "nestjs-prisma",
+    match: (ctx) =>
+      ctx.framework === "NestJS" &&
+      ctx.orm === "Prisma",
+  },
+];
+
+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 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 || [];
+
+  return {
+    profile,
+    hasPlatform,
+    hasShared,
+    hasInfra,
+    platformComponents,
+    diStrategy,
+    layers: {
+      platform: hasPlatform,
+      features: ctx.hasFeaturesDir || false,
+      shared: hasShared,
+      infra: hasInfra,
+    },
+  };
+}
+
+async function main() {
+  const ctx = await buildContext();
+  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 {
+    console.log(profile);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith("profile.mjs") || process.argv[1].endsWith("profile.js"))) {
+  main().catch(console.error);
+}

package/skills/forge/templates/feature/controller.ts.md

@@ -0,0 +1,66 @@
+```typescript
+// src/features/<domain>/adapters/in/http/<Domain>.controller.ts
+import { injectable, inject } from "tsyringe";
+import type { Request, Response, NextFunction } from "express";
+import { Create<Domain> } from "../../../application/use-cases/Create<Domain>.uc.js";
+import { Get<Domain> } from "../../../application/use-cases/Get<Domain>.uc.js";
+import { List<Domain> } from "../../../application/use-cases/List<Domain>.uc.js";
+import { Update<Domain> } from "../../../application/use-cases/Update<Domain>.uc.js";
+import { Delete<Domain> } from "../../../application/use-cases/Delete<Domain>.uc.js";
+
+@injectable()
+export class <Domain>Controller {
+  constructor(
+    @inject(Create<Domain>) private readonly create: Create<Domain>,
+    @inject(Get<Domain>) private readonly get: Get<Domain>,
+    @inject(List<Domain>) private readonly list: List<Domain>,
+    @inject(Update<Domain>) private readonly update: Update<Domain>,
+    @inject(Delete<Domain>) private readonly delete: Delete<Domain>
+  ) {}
+
+  createHandler = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await this.create.execute(req.body);
+      res.status(201).json({ data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  getById = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await this.get.execute(req.params.id);
+      res.status(200).json({ data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  list = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await this.list.execute(req.query);
+      res.status(200).json({ data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  update = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await this.update.execute(req.params.id, req.body);
+      res.status(200).json({ data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  delete = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      await this.delete.execute(req.params.id);
+      res.status(204).send();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+```

package/skills/forge/templates/feature/entity.ts.md

@@ -0,0 +1,11 @@
+```typescript
+// src/features/<domain>/domain/<Domain>.entity.ts
+import type { SomeGlobalType } from "@/shared/types/types.js";
+
+export interface <Domain> {
+  id: string;
+  // propiedades específicas del dominio
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+```

package/skills/forge/templates/feature/mapper.ts.md

@@ -0,0 +1,18 @@
+```typescript
+// src/features/<domain>/application/mappers/<Domain>.mapper.ts
+import type { <Domain> } from "../domain/<Domain>.entity.js";
+
+export class <Domain>Mapper {
+  static toDomain(doc: Record<string, any>): <Domain> {
+    return {
+      ...doc,
+    } as <Domain>;
+  }
+
+  static toPersistence(domain: <Domain>): Record<string, any> {
+    return {
+      ...domain,
+    };
+  }
+}
+```

package/skills/forge/templates/feature/repository-impl.ts.md

@@ -0,0 +1,59 @@
+```typescript
+// src/features/<domain>/adapters/out/persistence/<Domain>.repository.ts
+import { injectable } from "tsyringe";
+import type { <Domain> } from "../../../domain/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../../domain/I<Domain>.repository.js";
+import { <Domain>Mapper } from "../../../application/mappers/<Domain>.mapper.js";
+import <Domain>Model from "./<Domain>.schema.js";
+import { RepositoryError } from "@/shared/errors/RepositoryError.js";
+
+@injectable()
+export class <Domain>Repository implements I<Domain>Repository {
+  async create(data: Partial<<Domain>>, session?: unknown): Promise<<Domain>> {
+    try {
+      const doc = await <Domain>Model.create(data);
+      return <Domain>Mapper.toDomain(doc.toObject());
+    } catch (error: any) {
+      throw new RepositoryError("Error al crear", error);
+    }
+  }
+
+  async findById(id: string, session?: unknown): Promise<<Domain> | null> {
+    try {
+      const doc = await <Domain>Model.findById(id).lean();
+      return doc ? <Domain>Mapper.toDomain(doc) : null;
+    } catch (error: any) {
+      throw new RepositoryError("Error al buscar por ID", error);
+    }
+  }
+
+  async findAll(options?: Record<string, unknown>): Promise<{ data: <Domain>[]; total: number }> {
+    try {
+      const docs = await <Domain>Model.find().lean();
+      return {
+        data: docs.map((d: any) => <Domain>Mapper.toDomain(d)),
+        total: docs.length,
+      };
+    } catch (error: any) {
+      throw new RepositoryError("Error al listar", error);
+    }
+  }
+
+  async update(id: string, data: Partial<<Domain>>, session?: unknown): Promise<<Domain> | null> {
+    try {
+      const doc = await <Domain>Model.findByIdAndUpdate(id, data, { new: true }).lean();
+      return doc ? <Domain>Mapper.toDomain(doc) : null;
+    } catch (error: any) {
+      throw new RepositoryError("Error al actualizar", error);
+    }
+  }
+
+  async delete(id: string, session?: unknown): Promise<void> {
+    try {
+      await <Domain>Model.findByIdAndDelete(id);
+    } catch (error: any) {
+      throw new RepositoryError("Error al eliminar", error);
+    }
+  }
+}
+```

package/skills/forge/templates/feature/repository-interface.ts.md

@@ -0,0 +1,12 @@
+```typescript
+// src/features/<domain>/domain/I<Domain>.repository.ts
+import type { <Domain> } from "./<Domain>.entity.js";
+
+export interface I<Domain>Repository {
+  create(data: Partial<<Domain>>, session?: unknown): Promise<<Domain>>;
+  findById(id: string, session?: unknown): Promise<<Domain> | null>;
+  findAll(options?: Record<string, unknown>): Promise<{ data: <Domain>[]; total: number }>;
+  update(id: string, data: Partial<<Domain>>, session?: unknown): Promise<<Domain> | null>;
+  delete(id: string, session?: unknown): Promise<void>;
+}
+```

package/skills/forge/templates/feature/routes.ts.md

@@ -0,0 +1,17 @@
+```typescript
+// src/features/<domain>/adapters/in/http/<Domain>.routes.ts
+import { Router } from "express";
+import { container } from "tsyringe";
+import { <Domain>Controller } from "./<Domain>.controller.js";
+
+const router = Router();
+const controller = container.resolve(<Domain>Controller);
+
+router.post("/", controller.createHandler);
+router.get("/:id", controller.getById);
+router.get("/", controller.list);
+router.patch("/:id", controller.update);
+router.delete("/:id", controller.delete);
+
+export default router;
+```

package/skills/forge/templates/feature/schema.ts.md

@@ -0,0 +1,16 @@
+```typescript
+// src/features/<domain>/adapters/out/persistence/<Domain>.schema.ts
+import { model, Schema } from "mongoose";
+import type { <Domain> } from "../../../domain/<Domain>.entity.js";
+
+const <Domain>Schema = new Schema<<Domain>>(
+  {
+    // campos específicos
+  },
+  { timestamps: true }
+);
+
+<Domain>Schema.index({ /* índices */ });
+
+export default model<<Domain>>("<Domain>", <Domain>Schema);
+```

package/skills/forge/templates/feature/use-case.ts.md

@@ -0,0 +1,19 @@
+```typescript
+// src/features/<domain>/application/use-cases/Create<Domain>.uc.ts
+import { injectable, inject } from "tsyringe";
+import type { <Domain> } from "../../domain/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../domain/I<Domain>.repository.js";
+import { UseCaseError } from "@/shared/errors/UseCaseError.js";
+
+@injectable()
+export class Create<Domain> {
+  constructor(
+    @inject(I<Domain>Repository) private readonly repo: I<Domain>Repository
+  ) {}
+
+  async execute(data: Partial<<Domain>>): Promise<<Domain>> {
+    if (!data) throw new UseCaseError("Datos requeridos");
+    return this.repo.create(data);
+  }
+}
+```

package/skills/forge/templates/infra/mail.ts.md

@@ -0,0 +1,31 @@
+```typescript
+// src/infra/mail/Mail.config.ts
+
+export interface MailConfig {
+  host: string;
+  port: number;
+  user: string;
+  pass: string;
+  from: string;
+}
+
+export function loadMailConfig(): MailConfig {
+  return {
+    host: process.env.MAIL_HOST || "smtp.example.com",
+    port: parseInt(process.env.MAIL_PORT || "587", 10),
+    user: process.env.MAIL_USER || "",
+    pass: process.env.MAIL_PASS || "",
+    from: process.env.MAIL_FROM || "noreply@example.com",
+  };
+}
+```
+
+```typescript
+// src/infra/mail/Mail.service.ts
+import { loadMailConfig } from "./Mail.config.js";
+
+export async function sendMail(to: string, subject: string, body: string): Promise<void> {
+  const config = loadMailConfig();
+  // implementar con nodemailer, sendgrid, etc.
+}
+```

package/skills/forge/templates/infra/mongodb.ts.md

@@ -0,0 +1,12 @@
+```typescript
+// src/infra/mongodb/Mongo.config.ts
+import mongoose from "mongoose";
+
+export async function connectMongo(uri: string): Promise<void> {
+  await mongoose.connect(uri);
+}
+
+export async function disconnectMongo(): Promise<void> {
+  await mongoose.disconnect();
+}
+```

package/skills/forge/templates/infra/prisma.ts.md

@@ -0,0 +1,21 @@
+```typescript
+// src/infra/prisma/Prisma.client.ts
+import { PrismaClient } from "@prisma/client";
+
+const prisma = new PrismaClient();
+
+export { prisma };
+```
+
+```typescript
+// src/infra/prisma/Prisma.service.ts
+import { prisma } from "./Prisma.client.js";
+
+export async function connectPrisma(): Promise<void> {
+  await prisma.$connect();
+}
+
+export async function disconnectPrisma(): Promise<void> {
+  await prisma.$disconnect();
+}
+```

package/skills/forge/templates/infra/redis.ts.md

@@ -0,0 +1,30 @@
+```typescript
+// src/infra/redis/Redis.config.ts
+
+export interface RedisConfig {
+  url: string;
+  prefix: string;
+}
+
+export function loadRedisConfig(): RedisConfig {
+  return {
+    url: process.env.REDIS_URL || "redis://localhost:6379",
+    prefix: process.env.REDIS_PREFIX || "app:",
+  };
+}
+```
+
+```typescript
+// src/infra/redis/Redis.service.ts
+import { loadRedisConfig } from "./Redis.config.js";
+
+let client: unknown = null;
+
+export async function connectRedis(): Promise<void> {
+  // conectar según librería (ioredis, node-redis, etc.)
+}
+
+export async function disconnectRedis(): Promise<void> {
+  // desconectar
+}
+```

package/skills/forge/templates/platform/config.ts.md

@@ -0,0 +1,37 @@
+```typescript
+// src/platform/config/App.config.ts
+
+export interface AppConfig {
+  nodeEnv: string;
+  port: number;
+  apiPrefix: string;
+}
+
+export function loadAppConfig(): AppConfig {
+  return {
+    nodeEnv: process.env.NODE_ENV || "development",
+    port: parseInt(process.env.PORT || "3000", 10),
+    apiPrefix: process.env.API_PREFIX || "/api/v1",
+  };
+}
+```
+
+```typescript
+// src/platform/config/Env.config.ts
+
+export interface EnvConfig {
+  databaseUrl: string;
+  redisUrl: string;
+  jwtSecret: string;
+  jwtExpiresIn: string;
+}
+
+export function loadEnvConfig(): EnvConfig {
+  return {
+    databaseUrl: process.env.DATABASE_URL || "",
+    redisUrl: process.env.REDIS_URL || "",
+    jwtSecret: process.env.JWT_SECRET || "change-me",
+    jwtExpiresIn: process.env.JWT_EXPIRES_IN || "1d",
+  };
+}
+```

package/skills/forge/templates/platform/database.ts.md

@@ -0,0 +1,40 @@
+```typescript
+// src/platform/database/Database.config.ts
+import { loadEnvConfig } from "../config/Env.config.js";
+
+export interface DatabaseConfig {
+  url: string;
+  maxRetries: number;
+  retryDelay: number;
+}
+
+export function loadDatabaseConfig(): DatabaseConfig {
+  const env = loadEnvConfig();
+  return {
+    url: env.databaseUrl,
+    maxRetries: 3,
+    retryDelay: 1000,
+  };
+}
+```
+
+```typescript
+// src/platform/database/Connection.ts
+import { loadDatabaseConfig } from "./Database.config.js";
+
+let connection: unknown = null;
+
+export async function connect(): Promise<void> {
+  const config = loadDatabaseConfig();
+  // conectar según ORM (prisma, mongoose, pg, etc.)
+  console.log(`Connecting to database...`);
+}
+
+export async function disconnect(): Promise<void> {
+  // desconectar
+}
+
+export function getConnection(): unknown {
+  return connection;
+}
+```