@basetisia/skill-manager 0.2.0 → 0.3.0

package/.claude/skills/habilidades/typescript/SKILL.md

@@ -0,0 +1,16 @@
+# TypeScript — Contexto v1.1.0
+
+## Reglas
+- Usa TypeScript strict mode siempre
+- ES Modules (import/export), nunca CommonJS
+- Usa const por defecto, let solo cuando sea necesario
+- Nombres de archivos en kebab-case
+- Tipos/interfaces en PascalCase
+- Funciones en camelCase
+- No uses any — tipalo todo
+- Prefiere type sobre interface salvo que necesites extends
+
+## NUEVO: Imports
+- Ordena imports: builtins → externos → internos
+- Nunca uses import *
+- Usa import type para tipos

package/bin/index.js

@@ -4,12 +4,15 @@ 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";
 
 const program = new Command();
 
@@ -57,6 +60,49 @@ program
     }
   });
 
+// 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")
@@ -93,6 +139,30 @@ program
     }
   });
 
+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")
+  .action(async () => {
+    try {
+      await update();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command("login")
   .description("Inicia sesión con tu cuenta de Basetis (Google)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basetisia/skill-manager",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI to manage AI coding skills across editors",
   "type": "module",
   "engines": {

package/src/commands/install-bulk.js

@@ -0,0 +1,170 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { requireConfig } from "../utils/config.js";
+import { apiRequest } from "../utils/api.js";
+import { getAdapter, detectInstalledTools } from "../adapters/index.js";
+import { trackInstall } from "../utils/installed.js";
+
+/**
+ * Bulk install: instala todas las skills publicadas de un proyecto/area/team/sector.
+ * @param {string} kind - 'project' | 'area' | 'team' | 'sector'
+ * @param {string} slug - Slug de la entidad o proyecto
+ */
+export async function installBulk(kind, slug, options = {}) {
+  const config = await requireConfig();
+  const validKinds = ["project", "area", "team", "sector"];
+  if (!validKinds.includes(kind)) {
+    console.error(chalk.red(`Tipo no válido: ${kind}. Debe ser uno de: ${validKinds.join(", ")}`));
+    process.exit(1);
+  }
+
+  const spinner = ora(`Buscando skills del ${kind} '${slug}'...`).start();
+
+  // Fetch all data needed
+  let skills, target;
+  try {
+    skills = await apiRequest(`/api/companies/${config.companyId}/skills`);
+    skills = skills.filter((s) => s.status === "published" && !s.path.endsWith("/_index"));
+
+    if (kind === "project") {
+      const projects = await apiRequest(`/api/companies/${config.companyId}/projects`);
+      target = projects.find((p) => p.slug === slug);
+      if (!target) {
+        spinner.fail(`Proyecto '${slug}' no encontrado.`);
+        process.exit(1);
+      }
+      skills = skills.filter((s) => s.project_id === target.id);
+    } else {
+      const endpoint = { area: "areas", team: "teams", sector: "sectors" }[kind];
+      const entities = await apiRequest(`/api/companies/${config.companyId}/${endpoint}`);
+      target = entities.find((e) => e.slug === slug);
+      if (!target) {
+        spinner.fail(`${kind.charAt(0).toUpperCase() + kind.slice(1)} '${slug}' no encontrado.`);
+        process.exit(1);
+      }
+      skills = skills.filter((s) => s.entity_id === target.id);
+    }
+  } catch (err) {
+    spinner.fail("Error al cargar datos.");
+    throw err;
+  }
+
+  spinner.stop();
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow(`\n  No hay skills publicadas en ${kind} '${target.name}'.\n`));
+    return;
+  }
+
+  // Show what will be installed
+  console.log(
+    chalk.blue.bold(
+      `\n  ${target.name} (${kind}) tiene ${skills.length} skill(s) publicada(s):\n`
+    )
+  );
+  for (const skill of skills) {
+    const desc = skill.description ? chalk.dim(` — ${skill.description}`) : "";
+    console.log(`    ${chalk.cyan(skill.path)} ${chalk.gray(`v${skill.version}`)}${desc}`);
+  }
+  console.log();
+
+  // Confirm
+  if (!options.yes) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `¿Instalar las ${skills.length} skill(s)?`,
+        default: true,
+      },
+    ]);
+    if (!confirm) {
+      console.log(chalk.dim("Cancelado."));
+      return;
+    }
+  }
+
+  // Determine target tools
+  let toolNames = [];
+  if (options.tool) {
+    toolNames = options.tool.split(",").map((t) => t.trim());
+  } else if (config.defaultTool) {
+    toolNames = [config.defaultTool];
+  } else {
+    const detected = await detectInstalledTools();
+    if (detected.length === 0) {
+      console.error(chalk.red("No se detectó ninguna herramienta de IA instalada."));
+      process.exit(1);
+    }
+    const { selected } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "selected",
+        message: "¿En qué herramientas quieres instalar?",
+        choices: detected.map((a) => ({
+          name: a.displayName,
+          value: a.toolName,
+          checked: true,
+        })),
+        validate: (val) => (val.length > 0 ? true : "Selecciona al menos una herramienta."),
+      },
+    ]);
+    toolNames = selected;
+  }
+
+  // Determine scope
+  let scope = options.scope;
+  if (!scope) {
+    const { chosen } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "chosen",
+        message: "¿Dónde instalar las skills?",
+        choices: [
+          { name: "Global (solo para ti, en ~/)", value: "personal" },
+          { name: "Proyecto (en el repo actual)", value: "project" },
+        ],
+      },
+    ]);
+    scope = chosen;
+  }
+  if (scope === "global") scope = "personal";
+
+  // Install all
+  const adapters = toolNames.map((name) => getAdapter(name));
+  let installed = 0;
+  let failed = 0;
+
+  for (const skill of skills) {
+    const installSpinner = ora(`Instalando ${skill.path}...`).start();
+    try {
+      const content = skill.content || "";
+      for (const adapter of adapters) {
+        await adapter.install(skill.path, content, scope);
+      }
+      await trackInstall(skill, toolNames[0], scope);
+      installed++;
+      installSpinner.succeed(`Instalada ${skill.path}`);
+    } catch (err) {
+      installSpinner.fail(`Error instalando ${skill.path}`);
+      console.error(chalk.red(`  ${err.message}`));
+      failed++;
+    }
+  }
+
+  // Summary
+  console.log();
+  const toolList = adapters.map((a) => a.displayName).join(" y ");
+  if (failed > 0) {
+    console.log(
+      chalk.yellow(
+        `⚠ ${installed} skill(s) instalada(s), ${failed} fallaron en ${toolList} (${scope})`
+      )
+    );
+  } else {
+    console.log(
+      chalk.green(`✔ ${installed} skill(s) instalada(s) en ${toolList} (${scope})`)
+    );
+  }
+}

package/src/commands/install.js

@@ -4,6 +4,7 @@ import inquirer from "inquirer";
 import { requireConfig } from "../utils/config.js";
 import { apiRequest } from "../utils/api.js";
 import { getAdapter, detectInstalledTools } from "../adapters/index.js";
+import { trackInstall } from "../utils/installed.js";
 
 export async function install(skillPath, options = {}) {
   const config = await requireConfig();
@@ -19,6 +20,9 @@ export async function install(skillPath, options = {}) {
     throw err;
   }
 
+  // Filter out _index skills (auto-generated, not installable)
+  skills = skills.filter((s) => !s.path.endsWith("/_index"));
+
   // Find the target skill
   const target = skills.find((s) => s.path === skillPath);
   if (!target) {
@@ -159,6 +163,7 @@ export async function install(skillPath, options = {}) {
       for (const adapter of adapters) {
         await adapter.install(skill.path, content, scope);
       }
+      await trackInstall(skill, toolNames[0], scope);
       installed++;
       installSpinner.succeed(`Instalada ${skill.path}`);
     } catch (err) {

package/src/commands/list.js

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import ora from "ora";
 import { requireConfig } from "../utils/config.js";
 import { apiRequest } from "../utils/api.js";
+import { shouldCheckUpdates } from "../utils/installed.js";
+import { checkUpdatesPassive } from "./update.js";
 
 const LEVEL_ICONS = {
   root: "🏢",
@@ -22,6 +24,11 @@ const TYPE_LABELS = {
 export async function list(options = {}) {
   const config = await requireConfig();
 
+  // Passive update check (every 5 min)
+  if (await shouldCheckUpdates()) {
+    await checkUpdatesPassive(config);
+  }
+
   const spinner = ora("Cargando skills...").start();
   let skills;
   try {
@@ -32,8 +39,10 @@ export async function list(options = {}) {
     throw err;
   }
 
-  // Filter published only
-  skills = skills.filter((s) => s.status === "published");
+  // Filter published only and exclude auto-generated _index skills
+  skills = skills.filter(
+    (s) => s.status === "published" && !s.path.endsWith("/_index")
+  );
 
   // Apply text filter if provided
   if (options.filter) {

package/src/commands/push.js

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { readFile } from "node:fs/promises";
+import { requireConfig } from "../utils/config.js";
+import { apiRequest } from "../utils/api.js";
+import { getInstalledSkills } from "../utils/installed.js";
+import { getAdapter } from "../adapters/index.js";
+
+export async function push(skillPath) {
+  const config = await requireConfig();
+
+  // Find the installed skill
+  const installed = await getInstalledSkills();
+  const entry = installed.find((s) => s.path === skillPath);
+
+  if (!entry) {
+    console.log(chalk.red(`Skill no instalado localmente: ${skillPath}`));
+    console.log(chalk.dim("  Solo puedes hacer push de skills que tengas instalados."));
+    process.exit(1);
+  }
+
+  // Read local content
+  const adapter = getAdapter(entry.tool || config.defaultTool);
+  let localContent;
+  try {
+    const localPath = adapter.getInstallPath(skillPath, entry.scope);
+    localContent = await readFile(localPath, "utf-8");
+  } catch (err) {
+    console.log(chalk.red(`No se pudo leer el skill local: ${skillPath}`));
+    console.log(chalk.dim(`  ${err.message}`));
+    process.exit(1);
+  }
+
+  // Fetch remote to compare
+  const spinner = ora("Comparando con la versión del servidor...").start();
+  let remoteSkill;
+  try {
+    const skills = await apiRequest(`/api/companies/${config.companyId}/skills`);
+    remoteSkill = skills.find((s) => s.path === skillPath);
+  } catch (err) {
+    spinner.fail("No se pudo conectar con la API.");
+    throw err;
+  }
+
+  if (!remoteSkill) {
+    spinner.fail("Skill no encontrado en el servidor.");
+    process.exit(1);
+  }
+
+  if (localContent.trim() === (remoteSkill.content || "").trim()) {
+    spinner.succeed("El skill local es idéntico al del servidor. No hay cambios.");
+    return;
+  }
+
+  spinner.stop();
+
+  // Show diff summary
+  const localLines = localContent.split("\n").length;
+  const remoteLines = (remoteSkill.content || "").split("\n").length;
+  console.log(
+    chalk.dim(`\n  Local: ${localLines} líneas | Servidor: ${remoteLines} líneas`)
+  );
+
+  // Ask for commit message
+  const { message } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "message",
+      message: "Describe los cambios:",
+      validate: (val) => (val.trim() ? true : "El mensaje es obligatorio."),
+    },
+  ]);
+
+  // Push
+  const pushSpinner = ora("Enviando cambios...").start();
+  try {
+    const result = await apiRequest(
+      `/api/companies/${config.companyId}/skills/${remoteSkill.id}/push`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content: localContent, message }),
+      }
+    );
+
+    if (result.action === "pushed") {
+      pushSpinner.succeed(
+        chalk.green(
+          `Cambios publicados directamente (v${result.skill.version})`
+        )
+      );
+    } else if (result.action === "proposed") {
+      pushSpinner.succeed(
+        chalk.yellow(
+          "Propuesta de cambio creada. Un admin o lead debe aprobarla."
+        )
+      );
+      console.log(chalk.dim(`  ID de propuesta: ${result.proposal.id}`));
+    }
+  } catch (err) {
+    pushSpinner.fail("Error enviando cambios.");
+    throw err;
+  }
+}

package/src/commands/update.js

@@ -0,0 +1,127 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { requireConfig } from "../utils/config.js";
+import { apiRequest } from "../utils/api.js";
+import { getInstalledSkills, updateInstalledVersion, markChecked } from "../utils/installed.js";
+import { getAdapter } from "../adapters/index.js";
+
+export async function update() {
+  const config = await requireConfig();
+  const installed = await getInstalledSkills();
+
+  if (installed.length === 0) {
+    console.log(chalk.dim("No tienes skills instalados."));
+    return;
+  }
+
+  const spinner = ora("Comprobando actualizaciones...").start();
+
+  let updates;
+  try {
+    const body = installed.map((s) => ({ path: s.path, version: s.version }));
+    const result = await apiRequest(
+      `/api/companies/${config.companyId}/skills/check-updates`,
+      {
+        method: "POST",
+        body: JSON.stringify({ installed: body }),
+      }
+    );
+    updates = (result.updates || []).filter((u) => !u.path.endsWith("/_index"));
+    await markChecked();
+  } catch (err) {
+    spinner.fail("No se pudo comprobar actualizaciones.");
+    throw err;
+  }
+
+  if (updates.length === 0) {
+    spinner.succeed("Todo al día — no hay actualizaciones.");
+    return;
+  }
+
+  spinner.succeed(`${updates.length} actualización(es) disponible(s):\n`);
+
+  let updated = 0;
+  for (const upd of updates) {
+    console.log(
+      `  ${chalk.cyan(upd.path)}  ${chalk.gray(upd.currentVersion)} → ${chalk.green(upd.latestVersion)}`
+    );
+    if (upd.author) console.log(chalk.dim(`    Autor: ${upd.author}`));
+    if (upd.description) console.log(chalk.dim(`    ${upd.description}`));
+
+    const { doUpdate } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "doUpdate",
+        message: `¿Actualizar ${upd.path}?`,
+        default: true,
+      },
+    ]);
+
+    if (!doUpdate) {
+      console.log(chalk.dim("    Omitido.\n"));
+      continue;
+    }
+
+    const installSpinner = ora(`Actualizando ${upd.path}...`).start();
+    try {
+      // Fetch full skill content
+      const skill = await apiRequest(
+        `/api/companies/${config.companyId}/skills/${upd.id}`
+      );
+
+      // Find installed entry to know tool and scope
+      const entry = installed.find((s) => s.path === upd.path);
+      const tool = entry?.tool || config.defaultTool;
+      const scope = entry?.scope || "project";
+
+      const adapter = getAdapter(tool);
+      await adapter.install(skill.path, skill.content || "", scope);
+      await updateInstalledVersion(upd.path, upd.latestVersion);
+
+      updated++;
+      installSpinner.succeed(`Actualizada ${upd.path} a v${upd.latestVersion}`);
+    } catch (err) {
+      installSpinner.fail(`Error actualizando ${upd.path}`);
+      console.error(chalk.red(`    ${err.message}`));
+    }
+    console.log();
+  }
+
+  console.log(chalk.green(`✔ ${updated} skill(s) actualizado(s)`));
+}
+
+// Passive check — called from other commands
+export async function checkUpdatesPassive(config) {
+  try {
+    const installed = await getInstalledSkills();
+    if (installed.length === 0) return;
+
+    const body = installed.map((s) => ({ path: s.path, version: s.version }));
+    const result = await apiRequest(
+      `/api/companies/${config.companyId}/skills/check-updates`,
+      {
+        method: "POST",
+        body: JSON.stringify({ installed: body }),
+      }
+    );
+    await markChecked();
+
+    const updates = (result.updates || []).filter((u) => !u.path.endsWith("/_index"));
+    if (updates.length > 0) {
+      console.log(
+        chalk.yellow(
+          `\n  ⚠ ${updates.length} actualización(es) disponible(s):`
+        )
+      );
+      for (const u of updates) {
+        console.log(
+          chalk.dim(`    ${u.path}  ${u.currentVersion} → ${u.latestVersion}`)
+        );
+      }
+      console.log(chalk.dim("    Ejecuta: skill-manager update\n"));
+    }
+  } catch {
+    // Silent fail — don't break the main command
+  }
+}

package/src/utils/config.js

@@ -25,8 +25,19 @@ export async function saveConfig(config) {
 }
 
 export async function requireConfig() {
+  // Check credentials first
+  const { homedir } = await import("node:os");
+  const credsPath = join(homedir(), ".skill-manager", "credentials.json");
+  try {
+    await readFile(credsPath, "utf-8");
+  } catch {
+    throw new Error(
+      "No estás autenticado. Ejecuta primero: skill-manager login"
+    );
+  }
+
   const config = await loadConfig();
-  if (!config) {
+  if (!config || !config.companyId) {
     throw new Error(
       "No se encontró configuración. Ejecuta primero: skill-manager init"
     );

package/src/utils/installed.js

@@ -0,0 +1,76 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+const CONFIG_DIR = join(homedir(), ".skill-manager");
+const INSTALLED_FILE = join(CONFIG_DIR, "installed.json");
+const CHECK_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+async function loadInstalled() {
+  try {
+    const raw = await readFile(INSTALLED_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return { lastCheckAt: null, skills: [] };
+    throw err;
+  }
+}
+
+async function saveInstalled(data) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(INSTALLED_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+
+export async function trackInstall(skill, tool, scope) {
+  // Never track auto-generated _index skills
+  if (skill.path.endsWith("/_index")) return;
+
+  const data = await loadInstalled();
+
+  // Remove existing entry for same path + projectDir
+  const projectDir = scope === "project" ? process.cwd() : null;
+  data.skills = data.skills.filter(
+    (s) => !(s.path === skill.path && s.projectDir === projectDir)
+  );
+
+  data.skills.push({
+    path: skill.path,
+    version: skill.version,
+    skillId: skill.id,
+    companyId: skill.company_id,
+    installedAt: new Date().toISOString(),
+    tool,
+    scope,
+    projectDir,
+  });
+
+  await saveInstalled(data);
+}
+
+export async function getInstalledSkills() {
+  const data = await loadInstalled();
+  return data.skills || [];
+}
+
+export async function updateInstalledVersion(path, newVersion) {
+  const data = await loadInstalled();
+  for (const s of data.skills) {
+    if (s.path === path) {
+      s.version = newVersion;
+      s.installedAt = new Date().toISOString();
+    }
+  }
+  await saveInstalled(data);
+}
+
+export async function shouldCheckUpdates() {
+  const data = await loadInstalled();
+  if (!data.lastCheckAt) return true;
+  return Date.now() - new Date(data.lastCheckAt).getTime() > CHECK_INTERVAL_MS;
+}
+
+export async function markChecked() {
+  const data = await loadInstalled();
+  data.lastCheckAt = new Date().toISOString();
+  await saveInstalled(data);
+}