@ronaldjdevfs/forge 1.1.0 → 1.3.0-beta

package/src/cli.js

@@ -1,13 +1,23 @@
 #!/usr/bin/env node
 
-import { copyFileSync, mkdirSync, existsSync, readdirSync, statSync, writeFileSync, readFileSync } from "fs";
+import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync, readdirSync } 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");
+
+const AGENT_CONFIGS = {
+  claude:  { dir: ".claude",  template: "claude",  skillPath: ".claude/skills/forge",  need: ["CLAUDE.md", "settings.local.json"], postInstall: "forgeSentinel" },
+  cursor:  { dir: ".cursor",  template: "cursor",  skillPath: ".cursor/skills/forge",  need: [".cursorrules", "hooks.json"],         postInstall: "forgeSmith" },
+  codex:   { dir: ".agents",  template: "codex",   skillPath: ".agents/skills/forge",  need: ["hooks.json"],                          postInstall: "forgeSentinel" },
+  gemini:  { dir: ".gemini",  template: "gemini",  skillPath: ".gemini/skills/forge",  need: ["SKILL.md"],                            postInstall: null },
+  agents:  { dir: ".agents",  template: "agents",  skillPath: ".agents/skills/forge",  need: ["hooks.json"],                          postInstall: "forgeSentinel" },
+};
 
 function getTargetDir(global) {
   if (global) {
@@ -30,16 +40,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 +63,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 +74,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 +114,159 @@ 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)
+// --- Direct installers ---
 
-OPCIONES
-  -g, --global                     Instalar en ~/.config/opencode/skills/forge/
-  -h, --help                       Mostrar esta ayuda
-`);
-}
-
-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 installAgentTemplates(agentDir, agentName) {
+  const config = AGENT_CONFIGS[agentName];
+  if (!config) return;
+
+  const templateDir = join(AGENTS_TEMPLATES, config.template);
+  if (!existsSync(templateDir)) {
+    log.error(`Template para ${agentName} no encontrado en ${templateDir}`);
+    return;
+  }
+
+  const s = spinner();
+  s.start(`Copiando templates para ${agentName} en ${agentDir}/`);
+
+  mkdirSync(agentDir, { recursive: true });
+
+  // Copy skill into <agentDir>/skills/forge/
+  const skillDest = join(agentDir, "skills", "forge");
+  cpSync(SKILL_SRC, skillDest, { recursive: true, force: true });
+
+  // Copy template files (hooks, CLAUDE.md, .cursorrules, etc.)
+  for (const entry of readdirSync(templateDir)) {
+    const srcFile = join(templateDir, entry);
+    const destFile = join(agentDir, entry);
+    cpSync(srcFile, destFile, { recursive: true, force: true });
+  }
+
+  // Render SKILL.md with agent-specific path
+  const templatePath = join(AGENTS_TEMPLATES, "SKILL.md.template");
+  if (existsSync(templatePath)) {
+    const template = readFileSync(templatePath, "utf-8");
+    const rendered = template.replace(/\{\{AGENT_PATH\}\}/g, config.skillPath);
+    writeFileSync(join(skillDest, "SKILL.md"), rendered, "utf-8");
+  }
+
+  s.stop(`${agentName} configurado en ${agentDir}/`);
+  log.success(`${agentName} listo (skill + ${config.postInstall || "templates"})`);
+}
+
+async function installCursor() {
+  await installAgentTemplates(join(process.cwd(), ".cursor"), "cursor");
+}
+
+async function installClaude() {
+  await installAgentTemplates(join(process.cwd(), ".claude"), "claude");
+}
+
+async function installCodex() {
+  // Codex hooks point to .agents/skills/forge/ via git root
+  await installAgentTemplates(join(process.cwd(), ".agents"), "codex");
+  // Also copy hooks.json into .codex/ so Codex CLI picks it up
+  const codexDir = join(process.cwd(), ".codex");
+  mkdirSync(codexDir, { recursive: true });
+  const hooksSrc = join(AGENTS_TEMPLATES, "codex", "hooks.json");
+  if (existsSync(hooksSrc)) {
+    cpSync(hooksSrc, join(codexDir, "hooks.json"), { force: true });
+  }
+}
+
+async function installGemini() {
+  await installAgentTemplates(join(process.cwd(), ".gemini"), "gemini");
+}
+
+async function installAgentsGeneric() {
+  await installAgentTemplates(join(process.cwd(), ".agents"), "agents");
+}
+
+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;
+      case "codex":
+        await installCodex();
+        break;
+      case "gemini":
+        await installGemini();
+        break;
+      case "agents":
+        await installAgentsGeneric();
+        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 --codex            Instalar solo para Codex CLI
+  forge install --gemini           Instalar solo para Gemini Code Assist
+  forge install --all              Instalar para todos los agentes detectados
+  forge install --global           Instalar OpenCode globalmente (~/.config/opencode/)
+  forge install --help             Mostrar esta ayuda
+
+AGENTES SOPORTADOS
+  OpenCode, Claude Code, Cursor, Codex CLI, Gemini Code Assist, Agentes Genéricos
+
+HOOKS
+  forgeSentinel (PostToolUse) — guardia arquitectónico post-escritura
+  forgeSmith    (preToolUse)  — guardia arquitectónico pre-escritura (Cursor)
+
+OPCIONES
+  -g, --global                     Instalar OpenCode en ~/.config/opencode/skills/forge/
+  -h, --help                       Mostrar esta ayuda
+`);
 }
 
-function main() {
+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 +276,37 @@ function main() {
     return;
   }
 
+  const hasOpenCode = args.includes("--opencode");
+  const hasCursor   = args.includes("--cursor");
+  const hasClaude   = args.includes("--claude");
+  const hasCodex    = args.includes("--codex");
+  const hasGemini   = args.includes("--gemini");
+  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", "codex", "gemini", "agents"], isGlobal);
+    } else if (hasOpenCode || hasCursor || hasClaude || hasCodex || hasGemini) {
+      const selected = [];
+      if (hasOpenCode) selected.push("opencode");
+      if (hasCursor) selected.push("cursor");
+      if (hasClaude) selected.push("claude");
+      if (hasCodex) selected.push("codex");
+      if (hasGemini) selected.push("gemini");
+      await installAgents(selected, isGlobal);
+    } else {
+      await runWizard();
+    }
   } else {
     printHelp();
     process.exit(1);
   }
 }
 
-main();
+main().catch((err) => {
+  console.error("[ERROR]", err.message);
+  process.exit(1);
+});