@ronaldjdevfs/forge 1.3.1 → 1.3.3

package/README.md

@@ -1,6 +1,6 @@
 <img src="favicon.svg" alt="Forge Logo" width="100" height="100">
 
-> **v1.3.1** — Bugfixes, New Templates & Interactive Flags
+> **v1.3.2** — Domain Subdirectory Structure & Port Support
 
 ## Forge — Backend Architecture Operating System
 
@@ -58,8 +58,10 @@ Crea un nuevo feature (vertical slice) con estructura hexagonal completa. Antes
 ```
 src/features/<name>/
 ├── domain/
-│   ├── <Domain>.entity.ts
-│   └── I<Domain>.repository.ts
+│   ├── entities/         (<Domain>.entity.ts)
+│   ├── repositories/     (I<Domain>.repository.ts)
+│   ├── errors/           (<Domain>NotFound.error.ts)
+│   └── events/           (<Domain>Created.event.ts)
 ├── application/
 │   ├── use-cases/     (<Action>.uc.ts)
 │   └── mappers/       (<Domain>.mapper.ts)
@@ -262,6 +264,10 @@ src/
 ├── features/        ← Capacidades de negocio
 │   └── <name>/
 │       ├── domain/
+│       │   ├── entities/       (<Domain>.entity.ts)
+│       │   ├── repositories/   (I<Domain>.repository.ts)
+│       │   ├── errors/         (<Domain>NotFound.error.ts)
+│       │   └── events/         (<Domain>Created.event.ts)
 │       ├── application/
 │       └── adapters/
 │
@@ -291,6 +297,7 @@ src/
 | Directorios | `kebab-case/` | `credit-card/`, `event-bus/` |
 | Archivos | `<PascalCase>.<artefacto>.ts` | `User.entity.ts` |
 | Interfaces | `I<PascalCase>.<artefacto>.ts` | `IUser.repository.ts` |
+| Puertos (domain) | `<Name>.port.ts` | `PaymentPort.port.ts` |
 | Use cases | `<Action>.uc.ts` | `CreateUser.uc.ts` |
 | Clases | `PascalCase` | `UserController` |
 | Funciones | `camelCase` | `formatDate` |
@@ -378,7 +385,7 @@ Donde vive toda la inteligencia arquitectónica:
 | `reference/assay.md` | Documentación del comando assay |
 | `reference/hooks.md` | Documentación del sistema de hooks |
 | `profiles/` | 10 perfiles tecnológicos detallados |
-| `templates/feature/` | 11 templates TypeScript para features |
+| `templates/feature/` | 17 templates TypeScript para features |
 | `templates/platform/` | 6 templates para componentes de platform |
 | `templates/shared/` | 4 templates para shared (errors, contracts, types, utils) |
 | `templates/infra/` | 4 templates para infra (prisma, mongodb, redis, mail) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronaldjdevfs/forge",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Forge — Architecture Operating System for backend systems. Arquitectura Hexagonal, DDD pragmático y vertical slices.",
   "type": "module",
   "bin": {

package/skills/forge/scripts/detect.mjs

@@ -232,17 +232,29 @@ export function checkStructure(features) {
 
     if (hasSubdir(fDir, "domain")) {
       const dDir = join(fDir, "domain");
-      if (hasFile(dDir, /\.entity\.ts$/)) {
-        checks.push({ ...severity(`${feat}: domain/<Name>.entity.ts`, SEVERITY.INFO), pass: true });
+      const entitiesDir = join(dDir, "entities");
+      const reposDir = join(dDir, "repositories");
+
+      // Check domain/entities/ subdirectory (preferred)
+      if (hasSubdir(dDir, "entities") && hasFile(entitiesDir, /\.entity\.ts$/)) {
+        checks.push({ ...severity(`${feat}: domain/entities/<Name>.entity.ts`, SEVERITY.INFO), pass: true });
         featScore += 3;
+      } else if (hasFile(dDir, /\.entity\.ts$/)) {
+        checks.push({ ...severity(`${feat}: domain/<Name>.entity.ts (plano — migrar a domain/entities/)`, SEVERITY.WARNING), pass: false, fix: `Mover a ${feat}/domain/entities/` });
+        featScore += 1;
       } else {
-        checks.push({ ...severity(`${feat}: falta entity en domain/`, SEVERITY.ERROR), pass: false, fix: `Crear ${feat}.entity.ts en ${feat}/domain/` });
+        checks.push({ ...severity(`${feat}: falta entity en domain/`, SEVERITY.ERROR), pass: false, fix: `Crear ${feat}/domain/entities/<Name>.entity.ts` });
       }
-      if (hasFile(dDir, /^I[A-Z]/)) {
-        checks.push({ ...severity(`${feat}: domain/I<Name>Repository.ts`, SEVERITY.INFO), pass: true });
+
+      // Check domain/repositories/ subdirectory (preferred)
+      if (hasSubdir(dDir, "repositories") && hasFile(reposDir, /\.repository\.ts$/)) {
+        checks.push({ ...severity(`${feat}: domain/repositories/I<Name>.repository.ts`, SEVERITY.INFO), pass: true });
         featScore += 2;
+      } else if (hasFile(dDir, /^I[A-Z]/)) {
+        checks.push({ ...severity(`${feat}: domain/I<Name>Repository.ts (plano — migrar a domain/repositories/)`, SEVERITY.WARNING), pass: false, fix: `Mover a ${feat}/domain/repositories/I<Name>.repository.ts` });
+        featScore += 1;
       } else {
-        checks.push({ ...severity(`${feat}: falta repository interface en domain/`, SEVERITY.WARNING), pass: false, fix: `Crear I${feat.charAt(0).toUpperCase() + feat.slice(1)}Repository.ts` });
+        checks.push({ ...severity(`${feat}: falta repository interface en domain/`, SEVERITY.WARNING), pass: false, fix: `Crear ${feat}/domain/repositories/I${feat.charAt(0).toUpperCase() + feat.slice(1)}.repository.ts` });
       }
     } else {
       checks.push({ ...severity(`${feat}: falta domain/`, SEVERITY.ERROR), pass: false, fix: `Crear ${feat}/domain/` });

package/skills/forge/scripts/rename.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "fs";
 import { join, relative, dirname, basename, extname, parse } from "path";
 
 const ROOT = process.cwd();
@@ -40,6 +40,13 @@ function toPascalCase(str) {
     .join("");
 }
 
+function toPascalCaseI(str) {
+  if (/^I[A-Za-z]/.test(str)) {
+    return "I" + toPascalCase(str.slice(1));
+  }
+  return toPascalCase(str);
+}
+
 function toCamelCase(str) {
   const pascal = toPascalCase(str);
   return pascal.charAt(0).toLowerCase() + pascal.slice(1);
@@ -66,7 +73,10 @@ const PLATFORM_RULES = {
 };
 
 const FEATURE_SUBDIR_RULES = [
+  { subdir: "domain/entities", pattern: "entity", case: "pascal", description: "<Name>.entity.ts" },
+  { subdir: "domain/repositories", pattern: "repository", prefix: "I", case: "pascal", description: "I<Name>.repository.ts" },
   { subdir: "domain", pattern: "entity", case: "pascal", description: "<Name>.entity.ts" },
+  { subdir: "domain", pattern: "port", case: "pascal", description: "<Name>.port.ts" },
   { subdir: "domain", pattern: "repository", prefix: "I", case: "pascal", description: "I<Name>.repository.ts" },
   { subdir: "application/use-cases", pattern: "uc", case: "pascal", description: "<Action>.uc.ts" },
   { subdir: "application/mappers", pattern: "mapper", case: "pascal", description: "<Name>.mapper.ts" },
@@ -178,37 +188,73 @@ export function computeExpectedName(filePath) {
       if (featureSubpath === rule.subdir || featureSubpath.startsWith(rule.subdir + "/")) {
         const stemLower = stem.toLowerCase();
 
-        // For domain/entity: <Entity>.entity.ts
-        // Entity name derived from feature dir or current filename
-        if (rule.subdir === "domain" && rule.pattern === "entity") {
+        // For domain/entities/: <Name>.entity.ts
+        if (rule.subdir === "domain/entities") {
           let inferredEntity;
           if (hasSuffix(stem, "entity")) {
             inferredEntity = stem.replace(/\.entity$/i, "");
           } else {
-            const noEntity = stem.replace(/[Ee]ntity$/, "");
-            inferredEntity = noEntity || featureName;
+            inferredEntity = stem;
           }
-          const entityStem = toPascalCase(inferredEntity);
+          const entityStem = toPascalCaseI(inferredEntity);
           const expectedName = `${entityStem}.entity${ext}`;
           if (expectedName !== filename) {
-            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: ${rule.description}` };
+            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain/entities: ${rule.description}` };
           }
         }
 
-        // For domain/repository interface: I<Entity>.repository.ts
-        if (rule.subdir === "domain" && rule.pattern === "repository") {
+        // For domain/repositories/: I<Name>.repository.ts
+        if (rule.subdir === "domain/repositories") {
           const expectedStem = `I${entityName}.repository`;
           const expectedName = `${expectedStem}${ext}`;
           const currentMatches = stem === expectedStem;
           if (!currentMatches) {
+            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain/repositories: ${rule.description}` };
+          }
+        }
+
+        // For flat domain/entity: migrates to domain/entities/<Name>.entity.ts
+        if (rule.subdir === "domain" && rule.pattern === "entity" && featureSubpath === "domain") {
+          let inferredEntity;
+          if (hasSuffix(stem, "entity")) {
+            inferredEntity = stem.replace(/\.entity$/i, "");
+          } else {
+            const noEntity = stem.replace(/[Ee]ntity$/, "");
+            inferredEntity = noEntity || featureName;
+          }
+          const entityStem = toPascalCaseI(inferredEntity);
+          const expectedName = `${entityStem}.entity${ext}`;
+          const expectedPath = join(dirname(filePath), "entities", expectedName);
+          return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "entities", expectedName), rule: `feature/${featureName}/domain → domain/entities: ${rule.description}` };
+        }
+
+        // For domain/port: <Name>.port.ts
+        if (rule.subdir === "domain" && rule.pattern === "port") {
+          let inferredPort;
+          if (hasSuffix(stem, "port")) {
+            inferredPort = stem.replace(/\.port$/i, "");
+          } else {
+            inferredPort = stem;
+          }
+          const portStem = toPascalCaseI(inferredPort);
+          const expectedName = `${portStem}.port${ext}`;
+          if (expectedName !== filename) {
             return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: ${rule.description}` };
           }
-          return null;
+        }
+
+        // For flat domain/repository: migrates to domain/repositories/I<Entity>.repository.ts
+        if (rule.subdir === "domain" && rule.pattern === "repository" && featureSubpath === "domain") {
+          const expectedStem = `I${entityName}.repository`;
+          const expectedName = `${expectedStem}${ext}`;
+          const expectedPath = join(dirname(filePath), "repositories", expectedName);
+          return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "repositories", expectedName), rule: `feature/${featureName}/domain → domain/repositories: ${rule.description}` };
         }
 
         // For use-cases: <Action>.uc.ts
         if (rule.subdir === "application/use-cases") {
-          const expectedName = `${toPascalCase(stem)}.uc${ext}`;
+          const cleanStem = hasSuffix(stem, "uc") ? stem.replace(/\.uc$/i, "") : stem;
+          const expectedName = `${toPascalCase(cleanStem)}.uc${ext}`;
           if (expectedName !== filename) {
             return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/application/use-cases: ${rule.description}` };
           }
@@ -237,15 +283,21 @@ export function computeExpectedName(filePath) {
       }
     }
 
-    // Check domain/ for files that look like entity/repository but don't match (loose files)
+    // Check domain/ for loose files without suffix → migrate to subdirectory
     if (featureSubpath === "domain" && !stem.includes(".")) {
       const lower = stem.toLowerCase();
       if (lower.includes("repository") || stem.startsWith("I")) {
         const expectedName = `I${entityName}.repository${ext}`;
-        return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: I<Name>.repository.ts` };
+        const expectedPath = join(dirname(filePath), "repositories", expectedName);
+        return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "repositories", expectedName), rule: `feature/${featureName}/domain → domain/repositories: I<Name>.repository.ts` };
+      }
+      if (lower.includes("port")) {
+        const expectedName = `${entityName}.port${ext}`;
+        return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: <Name>.port.ts` };
       }
       const expectedName = `${entityName}.entity${ext}`;
-      return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: <Name>.entity.ts` };
+      const expectedPath = join(dirname(filePath), "entities", expectedName);
+      return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "entities", expectedName), rule: `feature/${featureName}/domain → domain/entities: <Name>.entity.ts` };
     }
 
     return null;
@@ -291,13 +343,13 @@ export function computeExpectedName(filePath) {
     if (subdir === "contracts") {
       const hasI = stem.startsWith("I");
       if (hasI) {
-        const fixedStem = toPascalCase(stem);
-        if (fixedStem !== stem) {
-          const expectedName = `${fixedStem}${ext}`;
-          return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `shared/contracts: ${rule.description}` };
-        }
-      } else {
-        const expectedName = `I${toPascalCase(stem)}${ext}`;
+          const fixedStem = toPascalCaseI(stem);
+          if (fixedStem !== stem) {
+            const expectedName = `${fixedStem}${ext}`;
+            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `shared/contracts: ${rule.description}` };
+          }
+        } else {
+          const expectedName = `I${toPascalCaseI(stem)}${ext}`;
         return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `shared/contracts: ${rule.description}` };
       }
     }
@@ -536,6 +588,9 @@ export function renameFile(oldPath, newPath, projectRoot = ROOT) {
     return { success: true, updatedImports: [], note: "El archivo ya tiene el nombre correcto" };
   }
 
+  // Ensure target directory exists
+  mkdirSync(dirname(newPath), { recursive: true });
+
   // Physical rename
   try {
     renameSync(oldPath, newPath);

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

@@ -1,8 +1,8 @@
 ```typescript
 // src/features/<domain>/adapters/out/legacy-<system>/<Domain>ACL.ts
 import { injectable, inject } from "tsyringe";
-import type { I<Domain>Repository } from "../../domain/I<Domain>Repository.js";
-import type { <Domain>Entity } from "../../domain/<Domain>Entity.js";
+import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";
+import type { <Domain>Entity } from "../../domain/entities/<Domain>.entity.js";
 import { <Domain>Gateway } from "./<Domain>Gateway.js";
 import { <Domain>Translator } from "./<Domain>Translator.js";
 

package/skills/forge/templates/feature/acl-translator.ts.md

@@ -1,6 +1,6 @@
 ```typescript
 // src/features/<domain>/adapters/out/legacy-<system>/<Domain>Translator.ts
-import type { <Domain>Entity } from "../../../domain/<Domain>Entity.js";
+import type { <Domain>Entity } from "../../../domain/entities/<Domain>.entity.js";
 import type { External<Domain>DTO } from "./External<Domain>DTO.js";
 
 export class <Domain>Translator {

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

@@ -1,5 +1,5 @@
 ```typescript
-// src/features/<domain>/domain/<Domain>.entity.ts
+// src/features/<domain>/domain/entities/<Domain>.entity.ts
 import type { SomeGlobalType } from "@/shared/types/types.js";
 
 export interface <Domain> {

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

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

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

@@ -1,8 +1,8 @@
 ```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 type { <Domain> } from "../../../domain/entities/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../../domain/repositories/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";

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

@@ -1,6 +1,6 @@
 ```typescript
-// src/features/<domain>/domain/I<Domain>.repository.ts
-import type { <Domain> } from "./<Domain>.entity.js";
+// src/features/<domain>/domain/repositories/I<Domain>.repository.ts
+import type { <Domain> } from "../entities/<Domain>.entity.js";
 
 export interface I<Domain>Repository {
   create(data: Partial<<Domain>>, session?: unknown): Promise<<Domain>>;

package/skills/forge/templates/feature/saga-orchestrator.ts.md

@@ -1,8 +1,8 @@
 ```typescript
 // src/features/<domain>/adapters/out/saga/SagaOrchestrator.ts
 import { injectable, inject } from "tsyringe";
-import type { SagaInstance, SagaStatus } from "../../domain/SagaInstance.entity.js";
-import type { ISagaRepository } from "../../domain/ISagaRepository.js";
+import type { SagaInstance, SagaStatus } from "../../domain/entities/SagaInstance.entity.js";
+import type { ISagaRepository } from "../../domain/repositories/ISagaRepository.repository.js";
 import type { IEventBus } from "@/platform/events/IEventBus.js";
 import type { ILogger } from "@/platform/logger/ILogger.js";
 

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

@@ -1,7 +1,7 @@
 ```typescript
 // src/features/<domain>/adapters/out/persistence/<Domain>.schema.ts
 import { model, Schema } from "mongoose";
-import type { <Domain> } from "../../../domain/<Domain>.entity.js";
+import type { <Domain> } from "../../../domain/entities/<Domain>.entity.js";
 
 const <Domain>Schema = new Schema<<Domain>>(
   {

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

@@ -1,8 +1,8 @@
 ```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 type { <Domain> } from "../../domain/entities/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";
 import { UseCaseError } from "@/shared/errors/UseCaseError.js";
 // Opcional: errores de dominio y eventos
 // import { <Domain>NotFoundError } from "../../domain/errors/<Domain>NotFound.error.js";