@ronaldjdevfs/forge 1.0.1

package/skills/forge/profiles/express-postgres.md

@@ -0,0 +1,164 @@
+# Profile: Express + PostgreSQL (raw)
+
+## Metadata
+
+```yaml
+framework: Express
+runtime: Node 20+
+database: PostgreSQL
+orm: node-postgres (pg)
+di_strategy: manual
+architecture: hexagonal-feature
+```
+
+## DI Strategy
+
+Este perfil usa **DI manual** (sin tsyringe). Las dependencias se inyectan por constructor y se instancian manualmente en bootstrap.
+
+```typescript
+// app.ts — wiring manual
+import { CreditRepository } from "@/features/credit/adapters/out/persistence/CreditRepository.js";
+import { AddCredit } from "@/features/credit/application/use-cases/Add.js";
+import { CreditController } from "@/features/credit/adapters/in/http/CreditController.js";
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+const creditRepo = new CreditRepository(pool);
+const addCredit = new AddCredit(creditRepo);
+const creditController = new CreditController(addCredit);
+```
+
+## Project Structure
+
+```
+├── src/
+│   ├── features/
+│   │   └── <domain>/
+│   │       ├── domain/
+│   │       │   ├── <Domain>.entity.ts
+│   │       │   └── I<Domain>Repository.ts
+│   │       ├── application/
+│   │       │   ├── use-cases/
+│   │       │   └── dto/
+│   │       └── adapters/
+│   │           ├── in/http/
+│   │           └── out/persistence/
+│   ├── shared/
+│   ├── infrastructure/
+│   │   └── pool.ts                # pg Pool singleton
+│   └── server.ts
+```
+
+## Persistence (pg)
+
+### Pool singleton
+
+```typescript
+// src/infrastructure/pool.ts
+import { Pool } from "pg";
+
+export const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+```
+
+### Repository pattern
+
+```typescript
+export class CreditRepository implements ICreditRepository {
+  constructor(private readonly db: Pool) {}
+
+  async create(data: Partial<Credit>): Promise<Credit> {
+    const { rows } = await this.db.query(
+      `INSERT INTO credits (amount, status) VALUES ($1, $2) RETURNING *`,
+      [data.amount, data.status]
+    );
+    return rows[0] as Credit;
+  }
+
+  async findById(id: string): Promise<Credit | null> {
+    const { rows } = await this.db.query(
+      `SELECT * FROM credits WHERE id = $1`,
+      [id]
+    );
+    return rows[0] ? (rows[0] as Credit) : null;
+  }
+}
+```
+
+### Transactions
+
+```typescript
+export class CreateCredit {
+  constructor(
+    private readonly creditRepo: ICreditRepository,
+    private readonly pool: Pool
+  ) {}
+
+  async execute(data: CreditInput): Promise<Credit> {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const credit = await this.creditRepo.create(data, client);
+      await client.query("COMMIT");
+      return credit;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+}
+```
+
+## Controller pattern
+
+```typescript
+export class CreditController {
+  constructor(private readonly addCredit: AddCredit) {}
+
+  add = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await this.addCredit.execute(req.body);
+      res.status(201).json({ data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+```
+
+## Routes pattern
+
+```typescript
+import { Emitter } from "@adpt/adapters";
+
+const router = Router();
+
+export function setupCreditRoutes(controller: CreditController) {
+  router.post("/", controller.add);
+  router.get("/:id", controller.getById);
+  return router;
+}
+```
+
+## Testing Strategy
+
+### Unit test
+
+```typescript
+const mockRepo = { create: jest.fn() };
+const useCase = new AddCredit(mockRepo);
+```
+
+### Integration test
+
+```typescript
+import { Pool } from "pg";
+const testPool = new Pool({ connectionString: process.env.TEST_DATABASE_URL });
+```
+
+## Naming Conventions
+
+Tables in snake_case, columns in snake_case, JavaScript/TypeScript in camelCase.

package/skills/forge/profiles/express-prisma.md

@@ -0,0 +1,116 @@
+# Profile: Express + Prisma
+
+## Metadata
+
+```yaml
+framework: Express
+runtime: Node 20+
+database: Cualquier RDBMS (PostgreSQL, MySQL, SQLite)
+orm: Prisma
+di_strategy: tsyringe
+architecture: hexagonal-feature
+```
+
+## Project Structure
+
+```
+├── prisma/
+│   └── schema.prisma
+├── src/
+│   ├── features/
+│   │   └── <domain>/
+│   │       ├── domain/
+│   │       │   ├── <Domain>.entity.ts
+│   │       │   └── I<Domain>Repository.ts
+│   │       ├── application/
+│   │       │   ├── use-cases/
+│   │       │   ├── dto/
+│   │       │   └── mappers/
+│   │       └── adapters/
+│   │           ├── in/http/
+│   │           └── out/persistence/
+│   ├── shared/
+│   ├── infrastructure/
+│   │   └── prisma.ts              # PrismaClient singleton
+│   └── server.ts
+```
+
+## DI Setup
+
+Igual que `express-mongodb` (tsyringe). Las interfaces se registran como singletons.
+
+## Persistence (Prisma)
+
+### PrismaClient singleton
+
+```typescript
+// src/infrastructure/prisma.ts
+import { PrismaClient } from "@prisma/client";
+
+export const prisma = new PrismaClient();
+```
+
+### Repository pattern
+
+```typescript
+@injectable()
+export class CreditRepository implements ICreditRepository {
+  async create(data: Partial<Credit>): Promise<Credit> {
+    const record = await prisma.credit.create({ data });
+    return CreditMapper.toDomain(record);
+  }
+
+  async findById(id: string): Promise<Credit | null> {
+    const record = await prisma.credit.findUnique({ where: { id } });
+    return record ? CreditMapper.toDomain(record) : null;
+  }
+}
+```
+
+### Transactions
+
+```typescript
+@injectable()
+export class CreateCredit {
+  async execute(data: CreditInput): Promise<Credit> {
+    return prisma.$transaction(async (tx) => {
+      const credit = await tx.credit.create({ data });
+      await tx.log.create({ data: { action: "credit_created", creditId: credit.id } });
+      return credit;
+    });
+  }
+}
+```
+
+## Testing Strategy
+
+### Unit test
+
+Misma estrategia que express-mongodb: `container.registerInstance()` con mocks.
+
+### Integration test
+
+```typescript
+import { prisma } from "@/infrastructure/prisma.js";
+import { CreditRepository } from "./CreditRepository.js";
+
+beforeAll(async () => {
+  // Prisma usa archivo de test o DB separada
+  // process.env.DATABASE_URL = "postgresql://test:test@localhost:5432/test";
+});
+
+afterAll(async () => {
+  await prisma.$disconnect();
+});
+
+it("persists a credit", async () => {
+  const repo = new CreditRepository();
+  const credit = await repo.create({ amount: 100 });
+  expect(credit.id).toBeDefined();
+  await prisma.credit.delete({ where: { id: credit.id } }); // cleanup
+});
+```
+
+## Naming Conventions
+
+Mismas que express-mongodb. Los nombres de tablas en Prisma siguen snake_case.

package/skills/forge/profiles/fastify-postgres.md

@@ -0,0 +1,110 @@
+# Profile: Fastify + PostgreSQL + Prisma
+
+## Metadata
+
+```yaml
+framework: Fastify
+runtime: Node 20+
+database: PostgreSQL
+orm: Prisma
+di_strategy: manual
+architecture: hexagonal-feature
+```
+
+## DI Strategy
+
+DI manual. Sin contenedor de DI externo. Las dependencias se inyectan por constructor y se registran explícitamente en bootstrap.
+
+```typescript
+// app.ts
+import Fastify from "fastify";
+import { PrismaClient } from "@prisma/client";
+import { creditRoutes } from "@/features/credit/adapters/in/http/credit.routes.js";
+
+const app = Fastify({ logger: true });
+const prisma = new PrismaClient();
+const creditRepo = new CreditRepository(prisma);
+const addCredit = new AddCredit(creditRepo);
+
+app.register(creditRoutes(addCredit));
+
+await app.listen({ port: 3000 });
+```
+
+## Project Structure
+
+```
+├── prisma/
+│   └── schema.prisma
+├── src/
+│   ├── features/
+│   │   └── <domain>/
+│   │       ├── domain/
+│   │       ├── application/
+│   │       └── adapters/
+│   │           ├── in/http/
+│   │           └── out/persistence/
+│   ├── shared/
+│   ├── infrastructure/
+│   │   └── prisma.ts
+│   ├── app.ts
+│   └── server.ts
+```
+
+## Routes & Controllers
+
+### Fastify plugin pattern
+
+```typescript
+// credit.routes.ts
+import type { FastifyInstance } from "fastify";
+import { CreditController } from "./CreditController.js";
+
+export async function creditRoutes(app: FastifyInstance, controller: CreditController) {
+  app.post("/credits", controller.add);
+  app.get("/credits/:id", controller.getById);
+  app.get("/credits", controller.list);
+}
+```
+
+### Controller
+
+```typescript
+export class CreditController {
+  constructor(private readonly addCredit: AddCredit) {}
+
+  add = async (request: FastifyRequest, reply: FastifyReply) => {
+    const result = await this.addCredit.execute(request.body as CreditInput);
+    return reply.status(201).send({ data: result });
+  };
+}
+```
+
+## Persistence
+
+Prisma repository pattern, identical to `express-prisma` profile.
+
+## Testing Strategy
+
+```typescript
+import Fastify from "fastify";
+
+const app = Fastify();
+const mockRepo = { create: jest.fn() };
+const useCase = new AddCredit(mockRepo);
+const controller = new CreditController(useCase);
+
+app.register(creditRoutes(controller));
+
+afterAll(() => app.close());
+
+it("creates a credit", async () => {
+  mockRepo.create.mockResolvedValue({ id: "1" });
+  const res = await app.inject({ method: "POST", url: "/credits", payload: { amount: 100 } });
+  expect(res.statusCode).toBe(201);
+});
+```
+
+## Naming Conventions
+
+Mismas que express-profile profiles. Fastify usa camelCase para rutas.

package/skills/forge/profiles/nestjs-prisma.md

@@ -0,0 +1,160 @@
+# Profile: NestJS + Prisma
+
+## Metadata
+
+```yaml
+framework: NestJS
+runtime: Node 20+
+database: Cualquier RDBMS
+orm: Prisma
+di_strategy: framework (NestJS DI)
+architecture: hexagonal-feature
+```
+
+## DI Strategy
+
+NestJS tiene su propio sistema de DI: `@Injectable()` decorator + módulos. No se necesita tsyringe.
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm"; // o Prisma
+
+@Injectable()
+export class AddCredit {
+  constructor(private readonly creditRepo: ICreditRepository) {}
+}
+```
+
+## Project Structure
+
+```
+├── prisma/
+│   └── schema.prisma
+├── src/
+│   ├── features/
+│   │   └── <domain>/
+│   │       ├── domain/
+│   │       │   ├── <Domain>.entity.ts
+│   │       │   └── I<Domain>Repository.ts
+│   │       ├── application/
+│   │       │   ├── use-cases/
+│   │       │   └── dto/
+│   │       └── adapters/
+│   │           ├── in/http/
+│   │           │   ├── <Domain>Controller.ts
+│   │           │   └── <domain>.module.ts
+│   │           └── out/persistence/
+│   │               ├── <Domain>Repository.ts
+│   │               └── <Domain>PrismaRepository.ts
+│   └── app.module.ts
+```
+
+## Module setup
+
+### feature module
+
+```typescript
+// credit.module.ts
+import { Module } from "@nestjs/common";
+import { CreditController } from "./CreditController.js";
+import { AddCredit } from "../../application/use-cases/Add.js";
+import { CreditRepository } from "../out/persistence/CreditPrismaRepository.js";
+
+@Module({
+  controllers: [CreditController],
+  providers: [
+    AddCredit,
+    { provide: "ICreditRepository", useClass: CreditRepository },
+  ],
+})
+export class CreditModule {}
+```
+
+### Controller (NestJS style)
+
+```typescript
+import { Controller, Post, Get, Body, Param } from "@nestjs/common";
+import { AddCredit } from "../../application/use-cases/Add.js";
+
+@Controller("credits")
+export class CreditController {
+  constructor(private readonly addCredit: AddCredit) {}
+
+  @Post()
+  async create(@Body() data: CreditInput) {
+    return this.addCredit.execute(data);
+  }
+
+  @Get(":id")
+  async findById(@Param("id") id: string) {
+    return this.addCredit.execute(id);
+  }
+}
+```
+
+## Persistence (Prisma)
+
+NestJS con Prisma: crear un `PrismaModule` global y `PrismaService` que extiende `PrismaClient`.
+
+```typescript
+import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}
+```
+
+### Repository
+
+```typescript
+@Injectable()
+export class CreditRepository implements ICreditRepository {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async create(data: Partial<Credit>): Promise<Credit> {
+    const record = await this.prisma.credit.create({ data });
+    return CreditMapper.toDomain(record);
+  }
+}
+```
+
+## Testing Strategy
+
+```typescript
+import { Test, TestingModule } from "@nestjs/testing";
+
+const mockRepo = { create: jest.fn() };
+
+beforeEach(async () => {
+  const module: TestingModule = await Test.createTestingModule({
+    providers: [
+      AddCredit,
+      { provide: "ICreditRepository", useValue: mockRepo },
+    ],
+  }).compile();
+
+  useCase = module.get<AddCredit>(AddCredit);
+});
+```
+
+## Naming Conventions
+
+NestJS usa PascalCase para clases y camelCase para métodos/propiedades. Decoradores nativos `@Injectable()`, `@Controller()`, etc.
+
+## Cross-feature communication
+
+```typescript
+// En NestJS, los módulos exportan providers para que otros módulos los usen
+@Module({
+  exports: [AddCredit], // Disponible para otros módulos
+})
+export class CreditModule {}
+```

package/skills/forge/reference/cast.md

@@ -0,0 +1,77 @@
+# Cast
+
+Crea un nuevo feature desde cero siguiendo la arquitectura hexagonal basada en features.
+
+## Cuándo usarlo
+
+- Agregar un nuevo dominio de negocio al proyecto
+- El dominio no existe previamente en forma legacy
+
+## Pre-condiciones
+
+Antes de crear un feature, verificar la existencia de los layers arquitectónicos:
+
+1. **Platform** — `src/platform/` (config, server, logger, di, etc.)
+2. **Shared** — `src/shared/` (errors, contracts, types, utils)
+3. **Infra** — `src/infra/` (prisma, redis, etc.)
+
+Si alguno no existe, ejecutar `bootstrapPlatform()` automáticamente para crearlos.
+
+## Flujo
+
+1. Verificar que `src/platform/`, `src/shared/`, `src/infra/` existan (crearlos si no)
+2. Determinar el nombre del feature (formato: kebab-case)
+3. Crear estructura de directorios:
+   ```
+   src/features/<name>/
+   ├── domain/
+   ├── application/
+   │   ├── use-cases/
+   │   └── mappers/
+   └── adapters/
+       ├── in/http/
+       └── out/persistence/
+   ```
+4. Crear archivos del feature en este orden (ver `templates/feature/`):
+   - `<Name>.entity.ts` — interfaz de dominio
+   - `I<Name>Repository.ts` — puerto de repositorio
+   - `<Name>.mapper.ts` — mapper dominio ↔ persistencia
+   - `<Name>Schema.ts` — schema de BD (según perfil)
+   - `<Name>Repository.ts` — implementación del repositorio
+   - Use cases (`Create.ts`, `Get.ts`, `List.ts`, `Update.ts`, `Delete.ts`)
+   - `<Name>Controller.ts` — controlador HTTP
+   - `<name>.routes.ts` — rutas HTTP
+5. Registrar rutas en el enrutador principal
+6. Ejecutar `forge quench` para verificar el feature
+7. Actualizar `ARCHITECTURE.md`
+
+## Convenciones
+
+Ver `reference/patterns.md` para el patrón completo.
+
+| Elemento | Formato | Ejemplo |
+|---|---|---|
+| Feature directory | `kebab-case/` | `credit-card/` |
+| Entity | `<Name>.entity.ts` | `CreditCard.entity.ts` |
+| Repository interface | `I<Name>.repository.ts` | `ICreditCard.repository.ts` |
+| Repository impl | `<Name>.repository.ts` | `CreditCard.repository.ts` |
+| Use case | `<Action>.uc.ts` | `CreateCreditCard.uc.ts` |
+| Mapper | `<Name>.mapper.ts` | `CreditCard.mapper.ts` |
+| Controller | `<Name>.controller.ts` | `CreditCard.controller.ts` |
+| Routes | `<Name>.routes.ts` | `CreditCard.routes.ts` |
+| Schema | `<Name>.schema.ts` | `CreditCard.schema.ts` |
+
+## Con el perfil activo
+
+Usar el perfil detectado para determinar:
+- Estrategia de DI (tsyringe/manual/framework)
+- Patrón de controlador (Express/Fastify/NestJS)
+- Patrón de persistencia (Mongoose/Prisma/pg)
+- Convenciones de imports (rutas relativas vs alias)
+- Componentes de platform a usar (config, logger, http, database)
+
+## Post-creación
+
+- `forge quench` — verificar que no hay violaciones
+- `forge inspect` — confirmar puntuación
+- `ARCHITECTURE.md` actualizado automáticamente

package/skills/forge/reference/chain.md

@@ -0,0 +1,73 @@
+# Chain
+
+Gestiona las cadenas de dependencias entre features.
+
+## Cuándo usarlo
+
+- Antes de migrar un feature (para conocer sus dependencias)
+- Cuando se detectan imports directos entre features
+- Para determinar el orden topológico de migración
+- Para diagnosticar acoplamiento excesivo
+
+## Reglas
+
+- Nunca imports directos entre features
+- La comunicación entre features siempre via interfaces inyectadas
+- Un feature puede depender de otro, pero nunca al revés (sin ciclos)
+- Las interfaces compartidas se declaran en el feature que las define
+- Dependencias transitivas se inyectan, no se heredan
+
+## Orden topológico
+
+Migrar features en orden de menor a mayor dependencia:
+
+```
+1. Features sin dependencias
+2. Features que dependen solo de shared/
+3. Features que dependen de features ya migrados
+```
+
+## Cómo inyectar dependencias entre features
+
+### Entre features del mismo proyecto
+
+```
+Feature A (credit)
+├── domain/ICreditRepository.ts  ← define la interfaz
+└── adapters/out/CreditRepository.ts  ← implementa
+
+Feature B (payment)  ← necesita CreditRepository
+├── application/PaymentUseCase.ts
+    └── @inject(ICreditRepository) creditRepo
+```
+
+### Registro en bootstrap
+
+```typescript
+container.registerSingleton<ICreditRepository>(
+  ICreditRepository as symbol,
+  CreditRepository
+);
+```
+
+## Detectar dependencias
+
+```bash
+# Grafo de dependencias entre features (API legacy)
+node .opencode/skills/forge/scripts/chain.mjs
+
+# Grafo arquitectónico completo (nodos, edges, violaciones)
+node .opencode/skills/forge/scripts/graph.mjs
+
+# ARCHITECTURE.md con grafo incluido
+node .opencode/skills/forge/scripts/architecture.mjs
+```
+
+`chain.mjs` ahora es un wrapper sobre `graph.mjs`. Produce el mismo formato de salida para compatibilidad (nodos, edges, features, orden topológico). El nuevo `graph.mjs` amplía el análisis a todos los tipos de nodo (core, feature, domain, infra, adapter) y detecta violaciones de reglas arquitectónicas (R1-R6).
+
+## Buenas prácticas
+
+- Mantener el grafo acíclico
+- Si hay ciclo, extraer la interfaz común a shared/
+- Documentar dependencias en ARCHITECTURE.md
+- Revisar dependencias después de cada migración