fwinit 1.4.5 → 1.4.6

package/README.md

@@ -35,6 +35,20 @@ fwinit fullstack mi-proyecto -b fastify -f react-native -p pnpm
 # Ver templates disponibles (agrupados por capa)
 fwinit list
 
+# Instalar skills globalmente (OpenCode, Pi, Agent Skills) — interactivo
+fwinit skills
+
+# Instalar skills globalmente sin preguntas (modo scripting/CI)
+fwinit skills --global opencode,pi   # o: --global all
+
+# Instalar solo algunas skills
+fwinit skills --global all --only create-specs,design
+
+# Eliminar skills globales (mismos flags; interactivo pregunta qué eliminar)
+fwinit skills --remove
+fwinit skills --global all --remove
+fwinit skills --global pi --remove --only design
+
 # Ayuda
 fwinit --help
 ```
@@ -48,6 +62,7 @@ fwinit --help
 > Full stack (backend + frontend)
   Solo backend (API)
   Solo frontend (app)
+  Skills globales (instalar / eliminar)
 ```
 
 - **Full stack**: te pregunta primero el backend y después el frontend, y arma el monorepo completo.

package/dist/index.js

@@ -5,8 +5,8 @@ import { Command } from "commander";
 import ora from "ora";
 import chalk from "chalk";
 import { readFileSync } from "fs";
-import { mkdir as mkdir2, cp as cp2, readFile as readFile2 } from "fs/promises";
-import { join as join2, basename } from "path";
+import { mkdir as mkdir3, cp as cp3, readFile as readFile2 } from "fs/promises";
+import { join as join3, basename } from "path";
 
 // src/templates.ts
 var TEMPLATES = [
@@ -266,33 +266,33 @@ async function exists(path) {
 }
 async function listMarkdown(dir) {
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    return (await readdir2(dir)).filter((f) => f.endsWith(".md"));
+    const { readdir: readdir3 } = await import("fs/promises");
+    return (await readdir3(dir)).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
 }
 async function planAgentBundle(repoRoot, bundle = AGENT_BUNDLE) {
-  const { join: join3 } = await import("path");
+  const { join: join4 } = await import("path");
   const installs = [];
   const skillDirs = [];
   const missingRequired = [];
   for (const entry of bundle) {
-    const src = join3(repoRoot, "skills", entry.dir);
+    const src = join4(repoRoot, "skills", entry.dir);
     if (entry.kind === "library") {
       if (!await exists(src)) {
         if (entry.required) missingRequired.push(entry.dir);
         continue;
       }
       installs.push({ from: src, to: `skills/${entry.dir}`, recursive: true });
-      const cmds = join3(src, "commands");
+      const cmds = join4(src, "commands");
       for (const file of await listMarkdown(cmds)) {
-        installs.push({ from: join3(cmds, file), to: `commands/${file}` });
+        installs.push({ from: join4(cmds, file), to: `commands/${file}` });
       }
       continue;
     }
-    const skill = join3(src, "SKILL.md");
-    const command = join3(src, "command.md");
+    const skill = join4(src, "SKILL.md");
+    const command = join4(src, "command.md");
     if (!await exists(skill)) {
       if (entry.required) missingRequired.push(entry.dir);
       continue;
@@ -305,7 +305,7 @@ async function planAgentBundle(repoRoot, bundle = AGENT_BUNDLE) {
       missingRequired.push(`${entry.dir}/command.md`);
     }
     for (const extra of entry.extras ?? []) {
-      const from = join3(src, extra);
+      const from = join4(src, extra);
       if (await exists(from)) {
         installs.push({
           from,
@@ -329,7 +329,8 @@ async function selectScope() {
       choices: [
         { name: "Full stack (backend + frontend)", value: "fullstack" },
         { name: "Solo backend (API)", value: "backend" },
-        { name: "Solo frontend (app)", value: "frontend" }
+        { name: "Solo frontend (app)", value: "frontend" },
+        { name: "Skills globales (instalar / eliminar)", value: "skills" }
       ]
     }
   ]);
@@ -404,6 +405,179 @@ async function askLayerLayout(layer) {
   ]);
   return layout;
 }
+async function selectGlobalTargets(choices) {
+  const { targets } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "targets",
+      message: "\xBFD\xF3nde quer\xE9s instalar las skills?",
+      choices
+    }
+  ]);
+  return targets;
+}
+async function selectGlobalTargetsToRemove(choices) {
+  const { targets } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "targets",
+      message: "\xBFDe d\xF3nde quer\xE9s eliminar las skills?",
+      choices
+    }
+  ]);
+  return targets;
+}
+async function selectSkillsAction() {
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "\xBFQu\xE9 quer\xE9s hacer con las skills globales?",
+      choices: [
+        { name: "Instalar / actualizar", value: "install" },
+        { name: "Eliminar", value: "remove" }
+      ]
+    }
+  ]);
+  return action;
+}
+async function askGlobalSkillsToo() {
+  const { global } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "global",
+      message: "\xBFInstalar las skills tambi\xE9n globalmente (OpenCode/Pi/Agent Skills)?",
+      default: false
+    }
+  ]);
+  return global;
+}
+
+// src/global-skills.ts
+import { mkdir as mkdir2, cp as cp2, rm as rm2, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+function resolveGlobalTargets() {
+  const home = process.env.HOME;
+  if (!home) return [];
+  return [
+    {
+      id: "opencode",
+      label: `OpenCode global (${home}/.config/opencode)`,
+      root: join2(home, ".config", "opencode"),
+      skillsDir: "skills",
+      commandsDir: "command"
+    },
+    {
+      id: "pi",
+      label: `Pi global (${home}/.pi/agent)`,
+      root: join2(home, ".pi", "agent"),
+      skillsDir: "skills",
+      commandsDir: "prompts"
+    },
+    {
+      id: "agents",
+      label: `Agent Skills global (${home}/.agents/skills)`,
+      root: join2(home, ".agents"),
+      skillsDir: "skills"
+    }
+  ];
+}
+function filterBundleByNames(only) {
+  const set = new Set(only);
+  const bundle = AGENT_BUNDLE.filter((e) => set.has(e.dir));
+  const known = new Set(AGENT_BUNDLE.map((e) => e.dir));
+  return { bundle, unknown: only.filter((n) => !known.has(n)) };
+}
+function mapPlanToTarget(plan, target) {
+  const mapped = [];
+  for (const item of plan.installs) {
+    if (item.to.startsWith("skills/")) {
+      mapped.push({
+        from: item.from,
+        to: join2(target.root, target.skillsDir, item.to.slice("skills/".length)),
+        recursive: item.recursive
+      });
+      continue;
+    }
+    if (item.to.startsWith("commands/")) {
+      if (!target.commandsDir) continue;
+      mapped.push({
+        from: item.from,
+        to: join2(target.root, target.commandsDir, item.to.slice("commands/".length)),
+        recursive: item.recursive
+      });
+      continue;
+    }
+  }
+  return mapped;
+}
+async function installGlobalSkills(repoRoot, targets, bundle = AGENT_BUNDLE) {
+  const plan = await planAgentBundle(repoRoot, bundle);
+  const results = [];
+  for (const target of targets) {
+    try {
+      let copied = 0;
+      for (const item of mapPlanToTarget(plan, target)) {
+        if (item.recursive === true) {
+          await rm2(item.to, { recursive: true, force: true });
+        }
+        await mkdir2(
+          item.recursive === true ? item.to : join2(item.to, ".."),
+          { recursive: true }
+        );
+        await cp2(item.from, item.to, {
+          recursive: item.recursive === true
+        });
+        copied++;
+      }
+      results.push({ target, copied });
+    } catch (error) {
+      results.push({
+        target,
+        copied: 0,
+        error: error.message
+      });
+    }
+  }
+  return results;
+}
+async function uninstallGlobalSkills(targets, bundle = AGENT_BUNDLE) {
+  const skillNames = bundle.map((e) => e.dir);
+  const results = [];
+  for (const target of targets) {
+    try {
+      const removed = [];
+      for (const name of skillNames) {
+        await rm2(join2(target.root, target.skillsDir, name), {
+          recursive: true,
+          force: true
+        });
+        removed.push(`${target.skillsDir}/${name}`);
+      }
+      if (target.commandsDir) {
+        const cmdDir = join2(target.root, target.commandsDir);
+        for (const name of skillNames) {
+          await rm2(join2(cmdDir, `${name}.md`), { force: true });
+          removed.push(`${target.commandsDir}/${name}.md`);
+          try {
+            const prefix = `${name}-`;
+            for (const f of await readdir2(cmdDir)) {
+              if (f.startsWith(prefix) && f.endsWith(".md")) {
+                await rm2(join2(cmdDir, f), { force: true });
+                removed.push(`${target.commandsDir}/${f}`);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      results.push({ target, removed });
+    } catch (error) {
+      results.push({ target, removed: [], error: error.message });
+    }
+  }
+  return results;
+}
 
 // src/utils.ts
 import { existsSync } from "fs";
@@ -507,9 +681,9 @@ function adaptScriptToNode(script) {
   return s;
 }
 async function adaptToNodeRuntime(projectPath) {
-  const { readFile: readFile3, writeFile: writeFile2, readdir: readdir2 } = await import("fs/promises");
-  const { join: join3 } = await import("path");
-  const pkgPath = join3(projectPath, "package.json");
+  const { readFile: readFile3, writeFile: writeFile2, readdir: readdir3 } = await import("fs/promises");
+  const { join: join4 } = await import("path");
+  const pkgPath = join4(projectPath, "package.json");
   const pkg = JSON.parse(await readFile3(pkgPath, "utf-8"));
   for (const key of Object.keys(pkg.scripts ?? {})) {
     pkg.scripts[key] = adaptScriptToNode(pkg.scripts[key]);
@@ -520,9 +694,9 @@ async function adaptToNodeRuntime(projectPath) {
   delete pkg.devDependencies["bun-types"];
   await writeFile2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   async function walk(dir) {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules") await walk(full);
       } else if (entry.name.endsWith(".test.ts")) {
@@ -533,12 +707,12 @@ async function adaptToNodeRuntime(projectPath) {
       }
     }
   }
-  const srcDir = join3(projectPath, "src");
+  const srcDir = join4(projectPath, "src");
   try {
     await walk(srcDir);
   } catch {
   }
-  const tsconfigPath = join3(projectPath, "tsconfig.json");
+  const tsconfigPath = join4(projectPath, "tsconfig.json");
   try {
     const tsconfig = JSON.parse(await readFile3(tsconfigPath, "utf-8"));
     if (tsconfig.compilerOptions?.types?.includes("bun-types")) {
@@ -550,8 +724,8 @@ async function adaptToNodeRuntime(projectPath) {
 }
 async function writeRootGitignore(projectPath) {
   const { writeFile: writeFile2, access } = await import("fs/promises");
-  const { join: join3 } = await import("path");
-  const gitignorePath = join3(projectPath, ".gitignore");
+  const { join: join4 } = await import("path");
+  const gitignorePath = join4(projectPath, ".gitignore");
   try {
     await access(gitignorePath);
   } catch {
@@ -579,7 +753,7 @@ async function gitInit(projectPath) {
 }
 async function writeRootFiles(info) {
   const { writeFile: writeFile2 } = await import("fs/promises");
-  const { join: join3 } = await import("path");
+  const { join: join4 } = await import("path");
   const projectPath = resolve(process.cwd(), info.projectName);
   await writeRootGitignore(projectPath);
   const installB = info.backend.postInit?.install ? resolveCommand(info.backend.postInit.install, info.pm) : `${info.pm} install`;
@@ -615,7 +789,7 @@ async function writeRootFiles(info) {
     "```",
     ""
   ].join("\n");
-  await writeFile2(join3(projectPath, "README.md"), readme);
+  await writeFile2(join4(projectPath, "README.md"), readme);
 }
 
 // src/index.ts
@@ -634,15 +808,15 @@ var AGENT_DIRS = [".opencode", ".pi", ".agents"];
 async function installAgentSkills(repoRoot, projectPath) {
   const plan = await planAgentBundle(repoRoot);
   for (const agentDir of AGENT_DIRS) {
-    const root = join2(projectPath, agentDir);
+    const root = join3(projectPath, agentDir);
     for (const dir of plan.skillDirs) {
-      await mkdir2(join2(root, dir), { recursive: true });
+      await mkdir3(join3(root, dir), { recursive: true });
     }
     for (const dir of plan.commandDirs) {
-      await mkdir2(join2(root, dir), { recursive: true });
+      await mkdir3(join3(root, dir), { recursive: true });
     }
     for (const item of plan.installs) {
-      await cp2(item.from, join2(root, item.to), {
+      await cp3(item.from, join3(root, item.to), {
         recursive: item.recursive === true
       });
     }
@@ -656,10 +830,29 @@ async function installAgentSkills(repoRoot, projectPath) {
     );
   }
 }
+async function installGlobalSkillsWithSpinner(targets, bundle) {
+  const spinner = ora("Descargando bundle de skills...").start();
+  const { tempDir, repoRoot } = await downloadAndExtractRepo();
+  try {
+    spinner.text = "Instalando skills...";
+    const results = await installGlobalSkills(repoRoot, targets, bundle);
+    spinner.succeed("Skills globales instaladas");
+    for (const r of results) {
+      if (r.error) {
+        console.log(chalk.red(`  \u2716 ${r.target.label}: ${r.error}`));
+      } else {
+        console.log(chalk.dim(`  \u2714 ${r.target.label} \u2014 ${r.copied} archivos`));
+      }
+    }
+    console.log();
+  } finally {
+    await cleanup(tempDir);
+  }
+}
 async function readTemplatePostInit(dir) {
   try {
     const tj = JSON.parse(
-      await readFile2(join2(dir, "template.json"), "utf-8")
+      await readFile2(join3(dir, "template.json"), "utf-8")
     );
     return tj.postInit;
   } catch {
@@ -669,14 +862,14 @@ async function readTemplatePostInit(dir) {
 async function createFullStackProject(projectPath, backendTpl, frontendTpl, pm) {
   const { tempDir, repoRoot } = await downloadAndExtractRepo();
   const projectName = basename(projectPath);
-  const backendPath = join2(projectPath, "backend");
-  const frontendPath = join2(projectPath, "frontend");
+  const backendPath = join3(projectPath, "backend");
+  const frontendPath = join3(projectPath, "frontend");
   await copyTemplate(
-    join2(repoRoot, "templates", backendTpl.folder),
+    join3(repoRoot, "templates", backendTpl.folder),
     backendPath
   );
   await copyTemplate(
-    join2(repoRoot, "templates", frontendTpl.folder),
+    join3(repoRoot, "templates", frontendTpl.folder),
     frontendPath
   );
   await substituteTemplate(backendPath, projectName, backendTpl.folder);
@@ -735,6 +928,102 @@ program.command("list").description("Mostrar templates disponibles").action(() =
     console.log();
   }
 });
+async function runSkillsFlow(opts = {}) {
+  const all = resolveGlobalTargets();
+  if (all.length === 0) {
+    console.error(chalk.red("\n\u2716 No se pudo resolver el HOME del usuario\n"));
+    process.exit(1);
+  }
+  console.log(chalk.bold("\nSkills disponibles:\n"));
+  console.log(chalk.dim("  create-specs \u2014 specs para proyecto nuevo (/create-specs)"));
+  console.log(chalk.dim("  create-specs-from-code \u2014 specs desde c\xF3digo existente (/create-specs-from-code)"));
+  console.log(chalk.dim("  design/ \u2014 dark-luxury, glassmorphism, minimal-dashboard, minimal-light, neo-brutalist (/design-<estilo>)\n"));
+  let bundle;
+  if (opts.only) {
+    const names = opts.only.split(",").map((s) => s.trim()).filter(Boolean);
+    const { bundle: filtered, unknown } = filterBundleByNames(names);
+    if (unknown.length > 0) {
+      console.log(chalk.yellow(`  \u26A0 Skills desconocidas (ignoradas): ${unknown.join(", ")}
+`));
+    }
+    if (filtered.length === 0) {
+      console.log(chalk.dim("\n  Ninguna skill v\xE1lida en --only \u2014 no se hizo nada.\n"));
+      return false;
+    }
+    bundle = filtered;
+  }
+  const remove = opts.remove === true;
+  const interactive = !opts.global;
+  let action = remove ? "remove" : "install";
+  if (interactive && !remove) {
+    action = await selectSkillsAction();
+  }
+  let targets;
+  if (opts.global) {
+    const ids = opts.global.split(",").map((s) => s.trim().toLowerCase());
+    if (ids.includes("all")) {
+      targets = all;
+    } else {
+      const valid = new Map(all.map((t) => [t.id, t]));
+      targets = [];
+      for (const id of ids) {
+        const t = valid.get(id);
+        if (!t) {
+          console.error(
+            chalk.red(`
+\u2716 Destino "${id}" inv\xE1lido. Us\xE1: ${all.map((x) => x.id).join(", ")} o all
+`)
+          );
+          process.exit(1);
+        }
+        targets.push(t);
+      }
+    }
+  } else {
+    const pick = action === "remove" ? selectGlobalTargetsToRemove : selectGlobalTargets;
+    const selected = await pick(all.map((t) => ({ name: t.label, value: t.id })));
+    if (selected.length === 0) {
+      console.log(
+        chalk.dim(`
+  Nada seleccionado \u2014 no se ${action === "remove" ? "elimin\xF3" : "instal\xF3"} nada.
+`)
+      );
+      return false;
+    }
+    targets = all.filter((t) => selected.includes(t.id));
+  }
+  if (action === "remove") {
+    const results = await uninstallGlobalSkills(targets, bundle);
+    for (const r of results) {
+      console.log(chalk.dim(`  \u2714 ${r.target.label} \u2014 ${r.removed.length} eliminados`));
+    }
+    console.log();
+    return true;
+  }
+  await installGlobalSkillsWithSpinner(targets, bundle);
+  return true;
+}
+program.command("skills").description(
+  "Instalar o eliminar las skills del repo en ubicaciones globales (OpenCode, Pi, Agent Skills)"
+).option(
+  "-g, --global <targets>",
+  "Destinos separados por coma: opencode, pi, agents (o 'all'). Saltea la pregunta"
+).option(
+  "-o, --only <skills>",
+  "Solo estas skills, separadas por coma: create-specs, create-specs-from-code, design"
+).option(
+  "-r, --remove",
+  "Eliminar en vez de instalar (combinar con --global y opcionalmente --only)"
+).action(async (opts) => {
+  try {
+    await runSkillsFlow(opts);
+  } catch (error) {
+    console.error(chalk.red(`
+\u2716 Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
 program.argument("[template]", "Template a usar (o 'fullstack' para backend + frontend)").argument("[project-name]", "Nombre del proyecto").option("-p, --pm <package-manager>", "Package manager a usar: npm, pnpm o bun").option("--backend", "Empaquetar el c\xF3digo en backend/ (saltea la pregunta)").option("--no-backend", "Dejar el c\xF3digo en la ra\xEDz del proyecto (saltea la pregunta)").option("-b, --backend-template <tpl>", "Backend a usar en fullstack (saltea la pregunta)").option("-f, --frontend-template <tpl>", "Frontend a usar en fullstack (saltea la pregunta)").option("--git", "Inicializar un repositorio git (saltea la pregunta)").option("--no-git", "No inicializar git (saltea la pregunta)").action(
   async (templateArg, projectNameArg) => {
     try {
@@ -756,6 +1045,10 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
       const rawArg = templateArg?.toLowerCase();
       if (rawArg === void 0) {
         const scope = await selectScope();
+        if (scope === "skills") {
+          await runSkillsFlow();
+          return;
+        }
         if (scope === "fullstack") {
           isFullStack = true;
         } else {
@@ -853,7 +1146,7 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
         spinner.succeed("Template descargado");
       } else {
         const { tempDir, templatePath, repoRoot } = await downloadAndExtract(template.folder);
-        const codePath = useLayerLayout ? join2(projectPath, layer) : projectPath;
+        const codePath = useLayerLayout ? join3(projectPath, layer) : projectPath;
         spinner.text = "Creando proyecto...";
         await copyTemplate(templatePath, codePath);
         await substituteTemplate(codePath, projectName, template.folder);
@@ -896,6 +1189,28 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
           );
         }
       }
+      if (git === void 0) {
+        const wantsGlobalSkills = await askGlobalSkillsToo();
+        if (wantsGlobalSkills) {
+          const all = resolveGlobalTargets();
+          if (all.length === 0) {
+            console.log(
+              chalk.yellow(
+                "  \u26A0 No se pudo resolver el HOME \u2014 skills globales omitidas\n"
+              )
+            );
+          } else {
+            const selected = await selectGlobalTargets(
+              all.map((t) => ({ name: t.label, value: t.id }))
+            );
+            if (selected.length > 0) {
+              await installGlobalSkillsWithSpinner(
+                all.filter((t) => selected.includes(t.id))
+              );
+            }
+          }
+        }
+      }
     } catch (error) {
       console.error(
         chalk.red(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fwinit",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "description": "CLI para crear proyectos desde templates",
   "type": "module",
   "bin": {