@ronaldjdevfs/forge 1.1.0 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
-<img src="logo.png" alt="Forge Logo" width="300" height="300">
+<img src="favicon.svg" alt="Forge Logo" width="100" height="100">
 
-# Forge — Backend Architecture Operating System
+## Forge — Backend Architecture Operating System
 
 **Forge** es un **sistema operativo arquitectónico** para backend. Modela, construye, audita, protege y evoluciona sistemas completos en cuatro dominios arquitectónicos: **Platform**, **Features**, **Shared** e **Infrastructure**.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronaldjdevfs/forge",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Forge — Architecture Operating System for backend systems. Arquitectura Hexagonal, DDD pragmático y vertical slices.",
   "type": "module",
   "bin": {
@@ -39,7 +39,10 @@
     "node": ">=18"
   },
   "main": "./src/cli.js",
-  "dependencies": {},
+  "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "picocolors": "^1.1.1"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/skills/forge/templates/agents/claude/CLAUDE.md

@@ -0,0 +1,98 @@
+# Forge — Backend Architecture Operating System
+
+Forge es un sistema operativo arquitectónico para backend. Diseña, construye, audita y evoluciona arquitecturas basadas en **Arquitectura Hexagonal**, **DDD pragmático** y **vertical slices**.
+
+## Boot Sequence
+
+Ejecutar en orden antes de cualquier acción:
+
+1. `node .opencode/skills/forge/scripts/context.mjs` — stack + layers detection
+2. `node .opencode/skills/forge/scripts/armorer.mjs` — ownership, orphans, duplicates
+3. `node .opencode/skills/forge/scripts/profile.mjs --extended` — tech profile
+4. `node .opencode/skills/forge/scripts/graph.mjs --json` — 4-layer graph
+5. `node .opencode/skills/forge/scripts/chain.mjs --json` — dependency analysis
+6. `node .opencode/skills/forge/scripts/inspect.mjs --json` — full audit
+7. `node .opencode/skills/forge/scripts/architecture.mjs` — update ARCHITECTURE.md
+8. Execute user command (cast, quench, relocate, etc.)
+9. Run architecture.mjs again
+
+## Architecture Model
+
+Cuatro capas obligatorias:
+
+| Layer | Propósito |
+|-------|-----------|
+| `src/platform/` | config, database, http, server, logger, cache, security, events, di |
+| `src/features/<name>/` | domain/, application/use-cases/, application/mappers/, adapters/in/http/, adapters/out/persistence/ |
+| `src/shared/` | errors/, contracts/, types/, utils/ (puro, sin lógica de negocio) |
+| `src/infra/` | prisma/, mongodb/, redis/, mail/ (implementaciones, sin reglas de negocio) |
+
+### Dependency Rules
+
+**Permitido:** `feature → platform`, `feature → shared`, `platform → infra`, `adapter → infra`, `feature → domain`
+
+**Prohibido (CRITICAL):**
+- R1: `feature → infra`
+- R2: `platform → feature`
+- R3: `shared → feature`
+- R4: `shared → infra`
+- R5: `domain → infra`
+- R6: `domain → platform`
+- R7: `infra → feature`
+- R8: cross-feature direct imports
+- R9: cycles
+
+## Naming Conventions
+
+| Elemento | Formato |
+|----------|---------|
+| Directorios | `kebab-case/` |
+| Archivos | `<PascalCase>.<artefacto>.ts` |
+| Interfaces | `I<PascalCase>.<artefacto>.ts` |
+| Use cases | `<Action>.uc.ts` |
+| Clases | `PascalCase` |
+| Funciones/variables | `camelCase` |
+| Constantes | `UPPER_SNAKE_CASE` |
+| Barrel files | `index.ts` con named exports, no `export default` |
+| Imports ESM | con extensión `.js`: `import { X } from "./foo.js"` |
+
+## Commands
+
+| Comando | Acción |
+|---------|--------|
+| `forge` | Init project (context + bootstrap + profile + graph) |
+| `cast` | New feature (verifica platform/shared/infra primero) |
+| `inspect` | Full audit (6 categorías, 110pts → 0-100) |
+| `quench` | Validate dependency rules |
+| `chain` | Topological dependency sort |
+| `graph` | Architecture graph con R1-R9 |
+| `armorer` | Ownership report (orphans, duplicates, misplaced) |
+| `smelt` | Extract code to shared/ |
+| `relocate` | Migrate legacy to platform/, shared/, infra/ or features/ |
+| `reforge` | Refactor considering all 4 layers |
+| `temper` | Harden DI (constructor injection) |
+| `inscribe` | Generate ARCHITECTURE.md |
+
+## Architecture Principles
+
+1. **Hexagonal basado en features** — unidad de organización = feature, no capa técnica
+2. **DDD ligero** — sin sobreingeniería, pragmatismo sobre dogma
+3. **Separación dominio e infraestructura** — domain/ no sabe de frameworks ni BD
+4. **Feature autónomo** — todo lo del dominio vive dentro de `features/<name>/`
+5. **Dependencias unidireccionales** — `adapters → application → domain → (nada)`
+6. **Cero lógica en controllers** — parsean, delegan, responden
+7. **Cero BD fuera de repositories** — única puerta a datos
+8. **DI disciplinada** — constructor injection, sin service locators
+9. **Errores tipados** — clases explícitas, no `throw Error()`
+10. **Grafo arquitectónico vivo** — todo componente es un nodo, toda relación un edge validado
+
+## Key Files
+
+- `skills/forge/SKILL.md` — orchestrator principal
+- `skills/forge/reference/principles.md` — manifiesto y 15 principios
+- `skills/forge/reference/patterns.md` — naming conventions
+- `skills/forge/scripts/` — context, detect, inspect, chain, profile, graph, architecture, armorer, bootstrap
+- `skills/forge/profiles/` — 10 tech profiles (express, fastify, nestjs × mongodb, postgres, prisma, drizzle)
+- `skills/forge/templates/` — templates para feature, platform, shared, infra
+- `AGENTS.md` — guía para agentes de IA
+- `ARCHITECTURE.md` — estado actual de la arquitectura

package/skills/forge/templates/agents/cursor/.cursorrules

@@ -0,0 +1,80 @@
+You are an AI assistant for a project that uses Forge — a Backend Architecture Operating System. Tu función es ayudar a diseñar, construir, auditar y evolucionar la arquitectura usando Arquitectura Hexagonal, DDD pragmático y vertical slices.
+
+## Architecture Model
+
+The project uses four mandatory layers:
+
+```
+src/
+├── platform/          # Config, database, http, server, logger, cache, security, events, di
+├── features/<name>/   # domain/, application/use-cases/, application/mappers/, adapters/in/http/, adapters/out/persistence/
+├── shared/            # errors/, contracts/, types/, utils/ (pure code, no business logic)
+└── infra/             # prisma/, mongodb/, redis/, mail/ (implementations, no business rules)
+```
+
+## Dependency Rules (CRITICAL — never violate)
+
+**Allowed:** `feature → platform`, `feature → shared`, `platform → infra`, `adapter → infra`, `feature → domain`
+
+**Prohibited:**
+- R1: `feature → infra`
+- R2: `platform → feature`
+- R3: `shared → feature`
+- R4: `shared → infra`
+- R5: `domain → infra`
+- R6: `domain → platform`
+- R7: `infra → feature`
+- R8: cross-feature direct imports
+- R9: cycles
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Directories | `kebab-case/` | `credit-card/` |
+| Files | `<PascalCase>.<artifact>.ts` | `User.entity.ts` |
+| Interfaces | `I<PascalCase>.<artifact>.ts` | `IUser.repository.ts` |
+| Use cases | `<Action>.uc.ts` | `CreateUser.uc.ts` |
+| Classes | `PascalCase` | `UserController` |
+| Functions/vars | `camelCase` | `formatDate` |
+| Constants | `UPPER_SNAKE_CASE` | `MAX_RETRY_COUNT` |
+| Barrels | `index.ts` | named exports only, no `export default` |
+| ESM imports | with `.js` extension | `import { X } from "./foo.js"` |
+
+## Code Principles
+
+1. **Zero business logic in controllers** — parse, delegate, respond
+2. **Zero DB access outside repositories** — only repositories touch the database
+3. **Constructor injection only** — no service locators, no `container.resolve()` in business logic
+4. **Typed domain errors** — explicit error classes, never generic `throw Error()`
+5. **Unidirectional dependencies** — `adapters → application → domain → (nothing)`
+6. **Domain knows nothing about infrastructure** — no framework, database, or external service imports in domain/
+7. **Features are autonomous** — no direct imports between features, only via injected interfaces
+8. **Explicit over magic** — prefer explicit imports and declared types over hidden decorators
+
+## Available Commands
+
+| Command | Action |
+|---------|--------|
+| `forge` | Initialize project |
+| `cast` | Create new feature |
+| `inspect` | Full architecture audit |
+| `quench` | Validate dependency rules |
+| `chain` | Dependency graph (topological) |
+| `graph` | Architecture graph with rules |
+| `armorer` | Ownership report |
+| `smelt` | Extract to shared/ |
+| `relocate` | Migrate legacy code |
+| `reforge` | Refactor architecture |
+| `temper` | Harden dependency injection |
+| `inscribe` | Generate ARCHITECTURE.md |
+
+## Key Files Reference
+
+- `skills/forge/SKILL.md` — orchestrator
+- `skills/forge/reference/principles.md` — 15 principles
+- `skills/forge/reference/patterns.md` — naming conventions
+- `skills/forge/scripts/` — all engine scripts
+- `skills/forge/profiles/` — tech profiles
+- `AGENTS.md` — agent guide
+- `ARCHITECTURE.md` — current architecture state

package/src/agents.mjs

@@ -0,0 +1,55 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOME = homedir();
+
+function detect(cwd) {
+  const agents = [];
+
+  agents.push({
+    id: "claude-global",
+    label: "Claude Code",
+    scope: "Global",
+    detected: existsSync(join(HOME, ".claude")) || existsSync(join(HOME, ".config", "claude")),
+  });
+
+  agents.push({
+    id: "claude-project",
+    label: "Claude Code",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".claude")) || existsSync(join(cwd, "CLAUDE.md")),
+  });
+
+  agents.push({
+    id: "opencode-global",
+    label: "OpenCode",
+    scope: "Global",
+    detected: existsSync(join(HOME, ".config", "opencode")),
+  });
+
+  agents.push({
+    id: "opencode-project",
+    label: "OpenCode",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".opencode")),
+  });
+
+  agents.push({
+    id: "copilot-project",
+    label: "GitHub Copilot",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".github", "copilot-instructions.md")),
+  });
+
+  agents.push({
+    id: "codex",
+    label: "Codex CLI",
+    scope: "Global",
+    detected: existsSync(join(HOME, ".codex")),
+  });
+
+  return agents;
+}
+
+export { detect as detectForWizard };

package/src/cli.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 
-import { copyFileSync, mkdirSync, existsSync, readdirSync, statSync, writeFileSync, readFileSync } from "fs";
+import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync } from "fs";
 import { join, dirname, relative } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
+import { spinner, log } from "@clack/prompts";
+import { runWizard } from "./wizard.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PKG_DIR = join(__dirname, "..");
-const SKILL_SRC = join(PKG_DIR, "skills", "forge");
+const SKILL_SRC = join(__dirname, "..", "skills", "forge");
+const AGENTS_TEMPLATES = join(SKILL_SRC, "templates", "agents");
 
 function getTargetDir(global) {
   if (global) {
@@ -30,16 +32,7 @@ function getConfigDir(global) {
 }
 
 function copyRecursive(src, dest) {
-  mkdirSync(dest, { recursive: true });
-  for (const entry of readdirSync(src)) {
-    const srcPath = join(src, entry);
-    const destPath = join(dest, entry);
-    if (statSync(srcPath).isDirectory()) {
-      copyRecursive(srcPath, destPath);
-    } else {
-      copyFileSync(srcPath, destPath);
-    }
-  }
+  cpSync(src, dest, { recursive: true, force: true });
 }
 
 function detectPM(configDir) {
@@ -62,7 +55,6 @@ function ensureDependencies(configDir) {
   if (!pkg.dependencies["@opencode-ai/plugin"]) {
     pkg.dependencies["@opencode-ai/plugin"] = "1.17.9";
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-    console.log(`  ✓ Actualizado ${relative(process.cwd(), pkgPath)}`);
   }
 
   const pm = detectPM(configDir);
@@ -74,30 +66,28 @@ function ensureDependencies(configDir) {
 
   try {
     runPM(pm);
-    console.log(`  ✓ Dependencias instaladas (${pm})`);
   } catch {
     for (const fallback of order[pm]) {
       try {
         runPM(fallback);
-        console.log(`  ✓ Dependencias instaladas (${fallback})`);
         return;
-      } catch {}
+      } catch { }
     }
-    console.warn("  ⚠ No se pudieron instalar dependencias. Ejecuta 'pnpm install' | 'npm install' manualmente en " + configDir);
+    log.warn("No se pudieron instalar dependencias. Ejecutá 'pnpm install' | 'npm install' manualmente en " + configDir);
   }
 }
 
 const COMMANDS = [
-  { name: "forge-forge",   desc: "Forge — inicializar proyecto arquitectónicamente" },
-  { name: "forge-cast",    desc: "Cast — crear un nuevo feature hexagonal desde cero" },
+  { name: "forge-forge", desc: "Forge — inicializar proyecto arquitectónicamente" },
+  { name: "forge-cast", desc: "Cast — crear un nuevo feature hexagonal desde cero" },
   { name: "forge-inspect", desc: "Inspect — inspeccionar la conformidad arquitectónica" },
-  { name: "forge-relocate",desc: "Relocate — migrar feature legacy a la nueva estructura" },
+  { name: "forge-relocate", desc: "Relocate — migrar feature legacy a la nueva estructura" },
   { name: "forge-reforge", desc: "Reforge — refactorizar la arquitectura de un feature" },
-  { name: "forge-quench",  desc: "Quench — verificar reglas arquitectónicas del proyecto" },
-  { name: "forge-temper",  desc: "Temper — endurecer la arquitectura (DI, seguridad)" },
-  { name: "forge-chain",   desc: "Chain — analizar cadena de dependencias entre features" },
-  { name: "forge-inscribe",desc: "Inscribe — generar y mantener ARCHITECTURE.md" },
-  { name: "forge-smelt",   desc: "Smelt — extraer código reutilizable a shared/" },
+  { name: "forge-quench", desc: "Quench — verificar reglas arquitectónicas del proyecto" },
+  { name: "forge-temper", desc: "Temper — endurecer la arquitectura (DI, seguridad)" },
+  { name: "forge-chain", desc: "Chain — analizar cadena de dependencias entre features" },
+  { name: "forge-inscribe", desc: "Inscribe — generar y mantener ARCHITECTURE.md" },
+  { name: "forge-smelt", desc: "Smelt — extraer código reutilizable a shared/" },
 ];
 
 function generateCommands(configDir) {
@@ -116,46 +106,111 @@ function generateCommands(configDir) {
     ].join("\n");
     writeFileSync(join(cmdsDir, `${cmd.name}.md`), content);
   }
-  console.log(`  ✓ Comandos /forge-* generados en .opencode/commands/`);
 }
 
-function printHelp() {
-  console.log(`
-Forge — Architecture OS
-
-USO
-  forge install                    Instalar skill en el proyecto actual
-  forge install --global           Instalar globalmente (~/.config/opencode/)
-  forge skills install             (alias del comando install)
-
-OPCIONES
-  -g, --global                     Instalar en ~/.config/opencode/skills/forge/
-  -h, --help                       Mostrar esta ayuda
-`);
-}
+// --- Direct installers ---
 
-function install(global) {
+async function installOpenCode(isGlobal = false) {
   if (!existsSync(SKILL_SRC)) {
-    console.error("[ERROR] No se encuentra skills/forge/ en el paquete. ¿Corrupto?");
+    log.error("No se encuentra skills/forge/ en el paquete. ¿Corrupto?");
     process.exit(1);
   }
 
-  const target = getTargetDir(global);
-  const configDir = getConfigDir(global);
+  const target = getTargetDir(isGlobal);
+  const configDir = getConfigDir(isGlobal);
+  const rel = relative(process.cwd(), target);
 
-  console.log(`\n  Forge — Architecture OS`);
-  console.log(`  ${"=".repeat(40)}`);
-  console.log(`  Destino: ${target}\n`);
+  const s = spinner();
 
+  s.start("Copiando skill a " + rel);
   copyRecursive(SKILL_SRC, target);
-  console.log(`  ✓ Skill copiada a ${relative(process.cwd(), target)}`);
+  s.stop("Skill copiada a " + rel);
+
+  s.start("Generando comandos /forge-*");
   generateCommands(configDir);
+  s.stop("Comandos generados en " + relative(process.cwd(), join(configDir, "commands")));
+
+  s.start("Instalando dependencias");
   ensureDependencies(configDir);
-  console.log(`\n  ✓ Forge instalado correctamente`);
-  console.log(`  ${"=".repeat(40)}\n`);
+  s.stop("Dependencias instaladas");
+
+  log.success("OpenCode configurado correctamente");
+}
+
+async function installCursor() {
+  const src = join(AGENTS_TEMPLATES, "cursor", ".cursorrules");
+  const dest = join(process.cwd(), ".cursorrules");
+
+  if (!existsSync(src)) {
+    log.error("Template .cursorrules no encontrado");
+    process.exit(1);
+  }
+
+  const s = spinner();
+  s.start("Creando .cursorrules");
+  copyFileSync(src, dest);
+  s.stop(".cursorrules creado");
+
+  log.success("Cursor configurado correctamente");
 }
 
-function main() {
+async function installClaude() {
+  const claudeDir = join(process.cwd(), ".claude");
+  const src = join(AGENTS_TEMPLATES, "claude", "CLAUDE.md");
+  const dest = join(claudeDir, "CLAUDE.md");
+
+  if (!existsSync(src)) {
+    log.error("Template CLAUDE.md no encontrado");
+    process.exit(1);
+  }
+
+  const s = spinner();
+  s.start("Creando .claude/CLAUDE.md");
+  mkdirSync(claudeDir, { recursive: true });
+  copyFileSync(src, dest);
+  s.stop(".claude/CLAUDE.md creado");
+
+  log.success("Claude Code configurado correctamente");
+}
+
+async function installAgents(selected, isGlobal = false) {
+  for (const agent of selected) {
+    switch (agent) {
+      case "opencode":
+        await installOpenCode(isGlobal);
+        break;
+      case "cursor":
+        await installCursor();
+        break;
+      case "claude":
+        await installClaude();
+        break;
+    }
+  }
+}
+
+// --- CLI ---
+
+function printHelp() {
+  console.log(`
+⚔️ Forge — Architecture OS
+
+USO
+  forge install                    Mostrar wizard interactivo de instalación
+  forge install --opencode         Instalar solo para OpenCode
+  forge install --cursor           Instalar solo para Cursor
+  forge install --claude           Instalar solo para Claude Code
+  forge install --all              Instalar para todos los agentes
+  forge install --global           Instalar OpenCode globalmente (~/.config/opencode/)
+  forge install --help             Mostrar esta ayuda
+
+OPCIONES
+  -g, --global                     Instalar OpenCode en ~/.config/opencode/skills/forge/
+  -h, --help                       Mostrar esta ayuda
+`);
+}
+
+async function main() {
   const args = process.argv.slice(2);
   const isHelp = args.includes("-h") || args.includes("--help");
   const isGlobal = args.includes("-g") || args.includes("--global");
@@ -165,15 +220,33 @@ function main() {
     return;
   }
 
+  const hasOpenCode = args.includes("--opencode");
+  const hasCursor   = args.includes("--cursor");
+  const hasClaude   = args.includes("--claude");
+  const hasAll      = args.includes("--all");
+
   const subcommandIndex = args.indexOf("skills");
   const command = subcommandIndex !== -1 ? args[subcommandIndex + 1] : args[0];
 
   if (command === "install") {
-    install(isGlobal);
+    if (hasAll) {
+      await installAgents(["opencode", "cursor", "claude"], isGlobal);
+    } else if (hasOpenCode || hasCursor || hasClaude) {
+      const selected = [];
+      if (hasOpenCode) selected.push("opencode");
+      if (hasCursor) selected.push("cursor");
+      if (hasClaude) selected.push("claude");
+      await installAgents(selected, isGlobal);
+    } else {
+      await runWizard();
+    }
   } else {
     printHelp();
     process.exit(1);
   }
 }
 
-main();
+main().catch((err) => {
+  console.error("[ERROR]", err.message);
+  process.exit(1);
+});

package/src/wizard.mjs

@@ -0,0 +1,474 @@
+import pc from "picocolors";
+import { intro, outro, select, multiselect, text, spinner, isCancel, cancel, log, tasks } from "@clack/prompts";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, cpSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { detectForWizard } from "./agents.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILL_SRC = join(__dirname, "..", "skills", "forge");
+const AGENTS_TEMPLATES = join(SKILL_SRC, "templates", "agents");
+const HOME = homedir();
+
+const SEP = pc.dim("\u2500".repeat(46));
+
+function printCenter(text, pad = 20) {
+  console.log(" ".repeat(pad) + text);
+}
+
+// --- Installer helpers ---
+
+function detectPM(cwd) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+
+function ensureDependencies(cwd) {
+  const pkgPath = join(cwd, "package.json");
+  let pkg = {};
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    } catch {
+      pkg = {};
+    }
+  }
+  if (!pkg.dependencies) pkg.dependencies = {};
+  if (!pkg.dependencies["@opencode-ai/plugin"]) {
+    pkg.dependencies["@opencode-ai/plugin"] = "1.17.9";
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  const pm = detectPM(cwd);
+  const order = { pnpm: ["npm", "bun"], npm: ["bun", "pnpm"], bun: ["npm", "pnpm"] };
+  function runPM(bin) { execSync(`${bin} install`, { cwd, stdio: "pipe" }); }
+  try { runPM(pm); }
+  catch {
+    for (const fb of order[pm]) {
+      try { runPM(fb); return; } catch { }
+    }
+    log.warn("No se pudieron instalar dependencias. Ejecut\u00e1 'pnpm install' manualmente.");
+  }
+}
+
+function generateCommands(configDir) {
+  const COMMANDS = [
+    { name: "forge-forge", desc: "Forge \u2014 inicializar proyecto arquitect\u00f3nicamente" },
+    { name: "forge-cast", desc: "Cast \u2014 crear un nuevo feature hexagonal" },
+    { name: "forge-inspect", desc: "Inspect \u2014 auditor\u00eda arquitect\u00f3nica" },
+    { name: "forge-relocate", desc: "Relocate \u2014 migrar feature legacy" },
+    { name: "forge-reforge", desc: "Reforge \u2014 refactorizar arquitectura" },
+    { name: "forge-quench", desc: "Quench \u2014 verificar reglas arquitect\u00f3nicas" },
+    { name: "forge-temper", desc: "Temper \u2014 endurecer arquitectura" },
+    { name: "forge-chain", desc: "Chain \u2014 cadena de dependencias" },
+    { name: "forge-inscribe", desc: "Inscribe \u2014 generar ARCHITECTURE.md" },
+    { name: "forge-smelt", desc: "Smelt \u2014 extraer c\u00f3digo a shared/" },
+  ];
+  const cmdsDir = join(configDir, "commands");
+  mkdirSync(cmdsDir, { recursive: true });
+  for (const cmd of COMMANDS) {
+    const sub = cmd.name.replace("forge-", "");
+    const content = [
+      "---",
+      `description: ${cmd.desc}`,
+      "agent: build",
+      "---",
+      "",
+      `Ejecuta el subcomando ${sub} de Forge con los argumentos: $ARGUMENTS`,
+      "",
+    ].join("\n");
+    writeFileSync(join(cmdsDir, `${cmd.name}.md`), content);
+  }
+}
+
+function copyAgentTemplate(name, dest) {
+  const src = join(AGENTS_TEMPLATES, name);
+  if (!existsSync(src)) return;
+  for (const entry of readdirSync(src)) {
+    const srcFile = join(src, entry);
+    const destFile = join(dest, entry);
+    if (existsSync(srcFile)) cpSync(srcFile, destFile, { recursive: true, force: true });
+  }
+}
+
+// --- Welcome ---
+
+async function welcomePhase() {
+  console.clear();
+  printCenter(pc.bold(pc.cyan("\u2694 Forge")), 22);
+  console.log();
+  printCenter(pc.dim("Sistema Operativo de Arquitectura"), 17);
+  console.log();
+  console.log("  " + SEP);
+  console.log();
+  console.log("  Bienvenido a Forge.");
+  console.log();
+  console.log("  Forge instalar\u00e1 la Skill de Arquitectura");
+  console.log("  en uno o varios agentes de IA compatibles.");
+  console.log();
+
+  const result = await text({
+    message: "Presiona Enter para continuar",
+    placeholder: "",
+    initialValue: "",
+  });
+
+  if (isCancel(result)) {
+    cancel("Cancelado, no pasa nada");
+    process.exit(0);
+  }
+}
+
+// --- Detection ---
+
+async function detectionPhase(cwd) {
+  console.clear();
+  log.message(pc.cyan("\u2694 Detectando agentes compatibles..."));
+
+  const s = spinner();
+  s.start("Buscando instalaciones...");
+
+  const agents = detectForWizard(cwd);
+  s.stop("B\u00fasqueda completada");
+  console.log();
+
+  const detectedCount = agents.filter((a) => a.detected).length;
+
+  for (const agent of agents) {
+    const label = agent.label.padEnd(20);
+    const scope = agent.scope;
+    if (agent.detected) {
+      console.log(`  ${pc.green("\u2714")} ${label}${pc.dim(scope)}`);
+    } else {
+      console.log(`  ${pc.red("\u2718")} ${label}${pc.dim(scope)}`);
+    }
+  }
+
+  console.log();
+  log.success(`Se encontraron ${detectedCount} instalaciones compatibles.`);
+  console.log();
+
+  await text({
+    message: "Presiona Enter para continuar",
+    placeholder: "",
+    initialValue: "",
+  });
+
+  return agents;
+}
+
+// --- Agent selection ---
+
+async function selectionPhase(agents) {
+  console.clear();
+  log.message(pc.cyan("\u2694 Selecciona los agentes"));
+  console.log();
+
+  const options = agents.map((a) => ({
+    value: a.id,
+    label: `${a.label} (${a.scope})`,
+    hint: a.detected ? "disponible" : undefined,
+  }));
+
+  options.push({ value: "__custom__", label: "Ruta personalizada" });
+
+  const selected = await multiselect({
+    message: "Espacio = seleccionar  |  Enter = continuar",
+    options,
+    required: false,
+  });
+
+  if (isCancel(selected)) {
+    cancel("Cancelado, no pasa nada");
+    process.exit(0);
+  }
+
+  let customPath = null;
+  if (selected.includes("__custom__")) {
+    customPath = await text({
+      message: "\u00bfD\u00f3nde deseas instalar Forge?",
+      placeholder: "/home/usuario/.claude",
+      validate: (v) => (v ? undefined : "La ruta es requerida"),
+    });
+
+    if (isCancel(customPath)) {
+      cancel("Cancelado, no pasa nada");
+      process.exit(0);
+    }
+
+    if (existsSync(customPath)) {
+      log.success("Ruta v\u00e1lida");
+    } else {
+      log.info("La ruta no existe, se crear\u00e1 al instalar");
+    }
+  }
+
+  return { selectedIds: selected.filter((id) => id !== "__custom__"), customPath };
+}
+
+// --- Summary ---
+
+async function summaryPhase(agentSelection) {
+  const allAgents = detectForWizard(process.cwd());
+  const selectedAgents = agentSelection.selectedIds
+    .map((id) => allAgents.find((a) => a.id === id))
+    .filter(Boolean);
+
+  while (true) {
+    console.clear();
+    log.message(pc.cyan("\u2694 Resumen"));
+    console.log("  " + SEP);
+    console.log();
+    console.log(`  ${pc.bold("Agentes")}`);
+    console.log();
+
+    for (const agent of selectedAgents) {
+      console.log(`  \u2022 ${agent.label} ${pc.dim(`(${agent.scope})`)}`);
+    }
+    if (agentSelection.customPath) {
+      console.log(`  \u2022 Ruta personalizada ${pc.dim(`(${agentSelection.customPath})`)}`);
+    }
+
+    console.log();
+    console.log(`  ${pc.bold("Componentes")}`);
+    console.log();
+
+    const components = [
+      "Forge Skill",
+      "Reglas",
+      "Prompts",
+      "Comandos",
+      "Plantillas",
+      "Agentes",
+    ];
+    for (const comp of components) {
+      console.log(`  ${pc.green("\u2714")} ${comp}`);
+    }
+
+    console.log();
+    console.log("  " + SEP);
+    console.log();
+
+    const action = await select({
+      message: "\u00bfDeseas continuar?",
+      options: [
+        { value: "install", label: "Instalar" },
+        { value: "back", label: "Volver" },
+        { value: "cancel", label: "Cancelar" },
+      ],
+    });
+
+    if (isCancel(action) || action === "cancel") {
+      cancel("Cancelado, no pasa nada");
+      process.exit(0);
+    }
+
+    if (action === "back") {
+      return "back";
+    }
+
+    return { action: "install", selectedAgents, customPath: agentSelection.customPath };
+  }
+}
+
+// --- Installation ---
+
+function buildAgentSteps(agent, cwd) {
+  const label = `${agent.label} (${agent.scope})`;
+  const s = (title, fn) => ({ title: `${pc.dim("\u2502")} ${title}`, task: fn });
+
+  switch (agent.id) {
+    case "claude-global":
+    case "claude-project": {
+      const dest = agent.id === "claude-global" ? join(HOME, ".claude") : join(cwd, ".claude");
+      const steps = [];
+      steps.push(s("Copiando Forge en .claude/", async () => {
+        mkdirSync(dest, { recursive: true });
+        copyAgentTemplate("claude", dest);
+        cpSync(SKILL_SRC, join(dest, "forge"), { recursive: true, force: true });
+        return "Forge instalado en .claude/";
+      }));
+      steps.push(s("Verificando instalaci\u00f3n", async () => {
+        const ok = existsSync(join(dest, "CLAUDE.md"));
+        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: CLAUDE.md no encontrado";
+      }));
+      return { label, dest, steps };
+    }
+
+    case "opencode-global": {
+      const dest = join(HOME, ".config", "opencode", "skills", "forge");
+      const configDir = join(HOME, ".config", "opencode");
+      const steps = [];
+      steps.push(s("Copiando Skill en opencode/", async () => {
+        mkdirSync(dest, { recursive: true });
+        cpSync(SKILL_SRC, dest, { recursive: true, force: true });
+        return "Skill copiada";
+      }));
+      steps.push(s("Registrando comandos + dependencias", async () => {
+        generateCommands(configDir);
+        ensureDependencies(configDir);
+        return "Comandos y dependencias listos";
+      }));
+      steps.push(s("Verificando instalaci\u00f3n", async () => {
+        const ok = existsSync(join(dest, "scripts", "context.mjs"));
+        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
+      }));
+      return { label, dest, steps };
+    }
+
+    case "opencode-project": {
+      const dest = join(cwd, ".opencode", "skills", "forge");
+      const configDir = join(cwd, ".opencode");
+      const steps = [];
+      steps.push(s("Copiando Skill en .opencode/", async () => {
+        mkdirSync(dest, { recursive: true });
+        cpSync(SKILL_SRC, dest, { recursive: true, force: true });
+        return "Skill copiada";
+      }));
+      steps.push(s("Registrando comandos + dependencias", async () => {
+        generateCommands(configDir);
+        ensureDependencies(configDir);
+        return "Comandos y dependencias listos";
+      }));
+      steps.push(s("Verificando instalaci\u00f3n", async () => {
+        const ok = existsSync(join(dest, "scripts", "context.mjs"));
+        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
+      }));
+      return { label, dest, steps };
+    }
+
+    case "copilot-project": {
+      const ghDir = join(cwd, ".github");
+      const dest = join(ghDir, "copilot-instructions.md");
+      const steps = [];
+      steps.push(s("Instalando reglas en .github/", async () => {
+        mkdirSync(ghDir, { recursive: true });
+        const src = join(AGENTS_TEMPLATES, "cursor", ".cursorrules");
+        if (existsSync(src)) copyFileSync(src, dest);
+        const ok = existsSync(dest);
+        return ok ? "Reglas instaladas" : "ERROR";
+      }));
+      return { label, dest, steps };
+    }
+
+    case "codex": {
+      const dest = join(HOME, ".codex");
+      const steps = [];
+      steps.push(s("Instalando Forge en .codex/", async () => {
+        mkdirSync(dest, { recursive: true });
+        copyAgentTemplate("cursor", dest);
+        cpSync(SKILL_SRC, join(dest, "forge"), { recursive: true, force: true });
+        return "Forge instalado";
+      }));
+      steps.push(s("Verificando instalaci\u00f3n", async () => {
+        return existsSync(dest) ? "\u2714 Instalaci\u00f3n verificada" : "ERROR";
+      }));
+      return { label, dest, steps };
+    }
+
+    default:
+      return null;
+  }
+}
+
+async function installPhase(result, cwd) {
+  console.clear();
+  log.message(pc.cyan("\u2694 Instalando Forge..."));
+
+  const agentsData = [];
+  for (const agent of result.selectedAgents) {
+    const data = buildAgentSteps(agent, cwd);
+    if (data) agentsData.push(data);
+  }
+
+  if (result.customPath) {
+    const dest = result.customPath;
+    const steps = [];
+    const s = (title, fn) => ({ title: `${pc.dim("\u2502")} ${title}`, task: fn });
+    steps.push(s("Instalando Forge en ruta personalizada", async () => {
+      mkdirSync(dest, { recursive: true });
+      cpSync(SKILL_SRC, join(dest, "forge"), { recursive: true, force: true });
+      copyAgentTemplate("claude", dest);
+      return "Forge instalado";
+    }));
+    steps.push(s("Verificando instalaci\u00f3n", async () => {
+      return existsSync(join(dest, "forge")) ? "\u2714 Instalaci\u00f3n verificada" : "ERROR";
+    }));
+    agentsData.push({ label: `Ruta personalizada (${dest})`, dest, steps });
+  }
+
+  const allSteps = [];
+  for (const ad of agentsData) {
+    allSteps.push({
+      title: pc.bold(pc.cyan(ad.label)),
+      task: async () => `Instalando en ${ad.dest}`,
+    });
+    for (const step of ad.steps) {
+      allSteps.push(step);
+    }
+  }
+
+  await tasks(allSteps);
+}
+
+// --- Main wizard orchestrator ---
+
+export async function runWizard() {
+  const cwd = process.cwd();
+
+  await welcomePhase();
+
+  console.clear();
+  intro(pc.cyan("\u2694 Forge"));
+
+  const agents = await detectionPhase(cwd);
+
+  let agentSelection;
+  let result;
+
+  while (true) {
+    agentSelection = await selectionPhase(agents);
+
+    if (agentSelection.selectedIds.length === 0 && !agentSelection.customPath) {
+      log.warn("Seleccion\u00e1 al menos un agente o una ruta personalizada.");
+      continue;
+    }
+
+    result = await summaryPhase(agentSelection);
+
+    if (result === "back") continue;
+    break;
+  }
+
+  await installPhase(result, cwd);
+
+  console.log();
+  console.log("  " + SEP);
+  printCenter(pc.bold(pc.cyan("\u2694 Forge")), 22);
+  console.log();
+  printCenter(pc.green("Instalaci\u00f3n completada correctamente."), 12);
+  console.log();
+  console.log(`  Forge se instal\u00f3 en:`);
+  console.log();
+
+  for (const agent of result.selectedAgents) {
+    console.log(`  ${pc.green("\u2714")} ${agent.label} ${pc.dim(`(${agent.scope})`)}`);
+  }
+  if (result.customPath) {
+    console.log(`  ${pc.green("\u2714")} Ruta personalizada ${pc.dim(`(${result.customPath})`)}`);
+  }
+
+  console.log();
+  console.log(`  ${pc.bold("Pr\u00f3ximos pasos")}`);
+  console.log();
+  console.log(`  \u2022 Reinicia tu agente si est\u00e1 abierto.`);
+  console.log(`  \u2022 Ejecut\u00e1 el comando "forge" dentro del agente.`);
+  console.log(`  \u2022 Consult\u00e1 la documentaci\u00f3n para comenzar.`);
+  console.log();
+  console.log("  " + SEP);
+  console.log();
+
+  outro(pc.cyan("\u00a1Forge est\u00e1 listo para usar! \u2694"));
+}