@skillsmanagerbasetis/skill-manager-local 0.4.2

package/bin/index.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { init } from "../src/commands/init.js";
+import { list } from "../src/commands/list.js";
+import { install } from "../src/commands/install.js";
+import { installBulk } from "../src/commands/install-bulk.js";
+import { status } from "../src/commands/status.js";
+import { detect } from "../src/commands/detect.js";
+import { login } from "../src/commands/login.js";
+import { logout } from "../src/commands/logout.js";
+import { whoami } from "../src/commands/whoami.js";
+import { sync } from "../src/commands/sync.js";
+import { push } from "../src/commands/push.js";
+import { update } from "../src/commands/update.js";
+import { remove } from "../src/commands/remove.js";
+import { read } from "../src/commands/read.js";
+import { search } from "../src/commands/search.js";
+
+const program = new Command();
+
+program
+  .name("skill-manager")
+  .description("CLI para gestionar skills de IA en tu editor")
+  .version("0.4.0");
+
+program
+  .command("init")
+  .description("Configura el repositorio de skills y la herramienta por defecto")
+  .action(async () => {
+    try {
+      await init();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("list")
+  .description("Lista todas las skills disponibles en el catálogo")
+  .option("-f, --filter <texto>", "Filtra skills por nombre")
+  .option("-j, --json", "Salida en formato JSON")
+  .action(async (options) => {
+    try {
+      await list(options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("search [texto]")
+  .description("Busca skills por texto, tipo, nivel, entidad o proyecto (solo las que puedes ver)")
+  .option("-t, --type <tipo>", "Filtrar por tipo: contexto, habilidad, agente")
+  .option("-l, --level <nivel>", "Filtrar por nivel: root, user, habilidades, area, team, sector, proyecto")
+  .option("-e, --entity <slug>", "Filtrar por entidad (slug del area/team/sector)")
+  .option("-p, --project <slug>", "Filtrar por proyecto (slug)")
+  .option("-j, --json", "Salida en formato JSON")
+  .action(async (texto, options) => {
+    try {
+      await search(texto, options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("install <ruta>")
+  .description("Instala una skill y sus dependencias (cadena de parents)")
+  .option("-t, --tool <herramienta>", "Herramienta(s) destino, separadas por coma (claude,cursor,gemini,codex,windsurf,opencode,copilot,aider,zed,roocode,qwen)")
+  .option("-s, --scope <ámbito>", "Ámbito de instalación: global o project")
+  .option("-f, --force", "Sobreescribir sin confirmar si la skill ya existe")
+  .action(async (ruta, options) => {
+    try {
+      await install(ruta, options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// Bulk install commands: install-project / install-area / install-team / install-sector
+const bulkOpts = (cmd) =>
+  cmd
+    .option("-t, --tool <herramienta>", "Herramienta(s) destino, separadas por coma")
+    .option("-s, --scope <ámbito>", "Ámbito de instalación: global o project")
+    .option("-y, --yes", "Asume sí en las confirmaciones");
+
+bulkOpts(
+  program
+    .command("install-project <slug>")
+    .description("Instala todas las skills publicadas de un proyecto")
+).action(async (slug, options) => {
+  try { await installBulk("project", slug, options); }
+  catch (err) { console.error(err.message); process.exit(1); }
+});
+
+bulkOpts(
+  program
+    .command("install-area <slug>")
+    .description("Instala todas las skills publicadas de un área")
+).action(async (slug, options) => {
+  try { await installBulk("area", slug, options); }
+  catch (err) { console.error(err.message); process.exit(1); }
+});
+
+bulkOpts(
+  program
+    .command("install-team <slug>")
+    .description("Instala todas las skills publicadas de un team")
+).action(async (slug, options) => {
+  try { await installBulk("team", slug, options); }
+  catch (err) { console.error(err.message); process.exit(1); }
+});
+
+bulkOpts(
+  program
+    .command("install-sector <slug>")
+    .description("Instala todas las skills publicadas de un sector")
+).action(async (slug, options) => {
+  try { await installBulk("sector", slug, options); }
+  catch (err) { console.error(err.message); process.exit(1); }
+});
+
+program
+  .command("status")
+  .description("Muestra el estado de las skills instaladas vs el catálogo")
+  .option("-j, --json", "Salida en formato JSON")
+  .action(async (options) => {
+    try {
+      await status(options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("detect")
+  .description("Analiza el proyecto actual y recomienda skills relevantes")
+  .action(async () => {
+    try {
+      await detect();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("sync")
+  .description("Actualiza el find-skill con tus permisos más recientes")
+  .action(async () => {
+    try {
+      await sync();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("push <ruta>")
+  .description("Publica los cambios locales de un skill al servidor")
+  .action(async (ruta) => {
+    try {
+      await push(ruta);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("update")
+  .description("Comprueba y aplica actualizaciones de skills instalados")
+  .option("-n, --dry-run", "Muestra qué se actualizaría sin aplicar cambios")
+  .action(async (options) => {
+    try {
+      await update(options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("remove <ruta>")
+  .description("Desinstala una skill del sistema de archivos local")
+  .option("-t, --tool <herramienta>", "Solo eliminar de esta herramienta (claude,cursor,gemini,codex,windsurf,opencode,copilot,aider,zed,roocode,qwen)")
+  .option("-s, --scope <ámbito>", "Solo eliminar de este ámbito: global o project")
+  .option("-y, --yes", "Asume sí en las confirmaciones")
+  .action(async (ruta, options) => {
+    try {
+      await remove(ruta, options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("read <ruta>")
+  .description("Muestra el contenido de una skill instalada")
+  .option("-t, --tool <herramienta>", "Leer de esta herramienta específica")
+  .option("-s, --scope <ámbito>", "Leer de este ámbito: global o project")
+  .option("-r, --raw", "Muestra el contenido sin formateo")
+  .option("-j, --json", "Salida en formato JSON")
+  .action(async (ruta, options) => {
+    try {
+      await read(ruta, options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("login")
+  .description("Inicia sesión con tu cuenta de Basetis (Google)")
+  .action(async () => {
+    try {
+      await login();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("logout")
+  .description("Cierra la sesión actual")
+  .action(async () => {
+    try {
+      await logout();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("whoami")
+  .description("Muestra el usuario autenticado")
+  .action(async () => {
+    try {
+      await whoami();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@skillsmanagerbasetis/skill-manager-local",
+  "version": "0.4.2",
+  "description": "CLI to manage AI coding skills across editors",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "skill-manager-local": "bin/index.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "chalk": "^5",
+    "commander": "^13",
+    "inquirer": "^12",
+    "js-yaml": "^4",
+    "ora": "^8"
+  }
+}

package/src/adapters/adapters.test.js

@@ -0,0 +1,175 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, readFile, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const SKILL_CONTENT = `---
+name: test-skill
+version: "1.0.0"
+description: A test skill
+---
+You are a test skill.
+`;
+
+let tmpHome, tmpCwd, origHome, origCwd;
+
+async function setup() {
+  tmpHome = await realpath(await mkdtemp(join(tmpdir(), "sm-home-")));
+  tmpCwd = await realpath(await mkdtemp(join(tmpdir(), "sm-cwd-")));
+  origHome = process.env.HOME;
+  origCwd = process.cwd();
+  process.env.HOME = tmpHome;
+  process.chdir(tmpCwd);
+}
+
+async function teardown() {
+  process.env.HOME = origHome;
+  process.chdir(origCwd);
+  await rm(tmpHome, { recursive: true, force: true });
+  await rm(tmpCwd, { recursive: true, force: true });
+}
+
+// Re-import adapters fresh so homeDir/cwdDir pick up the new env
+async function loadAdapter(name) {
+  const mod = await import(`./${name}.js?t=${Date.now()}`);
+  return mod;
+}
+
+describe("claude adapter", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("installs to personal scope at ~/.claude/skills/", async () => {
+    const claude = await loadAdapter("claude");
+    const dest = await claude.install("external/sector/pharma", SKILL_CONTENT, "personal");
+    assert.equal(dest, join(tmpHome, ".claude", "skills", "external", "sector", "pharma", "SKILL.md"));
+    const content = await readFile(dest, "utf-8");
+    assert.ok(content.includes("test skill"));
+  });
+
+  it("installs to project scope at .claude/skills/", async () => {
+    const claude = await loadAdapter("claude");
+    const dest = await claude.install("internal/tooling/eslint", SKILL_CONTENT, "project");
+    assert.equal(dest, join(tmpCwd, ".claude", "skills", "internal", "tooling", "eslint", "SKILL.md"));
+  });
+
+  it("getInstallPath returns correct path", async () => {
+    const claude = await loadAdapter("claude");
+    const p = claude.getInstallPath("a/b/c", "personal");
+    assert.ok(p.endsWith(join(".claude", "skills", "a", "b", "c", "SKILL.md")));
+  });
+
+  it("getInstalledSkills reads back installed skills", async () => {
+    const claude = await loadAdapter("claude");
+    await claude.install("sector/pharma", SKILL_CONTENT, "personal");
+    const skills = await claude.getInstalledSkills("personal");
+    assert.equal(skills.length, 1);
+    assert.equal(skills[0].path, "sector/pharma");
+    assert.equal(skills[0].version, "1.0.0");
+  });
+});
+
+describe("gemini adapter", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("installs to personal scope at ~/.gemini/skills/", async () => {
+    const gemini = await loadAdapter("gemini");
+    const dest = await gemini.install("sector/pharma", SKILL_CONTENT, "personal");
+    assert.equal(dest, join(tmpHome, ".gemini", "skills", "sector", "pharma", "SKILL.md"));
+  });
+
+  it("installs to project scope at .agents/skills/", async () => {
+    const gemini = await loadAdapter("gemini");
+    const dest = await gemini.install("sector/pharma", SKILL_CONTENT, "project");
+    assert.equal(dest, join(tmpCwd, ".agents", "skills", "sector", "pharma", "SKILL.md"));
+  });
+});
+
+describe("codex adapter", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("installs to personal scope at ~/.codex/{skillName}/", async () => {
+    const codex = await loadAdapter("codex");
+    const dest = await codex.install("external/sector/pharma", SKILL_CONTENT, "personal");
+    assert.equal(dest, join(tmpHome, ".codex", "pharma", "SKILL.md"));
+  });
+
+  it("installs to project scope at .agents/skills/", async () => {
+    const codex = await loadAdapter("codex");
+    const dest = await codex.install("external/sector/pharma", SKILL_CONTENT, "project");
+    assert.equal(dest, join(tmpCwd, ".agents", "skills", "external", "sector", "pharma", "SKILL.md"));
+  });
+});
+
+describe("cursor adapter", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("installs to personal scope as .mdc with cursor frontmatter", async () => {
+    const cursor = await loadAdapter("cursor");
+    const dest = await cursor.install("external/sector/pharma", SKILL_CONTENT, "personal");
+    assert.equal(dest, join(tmpHome, ".cursor", "rules", "pharma.mdc"));
+    const content = await readFile(dest, "utf-8");
+    assert.ok(content.startsWith("---\ndescription: A test skill\nalwaysApply: false\n---\n"));
+  });
+
+  it("installs to project scope at .cursor/rules/", async () => {
+    const cursor = await loadAdapter("cursor");
+    const dest = await cursor.install("sector/pharma", SKILL_CONTENT, "project");
+    assert.equal(dest, join(tmpCwd, ".cursor", "rules", "pharma.mdc"));
+  });
+});
+
+describe("windsurf adapter", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("installs to personal scope by appending to global_rules.md", async () => {
+    const windsurf = await loadAdapter("windsurf");
+    const dest = await windsurf.install("sector/pharma", SKILL_CONTENT, "personal");
+    assert.equal(dest, join(tmpHome, ".windsurf", "global_rules.md"));
+    const content = await readFile(dest, "utf-8");
+    assert.ok(content.includes("## pharma"));
+    assert.ok(content.includes("test skill"));
+  });
+
+  it("appends multiple skills without overwriting", async () => {
+    const windsurf = await loadAdapter("windsurf");
+    await windsurf.install("sector/pharma", SKILL_CONTENT, "personal");
+    await windsurf.install("sector/tech", "---\nname: tech\nversion: \"2.0.0\"\n---\nTech skill.", "personal");
+    const content = await readFile(join(tmpHome, ".windsurf", "global_rules.md"), "utf-8");
+    assert.ok(content.includes("## pharma"));
+    assert.ok(content.includes("## tech"));
+  });
+
+  it("installs to project scope at .windsurf/rules/", async () => {
+    const windsurf = await loadAdapter("windsurf");
+    const dest = await windsurf.install("sector/pharma", SKILL_CONTENT, "project");
+    assert.equal(dest, join(tmpCwd, ".windsurf", "rules", "pharma.md"));
+  });
+});
+
+describe("adapter index", () => {
+  it("getAdapter returns correct adapter", async () => {
+    const { getAdapter } = await import("./index.js");
+    const claude = getAdapter("claude");
+    assert.equal(claude.toolName, "claude");
+    assert.equal(claude.displayName, "Claude Code");
+  });
+
+  it("getAdapter throws for unknown tool", async () => {
+    const { getAdapter } = await import("./index.js");
+    assert.throws(() => getAdapter("unknown"), { message: /no soportada/ });
+  });
+
+  it("getAllAdapters returns 5 adapters", async () => {
+    const { getAllAdapters } = await import("./index.js");
+    const all = getAllAdapters();
+    assert.equal(all.length, 5);
+    const names = all.map((a) => a.toolName);
+    assert.deepEqual(names, ["claude", "gemini", "codex", "cursor", "windsurf"]);
+  });
+});

package/src/adapters/aider.js

@@ -0,0 +1,41 @@
+import { join, basename } from "node:path";
+import { cwdDir, writeFile, readFile } from "../utils/fs.js";
+import { parseFrontmatter, scanDir } from "./shared.js";
+
+export const toolName = "aider";
+export const displayName = "Aider";
+
+// Aider only supports project-level conventions files
+function basePath() {
+  return join(cwdDir(), ".aider", "skills");
+}
+
+export function getInstallPath(skillPath, scope) {
+  if (scope === "personal") {
+    return join(basePath(), `${basename(skillPath)}.md`);
+  }
+  return join(basePath(), `${basename(skillPath)}.md`);
+}
+
+export async function install(skillPath, skillContent, scope, _metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  if (scope === "personal") return [];
+  const dir = basePath();
+  const files = await scanDir(dir, ".md");
+  const skills = [];
+  for (const file of files) {
+    const content = await readFile(join(dir, file));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    skills.push({
+      path: file.replace(/\.md$/, ""),
+      version: meta.version || "unknown",
+    });
+  }
+  return skills;
+}

package/src/adapters/claude.js

@@ -0,0 +1,26 @@
+import { join } from "node:path";
+import { homeDir, cwdDir, writeFile } from "../utils/fs.js";
+import { scanInstalledSkills } from "./shared.js";
+
+export const toolName = "claude";
+export const displayName = "Claude Code";
+
+function basePath(scope) {
+  return scope === "personal"
+    ? join(homeDir(), ".claude", "skills")
+    : join(cwdDir(), ".claude", "skills");
+}
+
+export function getInstallPath(skillPath, scope) {
+  return join(basePath(scope), skillPath, "SKILL.md");
+}
+
+export async function install(skillPath, skillContent, scope, _metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  return scanInstalledSkills(basePath(scope));
+}

package/src/adapters/codex.js

@@ -0,0 +1,31 @@
+import { join, basename } from "node:path";
+import { homeDir, cwdDir, writeFile } from "../utils/fs.js";
+import { scanInstalledSkills } from "./shared.js";
+
+export const toolName = "codex";
+export const displayName = "Codex CLI";
+
+function basePath(scope) {
+  if (scope === "personal") {
+    return join(homeDir(), ".codex");
+  }
+  return join(cwdDir(), ".agents", "skills");
+}
+
+export function getInstallPath(skillPath, scope) {
+  if (scope === "personal") {
+    const skillName = basename(skillPath);
+    return join(basePath(scope), skillName, "SKILL.md");
+  }
+  return join(basePath(scope), skillPath, "SKILL.md");
+}
+
+export async function install(skillPath, skillContent, scope, _metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  return scanInstalledSkills(basePath(scope));
+}

package/src/adapters/copilot.js

@@ -0,0 +1,42 @@
+import { join, basename } from "node:path";
+import { cwdDir, writeFile, readFile } from "../utils/fs.js";
+import { parseFrontmatter, scanDir } from "./shared.js";
+
+export const toolName = "copilot";
+export const displayName = "GitHub Copilot";
+
+// Copilot only supports project-level skills
+function basePath() {
+  return join(cwdDir(), ".github", "copilot", "skills");
+}
+
+export function getInstallPath(skillPath, scope) {
+  if (scope === "personal") {
+    // Copilot doesn't have a global skills directory — install to project
+    return join(basePath(), `${basename(skillPath)}.md`);
+  }
+  return join(basePath(), `${basename(skillPath)}.md`);
+}
+
+export async function install(skillPath, skillContent, scope, _metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  if (scope === "personal") return [];
+  const dir = basePath();
+  const files = await scanDir(dir, ".md");
+  const skills = [];
+  for (const file of files) {
+    const content = await readFile(join(dir, file));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    skills.push({
+      path: file.replace(/\.md$/, ""),
+      version: meta.version || "unknown",
+    });
+  }
+  return skills;
+}

package/src/adapters/cursor.js

@@ -0,0 +1,54 @@
+import { join, basename } from "node:path";
+import { homeDir, cwdDir, writeFile, readFile } from "../utils/fs.js";
+import { parseFrontmatter, scanDir } from "./shared.js";
+
+export const toolName = "cursor";
+export const displayName = "Cursor";
+
+function basePath(scope) {
+  return scope === "personal"
+    ? join(homeDir(), ".cursor", "rules")
+    : join(cwdDir(), ".cursor", "rules");
+}
+
+export function getInstallPath(skillPath, scope) {
+  const skillName = basename(skillPath);
+  return join(basePath(scope), `${skillName}.mdc`);
+}
+
+function toCursorFormat(skillContent, metadata = {}) {
+  const { meta, body } = parseFrontmatter(skillContent);
+  const description = metadata.description || meta.description || meta.name || "Skill";
+  const alwaysApply = metadata.activationMode === "always";
+  const globs = metadata.cursorGlobs?.length
+    ? metadata.cursorGlobs.join(", ")
+    : "";
+
+  let header = `---\ndescription: ${description}\nalwaysApply: ${alwaysApply}`;
+  if (globs) header += `\nglobs: ${globs}`;
+  header += "\n---\n";
+  return header + body;
+}
+
+export async function install(skillPath, skillContent, scope, metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  const content = toCursorFormat(skillContent, metadata);
+  await writeFile(dest, content);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  const dir = basePath(scope);
+  const files = await scanDir(dir, ".mdc");
+  const skills = [];
+  for (const file of files) {
+    const content = await readFile(join(dir, file));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    skills.push({
+      path: file.replace(/\.mdc$/, ""),
+      version: meta.version || "unknown",
+    });
+  }
+  return skills;
+}

package/src/adapters/gemini.js

@@ -0,0 +1,26 @@
+import { join } from "node:path";
+import { homeDir, cwdDir, writeFile } from "../utils/fs.js";
+import { scanInstalledSkills } from "./shared.js";
+
+export const toolName = "gemini";
+export const displayName = "Gemini CLI";
+
+function basePath(scope) {
+  return scope === "personal"
+    ? join(homeDir(), ".gemini", "skills")
+    : join(cwdDir(), ".agents", "skills");
+}
+
+export function getInstallPath(skillPath, scope) {
+  return join(basePath(scope), skillPath, "SKILL.md");
+}
+
+export async function install(skillPath, skillContent, scope, _metadata = {}) {
+  const dest = getInstallPath(skillPath, scope);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  return scanInstalledSkills(basePath(scope));
+}