@ronaldjdevfs/forge 1.3.3 → 1.3.6

package/skills/forge/scripts/detect.mjs

@@ -848,6 +848,67 @@ export function checkPlatform(ctx) {
   return { score: Math.min(score, 15), checks };
 }
 
+/* ── R13: Domain logic in platform ── */
+
+export function checkPlatformForDomain(ctx) {
+  const checks = [];
+  let score = 10;
+
+  if (!ctx.platform || !ctx.platform.exists) {
+    return { score, checks };
+  }
+
+  const DOMAIN_PATTERNS = /\.(entity|uc|mapper|port|repository)\.(ts|js)$/i;
+  const DOMAIN_KEYWORDS = /\b(entity|useCase|use_case|valueObject|domainService|domain_event|dto)\b/i;
+  const LOGIC_KEYWORDS = /\b(if|for|while|switch|catch|throw|return)\s*\(/g;
+
+  const platformDir = join(ROOT, "src", "platform");
+  if (!isDir(platformDir)) return { score: score, checks };
+
+  const allPlatformFiles = findFiles(platformDir, ".ts", 6).concat(findFiles(platformDir, ".js", 6));
+  let violations = 0;
+
+  for (const f of allPlatformFiles) {
+    const relPath = relative(ROOT, f);
+    const basenamePath = basename(f);
+
+    // Check 1: File naming suggests domain artifact
+    if (DOMAIN_PATTERNS.test(basenamePath)) {
+      checks.push({
+        ...severity(`[R13] Platform contiene artefacto de dominio: ${basenamePath}`, SEVERITY.CRITICAL),
+        pass: false,
+        detail: relPath,
+        fix: "Mover a src/features/<name>/domain/ o application/. Platform no debe tener lógica de negocio.",
+      });
+      violations++;
+      score -= 3;
+      continue;
+    }
+
+    // Check 2: Content references domain concepts
+    const content = read(f);
+    if (!content) continue;
+
+    if (DOMAIN_KEYWORDS.test(content)) {
+      checks.push({
+        ...severity(`[R13] Platform contiene terminología de dominio en ${basenamePath}`, SEVERITY.WARNING),
+        pass: false,
+        detail: relPath,
+        fix: "Si contiene lógica de negocio, mover a features/. Si es naming accidental, renombrar.",
+      });
+      violations++;
+      score -= 2;
+    }
+  }
+
+  if (violations === 0 && allPlatformFiles.length > 0) {
+    checks.push({ ...severity("Platform sin lógica de dominio", SEVERITY.INFO), pass: true });
+    score = 10;
+  }
+
+  return { score: Math.max(score, 0), checks };
+}
+
 export function checkDependencies(ctx) {
   const checks = [];
   let score = 0;
@@ -997,6 +1058,111 @@ export function checkNaming(projectRoot = ROOT) {
   return { score: Math.max(score, 0), checks };
 }
 
+export function checkImportConventions(features) {
+  const checks = [];
+  let score = 20;
+
+  if (features.length === 0) return { score: 20, checks };
+
+  const allFeatureFiles = findFiles(FEATURES, ".ts", 6).concat(findFiles(FEATURES, ".js", 6));
+  const allPlatformFiles = isDir(join(SRC, "platform")) ? findFiles(join(SRC, "platform"), ".ts", 6) : [];
+  const files = [...allFeatureFiles, ...allPlatformFiles];
+
+  let r10Violations = 0; // Bare specifiers
+  let r11Violations = 0; // Missing .js extension
+  let r12Violations = 0; // bootstrap.di.js imports
+
+  for (const f of files) {
+    const content = read(f);
+    if (!content) continue;
+    const imports = parseImportsWithLines(content, f);
+
+    for (const imp of imports) {
+      const src = imp.source;
+
+      // R10: Bare specifier — import from "domain/..." (no ./ ../ @/ prefix)
+      if (
+        !src.startsWith("./") &&
+        !src.startsWith("../") &&
+        !src.startsWith("@/") &&
+        !src.startsWith("/") &&
+        src.includes("/") &&
+        !src.startsWith("tsyringe") &&
+        !src.startsWith("reflect-metadata") &&
+        !src.startsWith("express") &&
+        !src.startsWith("node:") &&
+        !src.startsWith("mongoose") &&
+        !src.startsWith("prisma") &&
+        src !== "tsyringe" &&
+        !src.includes("node_modules")
+      ) {
+        r10Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R10] Bare specifier en import local — debe usar ./ o @/`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: `Reemplazar "${src}" por "./${src}.js" (relativo) o "@/shared/${src.split("/").pop()}" (alias)`,
+        });
+        score -= 2;
+      }
+
+      // R11: Import con extensión .ts en vez de .js
+      if (src.endsWith(".ts") && !src.endsWith(".d.ts")) {
+        r11Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R11] Import con extensión .ts — debe usar .js`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: src.replace(/\.ts$/, ".js"),
+        });
+        score -= 2;
+      }
+
+      // R12: Import desde bootstrap.di.js
+      if (src.includes("bootstrap.di")) {
+        r12Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R12] Import desde bootstrap.di.js — no existe en arquitectura actual`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: `Reemplazar por "./di.js" (feature con DI propia) o "@/setting/dependencies/<feature>.di.js" (feature sin DI propia)`,
+        });
+        score -= 3;
+      }
+    }
+
+    // R12b: registerSingleton con model() (Mongoose)
+    if (content.includes("registerSingleton") && content.includes("model(")) {
+      checks.push({
+        severity: SEVERITY.WARNING,
+        label: `[R12] registerSingleton usado con model() — debe usar register({ useValue })`,
+        pass: false,
+        detail: relative(ROOT, f),
+        fix: 'Reemplazar container.registerSingleton(...) por container.register(..., { useValue: ... as any })',
+      });
+      score -= 2;
+    }
+  }
+
+  if (r10Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R10] Sin bare specifiers en imports", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+  if (r11Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R11] Sin imports con extensión .ts", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+  if (r12Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R12] Sin imports a bootstrap.di.js", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+
+  return { score: Math.max(score, 0), checks };
+}
+
 export function allChecks(features, graph, ctx) {
   const g = graph || getGraph();
   const c = ctx || {};
@@ -1006,10 +1172,12 @@ export function allChecks(features, graph, ctx) {
     decorators: checkDecorators(features),
     ownership: checkOwnership(c),
     platform: checkPlatform(c),
+    platformDomain: checkPlatformForDomain(c),
     dependencies: checkDependencies(c),
     graph: checkGraph(g),
     customRules: checkCustomRules(features),
     naming: checkNaming(),
+    importConventions: checkImportConventions(features),
   };
 }
 
@@ -1103,6 +1271,26 @@ export function applyFixes(checks, projectRoot = ROOT) {
       }
     }
 
+    // Fix R11: .ts → .js in import path
+    if (check.label?.includes("[R11]") && check.fix && check.detail) {
+      const filePath = join(projectRoot, check.detail.split(":")[0]);
+      if (existsSync(filePath)) {
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.replace(
+          /(from\s+['"])([^'"]+)\.ts(['"])/g,
+          (match, prefix, path, suffix) => {
+            if (path.endsWith(".d")) return match;
+            return `${prefix}${path}.js${suffix}`;
+          }
+        );
+        if (newContent !== content) {
+          writeFileSync(filePath, newContent);
+          fixed++;
+          details.push(`  ${GREEN}✔${RESET} ${relative(projectRoot, filePath)}: extensión .ts → .js en imports`);
+        }
+      }
+    }
+
     // Fix missing reflect-metadata import
     if (check.fix?.includes('import "reflect-metadata"') && check.detail) {
       const filePath = join(projectRoot, check.detail);

package/skills/forge/scripts/forgeSmith.mjs

@@ -60,11 +60,96 @@ function hasCriticalViolations(result) {
  * Quick check against proposed content.
  * Returns violations that would be introduced by the proposed content.
  */
+/**
+ * Quickly check proposed content for common import violations
+ * before the file is written to disk (preToolUse guard).
+ */
+function checkProposedContentViolations(filePath, content) {
+  const violations = [];
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match import/export from statements
+    const importMatch = line.match(
+      /(?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|[^;{]+?)\s+from\s+['"]([^'"]+)['"]/
+    );
+    if (!importMatch) continue;
+
+    const src = importMatch[1];
+    const lineNum = i + 1;
+
+    // R10: Bare specifier — import from "domain/..." (no ./ ../ @/ prefix)
+    if (
+      !src.startsWith("./") &&
+      !src.startsWith("../") &&
+      !src.startsWith("@/") &&
+      !src.startsWith("/") &&
+      src.includes("/") &&
+      !src.startsWith("tsyringe") &&
+      !src.startsWith("reflect-metadata") &&
+      !src.startsWith("express") &&
+      !src.startsWith("node:") &&
+      !src.startsWith("mongoose") &&
+      !src.startsWith("prisma") &&
+      src !== "tsyringe"
+    ) {
+      violations.push({
+        severity: "CRITICAL",
+        label: `[R10] Bare specifier — debe usar ./ o @/ prefix`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: `Agregar prefijo "./" o "@/" al import`,
+      });
+    }
+
+    // R11: Import con extensión .ts en vez de .js
+    if (src.endsWith(".ts") && !src.endsWith(".d.ts")) {
+      violations.push({
+        severity: "ERROR",
+        label: `[R11] Import con extensión .ts — debe usar .js`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: src.replace(/\.ts$/, ".js"),
+      });
+    }
+
+    // R12: import desde bootstrap.di.js
+    if (src.includes("bootstrap.di")) {
+      violations.push({
+        severity: "CRITICAL",
+        label: `[R12] Import a bootstrap.di.js — no existe en esta arquitectura`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: 'Usar "./di.js" o "@/setting/dependencies/<feature>.di.js"',
+      });
+    }
+  }
+
+  // R12b: registerSingleton con model() (Mongoose)
+  if (content.includes("registerSingleton") && content.includes("model(")) {
+    violations.push({
+      severity: "CRITICAL",
+      label: `[R12] registerSingleton con model() — usar register({ useValue })`,
+      detail: filePath,
+      fix: 'container.register("Token", { useValue: Model as any })',
+    });
+  }
+
+  return violations;
+}
+
 async function checkProposedFile(filePath, content) {
   if (!isSourceFile(filePath)) {
     return { violations: [], total: 0, hasCritical: false, hasErrors: false };
   }
 
+  // Fast pre-check on proposed content (before it hits disk)
+  const contentViolations = checkProposedContentViolations(filePath, content);
+  if (contentViolations.length > 0) {
+    const hasCritical = contentViolations.some(v => v.severity === "CRITICAL");
+    const hasErrors = contentViolations.some(v => v.severity === "ERROR");
+    return { violations: contentViolations, total: contentViolations.length, hasCritical, hasErrors };
+  }
+
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
   const graph = ctx.graph || getGraph();

package/skills/forge/scripts/inspect.mjs

@@ -18,8 +18,10 @@ const CAT_NAMES = {
   layers: "Capas",
   ownership: "Ownership",
   platform: "Platform",
+  platformDomain: "Platform Domain",
   dependencies: "Dependencias",
   graph: "Grafo",
+  importConventions: "Import Conventions",
 };
 
 const CAT_MAX = {
@@ -28,10 +30,12 @@ const CAT_MAX = {
   decorators: 20,
   ownership: 20,
   platform: 15,
+  platformDomain: 10,
   dependencies: 15,
   graph: 20,
   customRules: 5,
   naming: 10,
+  importConventions: 20,
 };
 
 function countBySeverity(checks) {

package/skills/forge/scripts/registry/rules.mjs

@@ -249,6 +249,31 @@ export const RULES = [
       return violations;
     },
   }),
+
+  defineRule({
+    id: "R13",
+    name: "Platform no contiene lógica de dominio",
+    severity: SEVERITY.CRITICAL,
+    category: CATEGORY.STRUCTURE,
+    description: "Platform es backbone técnico y no debe contener entidades, casos de uso, mappers de dominio, schemas de entidades, repositorios de dominio ni ninguna otra lógica de negocio.",
+    fix: "Mover el archivo con lógica de dominio a src/features/<name>/domain/, src/features/<name>/application/, o src/features/<name>/adapters/ según corresponda.",
+    example: "✘ platform/User.entity.ts, platform/payments/ creando lógica de dominio en platform/",
+    check: (graph, ctx) => {
+      const violations = [];
+      if (!ctx || !ctx.platform || !ctx.platform.exists) return violations;
+      for (const comp of (ctx.platform.components || [])) {
+        const lower = comp.toLowerCase();
+        if (lower.endsWith(".entity") || lower.endsWith(".uc") || lower.endsWith(".mapper") || lower.endsWith(".port")) {
+          violations.push({
+            rule: "R13", severity: SEVERITY.CRITICAL,
+            from: `platform:${comp}`, to: "(domain)",
+            description: `Platform contiene artefacto de dominio: "${comp}"`,
+          });
+        }
+      }
+      return violations;
+    },
+  }),
 ];
 
 /**

package/skills/forge/scripts/rename.mjs

@@ -147,6 +147,15 @@ export function computeExpectedName(filePath) {
   // Platform layer
   if (parts[1] === "platform" && parts[2]) {
     const subdir = parts[2];
+    const DOMAIN_SUFFIXES = /\.(entity|uc|mapper|port|repository)\.(ts|js)$/i;
+    if (DOMAIN_SUFFIXES.test(filename)) {
+      return {
+        current: filePath,
+        expected: filePath,
+        relPath: relPath,
+        rule: `[R13] Platform no debe contener artefactos de dominio: "${filename}" pertenece a src/features/<name>/`,
+      };
+    }
     const rule = PLATFORM_RULES[subdir];
     if (!rule) return null;
 

package/skills/forge/scripts/update.mjs

@@ -17,7 +17,7 @@ const ROOT = process.cwd();
 const CACHE_PATH = join(ROOT, ".forge", "version-cache.json");
 const CACHE_TTL = 86400000; // 24h
 const VERSION_URL = "https://forge.dev/latest";
-const CURRENT_VERSION = "1.0.2";
+const CURRENT_VERSION = "1.3.6";
 
 function readJson(path) {
   try {

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

@@ -1,12 +1,20 @@
 ```typescript
 // src/features/<domain>/adapters/in/http/<Domain>.controller.ts
+//
+// IMPORTANTE — Convenciones:
+// 1. Nombres de métodos: usar createHandler (no "add", "store", etc.)
+// 2. Si la entidad <Domain> es compartida desde platform/domain/,
+//    importar con path alias: import type { <Domain> } from "@/domain/entities/<Domain>.js";
+// 3. Si el feature NO tiene di.ts propio, el controller se importa desde
+//    @/setting/dependencies/<domain>.di.js en vez de bootstrap.di.js
+
 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";
+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 {

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

@@ -0,0 +1,33 @@
+```typescript
+// src/features/<domain>/di.ts
+// DI container wiring para el feature <Domain>.
+//
+// NOTA: Si el repositorio exporta un modelo Mongoose (model()) en lugar de una clase,
+// usar container.register() con useValue en vez de registerSingleton.
+//
+// Para entidades compartidas desde platform/domain/, usar path alias @/domain/ en vez de relativo.
+
+import { container } from "tsyringe";
+import type { I<Domain>Repository } from "./domain/repositories/I<Domain>.repository.js";
+import { <Domain>Repository } from "./adapters/out/persistence/<Domain>.repository.js";
+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";
+
+// ── Repositorio ──
+// Si <Domain>Repository es una clase (implementación estándar):
+container.registerSingleton<I<Domain>Repository>("I<Domain>Repository", <Domain>Repository);
+
+// Si <Domain>Repository es un modelo Mongoose (export default model()), usar:
+// import <Domain>Model from "./adapters/out/persistence/<Domain>.schema.js";
+// container.register<I<Domain>Repository>("I<Domain>Repository", { useValue: <Domain>Model as any });
+
+// ── Use Cases ──
+container.registerSingleton(Create<Domain>);
+container.registerSingleton(Get<Domain>);
+container.registerSingleton(List<Domain>);
+container.registerSingleton(Update<Domain>);
+container.registerSingleton(Delete<Domain>);
+```

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

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/application/mappers/<Domain>.mapper.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import type { <Domain> } from "../domain/entities/<Domain>.entity.js";
 
 export class <Domain>Mapper {

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

@@ -1,9 +1,14 @@
 ```typescript
 // src/features/<domain>/adapters/out/persistence/<Domain>.repository.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import { injectable } from "tsyringe";
 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>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/routes.ts.md

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/adapters/in/http/<Domain>.routes.ts
+//
+// IMPORTANTE: Los nombres de método del controller deben coincidir
+// con los invocados aquí. Si el controller usa "add" en vez de "createHandler",
+// ajustar la ruta: router.post("/", controller.add);
+
 import { Router } from "express";
 import { container } from "tsyringe";
 import { <Domain>Controller } from "./<Domain>.controller.js";

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

@@ -12,5 +12,9 @@ const <Domain>Schema = new Schema<<Domain>>(
 
 <Domain>Schema.index({ /* índices */ });
 
+// NOTA DI: model() exporta un objeto Model, NO una clase.
+// En el contenedor DI usar container.register() con useValue, NO registerSingleton:
+//   import <Domain>Model from "./<Domain>.schema.js";
+//   container.register<I<Domain>Repository>("I<Domain>Repository", { useValue: <Domain>Model as any });
 export default model<<Domain>>("<Domain>", <Domain>Schema);
 ```

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

@@ -0,0 +1,68 @@
+```typescript
+// src/features/<domain>/__tests__/Create<Domain>.test.ts
+//
+// Convenciones para tests:
+// - Usar extension .js en imports (ESM + verbatimModuleSyntax)
+// - Usar "as const" para literales que forman parte de union types
+// - Usar "result!" (non-null assertion) cuando execute() retorna T | null
+// - Usar "(result as any)._id" si _id no existe en el tipo de dominio
+
+import { describe, it, before } from "node:test";
+import assert from "node:assert";
+import { Create<Domain> } from "../application/use-cases/Create<Domain>.uc.js";
+import type { I<Domain>Repository } from "../domain/repositories/I<Domain>.repository.js";
+import type { <Domain> } from "../domain/entities/<Domain>.entity.js";
+
+class Mock<Domain>Repository implements I<Domain>Repository {
+  private store: <Domain>[] = [];
+
+  async create(data: Partial<<Domain>>): Promise<<Domain>> {
+    const entity = { id: "1", ...data } as <Domain>;
+    this.store.push(entity);
+    return entity;
+  }
+
+  async findById(id: string): Promise<<Domain> | null> {
+    return this.store.find(e => (e as any).id === id) || null;
+  }
+
+  async findAll(): Promise<{ data: <Domain>[]; total: number }> {
+    return { data: this.store, total: this.store.length };
+  }
+
+  async update(id: string, data: Partial<<Domain>>): Promise<<Domain> | null> {
+    const idx = this.store.findIndex(e => (e as any).id === id);
+    if (idx === -1) return null;
+    this.store[idx] = { ...this.store[idx], ...data };
+    return this.store[idx];
+  }
+
+  async delete(id: string): Promise<void> {
+    this.store = this.store.filter(e => (e as any).id !== id);
+  }
+}
+
+describe("Create<Domain>", () => {
+  let useCase: Create<Domain>;
+  let mockRepo: Mock<Domain>Repository;
+
+  before(() => {
+    mockRepo = new Mock<Domain>Repository();
+    useCase = new Create<Domain>(mockRepo);
+  });
+
+  it("debería crear una entidad <domain>", async () => {
+    const input = { name: "test" as const };
+    const result = await useCase.execute(input);
+    assert.ok(result!);
+    assert.equal((result as any)._id || result!.id, "1");
+  });
+
+  it("debería lanzar error si faltan datos requeridos", async () => {
+    await assert.rejects(
+      () => useCase.execute(null as any),
+      { message: /requeridos|requerid/i }
+    );
+  });
+});
+```

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

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/application/use-cases/Create<Domain>.uc.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import { injectable, inject } from "tsyringe";
 import type { <Domain> } from "../../domain/entities/<Domain>.entity.js";
 import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";

package/skills/forge/tests/core.test.mjs

@@ -233,11 +233,12 @@ describe("formatter.mjs", () => {
 });
 
 describe("registry/rules.mjs", () => {
-  it("has 9 built-in rules (R1-R9)", async () => {
+  it("has 10 built-in rules (R1-R9 + R13)", async () => {
     const { RULES, RULES_BY_ID } = await import("../scripts/registry/rules.mjs");
-    assert.equal(RULES.length, 9);
+    assert.equal(RULES.length, 10);
     assert.ok(RULES_BY_ID.R1);
     assert.ok(RULES_BY_ID.R9);
+    assert.ok(RULES_BY_ID.R13);
     for (const r of RULES) {
       assert.ok(r.id);
       assert.ok(r.name);

package/src/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync, readdirSync } from "fs";
+import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync, readdirSync, statSync } from "fs";
 import { join, dirname, relative } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -43,6 +43,20 @@ function copyRecursive(src, dest) {
   cpSync(src, dest, { recursive: true, force: true });
 }
 
+function renderSkillPaths(skillDest, skillPath) {
+  for (const entry of readdirSync(skillDest)) {
+    const fullPath = join(skillDest, entry);
+    if (statSync(fullPath).isDirectory()) {
+      renderSkillPaths(fullPath, skillPath);
+    } else if (entry.endsWith(".md")) {
+      const content = readFileSync(fullPath, "utf-8");
+      if (content.includes("{{AGENT_PATH}}")) {
+        writeFileSync(fullPath, content.replace(/\{\{AGENT_PATH\}\}/g, skillPath), "utf-8");
+      }
+    }
+  }
+}
+
 function detectPM(configDir) {
   if (existsSync(join(configDir, "pnpm-lock.yaml")) || existsSync(join(process.cwd(), "pnpm-lock.yaml"))) return "pnpm";
   if (existsSync(join(configDir, "bun.lock")) || existsSync(join(configDir, "bun.lockb"))) return "bun";
@@ -143,8 +157,11 @@ async function installOpenCode(isGlobal = false) {
 
   const s = spinner();
 
+  const skillPath = isGlobal ? join("~/.config/opencode", "skills", "forge") : join(".opencode", "skills", "forge");
+
   s.start("Copiando skill a " + rel);
   copyRecursive(SKILL_SRC, target);
+  renderSkillPaths(target, skillPath);
   s.stop("Skill copiada a " + rel);
 
   s.start("Generando comandos /forge-*");
@@ -192,6 +209,9 @@ async function installAgentTemplates(agentDir, agentName) {
     writeFileSync(join(skillDest, "SKILL.md"), rendered, "utf-8");
   }
 
+  // Render {{AGENT_PATH}} in remaining .md files (command/forge.md, reference/*.md)
+  renderSkillPaths(skillDest, config.skillPath);
+
   s.stop(`${agentName} configurado en ${agentDir}/`);
   log.success(`${agentName} listo (skill + ${config.postInstall || "templates"})`);
 }