@basetisia/skill-manager 0.1.2 → 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,11 +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();
 
@@ -56,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")
@@ -80,6 +127,42 @@ program
     }
   });
 
+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")
+  .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.1.2",
+  "version": "0.3.0",
   "description": "CLI to manage AI coding skills across editors",
   "type": "module",
   "engines": {

package/src/commands/init.js

@@ -2,16 +2,28 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import ora from "ora";
 import { loadConfig, saveConfig, getConfigPath } from "../utils/config.js";
-import { verifyConnection } from "../utils/gitlab.js";
+import { loadCredentials } from "../utils/auth.js";
+import { apiRequest } from "../utils/api.js";
+import { generateFindSkill } from "../utils/find-skill.js";
+import { getAdapter } from "../adapters/index.js";
 
 export async function init() {
+  // Check auth
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.log(
+      chalk.red("No estás autenticado. Ejecuta primero: skill-manager login")
+    );
+    process.exit(1);
+  }
+
   const existing = await loadConfig();
-  if (existing) {
+  if (existing?.companyId) {
     const { overwrite } = await inquirer.prompt([
       {
         type: "confirm",
         name: "overwrite",
-        message: "Ya existe una configuración. ¿Deseas sobrescribirla?",
+        message: `Ya estás configurado para ${existing.companyName || "una empresa"}. ¿Reconfigurar?`,
         default: false,
       },
     ]);
@@ -21,110 +33,101 @@ export async function init() {
     }
   }
 
-  const answers = await inquirer.prompt([
-    {
-      type: "list",
-      name: "type",
-      message: "Tipo de repositorio de skills:",
-      choices: [
-        { name: "GitLab", value: "gitlab" },
-        { name: "GitHub", value: "github" },
-        { name: "Local (carpeta en disco)", value: "local" },
-      ],
-    },
-    {
-      type: "input",
-      name: "url",
-      message: "URL base del servidor:",
-      default: (prev) =>
-        prev.type === "github"
-          ? "https://github.com"
-          : "https://git.basetis.com",
-      when: (prev) => prev.type !== "local",
-    },
-    {
-      type: "input",
-      name: "projectId",
-      message: (prev) =>
-        prev.type === "gitlab"
-          ? "Project ID (numérico) o ruta (grupo/repo):"
-          : "Repositorio (owner/repo):",
-      default: (prev) =>
-        prev.type === "gitlab" ? "okr-ia/basetisskills" : "",
-      when: (prev) => prev.type !== "local",
-      validate: (val) => (val.trim() ? true : "Este campo es obligatorio."),
-    },
-    {
-      type: "input",
-      name: "localPath",
-      message: "Ruta absoluta a la carpeta de skills:",
-      when: (prev) => prev.type === "local",
-      validate: (val) => (val.trim() ? true : "Este campo es obligatorio."),
-    },
-    {
-      type: "password",
-      name: "token",
-      message: "Token de acceso personal (se guardará en ~/.skill-manager/config.json):",
-      when: (prev) => prev.type !== "local",
-      validate: (val) => (val.trim() ? true : "El token es obligatorio para repos remotos."),
-    },
-    {
-      type: "input",
-      name: "branch",
-      message: "Rama del repositorio:",
-      default: "main",
-      when: (prev) => prev.type !== "local",
-    },
+  // Fetch user info from API
+  const spinner = ora("Conectando con Skillsmanager...").start();
+  let me;
+  try {
+    me = await apiRequest("/api/me");
+    spinner.succeed(`Conectado como ${chalk.bold(me.name)} (${me.email})`);
+  } catch (err) {
+    spinner.fail("No se pudo conectar con la API.");
+    console.error(chalk.red(`  ${err.message}`));
+    process.exit(1);
+  }
+
+  if (!me.companies || me.companies.length === 0) {
+    console.log(
+      chalk.red(
+        "\nNo perteneces a ninguna empresa. Contacta con un administrador."
+      )
+    );
+    process.exit(1);
+  }
+
+  // Select company (if more than one)
+  let company;
+  if (me.companies.length === 1) {
+    company = me.companies[0];
+    console.log(chalk.dim(`  Empresa: ${company.name} (${company.role})`));
+  } else {
+    const { companyId } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "companyId",
+        message: "Selecciona tu empresa:",
+        choices: me.companies.map((c) => ({
+          name: `${c.name} (${c.role})`,
+          value: c.id,
+        })),
+      },
+    ]);
+    company = me.companies.find((c) => c.id === companyId);
+  }
+
+  // Select default tool
+  const { defaultTool } = await inquirer.prompt([
     {
       type: "list",
       name: "defaultTool",
       message: "Herramienta de IA por defecto:",
       choices: [
         { name: "Claude Code", value: "claude" },
-        { name: "Gemini CLI", value: "gemini" },
         { name: "Cursor", value: "cursor" },
         { name: "Windsurf", value: "windsurf" },
-        { name: "Preguntar siempre", value: null },
+        { name: "Gemini CLI", value: "gemini" },
+        { name: "Codex", value: "codex" },
       ],
+      default: existing?.defaultTool || "claude",
     },
   ]);
 
   const config = {
-    registry: {
-      type: answers.type,
-      url: answers.url || null,
-      projectId: answers.projectId || answers.localPath || "",
-      token: answers.token || "",
-      branch: answers.branch || "main",
-    },
-    defaultTool: answers.defaultTool,
+    companyId: company.id,
+    companyName: company.name,
+    apiUrl: existing?.apiUrl || "http://localhost:3001",
+    defaultTool,
   };
 
-  // Verify remote connection
-  if (config.registry.type !== "local") {
-    const spinner = ora("Verificando conexión con el repositorio...").start();
-    try {
-      await verifyConnection(config.registry);
-      spinner.succeed("Conexión verificada correctamente.");
-    } catch (err) {
-      spinner.fail("No se pudo conectar al repositorio.");
-      console.error(chalk.red(`  Error: ${err.message}`));
-      const { saveAnyway } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "saveAnyway",
-          message: "¿Guardar la configuración de todas formas?",
-          default: false,
-        },
-      ]);
-      if (!saveAnyway) {
-        console.log(chalk.yellow("Operación cancelada."));
-        return;
-      }
-    }
+  await saveConfig(config);
+
+  // Generate and install find-skill
+  const findSpinner = ora("Generando find-skill personalizado...").start();
+  try {
+    const findSkillContent = await generateFindSkill(config);
+    const adapter = getAdapter(defaultTool);
+    await adapter.install("find-skill", findSkillContent, "personal");
+    findSpinner.succeed("Find-skill instalado");
+  } catch (err) {
+    findSpinner.fail("No se pudo instalar el find-skill");
+    console.error(chalk.dim(`  ${err.message}`));
+    console.log(
+      chalk.dim("  Puedes intentarlo más tarde con: skill-manager sync")
+    );
   }
 
-  await saveConfig(config);
-  console.log(chalk.green("✔ Configuración guardada correctamente."));
+  console.log(chalk.green("\n✔ Configuración completa."));
   console.log(chalk.dim(`  → ${getConfigPath()}`));
+  console.log(
+    chalk.dim(
+      `  Empresa: ${company.name} | Herramienta: ${defaultTool}`
+    )
+  );
+  console.log(
+    chalk.dim(
+      "\n  El find-skill te recomendará skills cuando trabajes en tu editor."
+    )
+  );
+  console.log(
+    chalk.dim("  Para ver skills disponibles: skill-manager list")
+  );
 }

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

@@ -1,29 +1,105 @@
 import chalk from "chalk";
 import ora from "ora";
 import inquirer from "inquirer";
-import { resolveChain } from "../manifest.js";
-import { fetchFileContent } from "../utils/gitlab.js";
+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 = {}) {
-  // Resolve the full dependency chain
-  const spinner = ora("Resolviendo dependencias...").start();
-  let chain;
+  const config = await requireConfig();
+
+  // Fetch all published skills
+  const spinner = ora("Cargando skills...").start();
+  let skills;
   try {
-    chain = await resolveChain(skillPath);
-    spinner.succeed(`Cadena resuelta: ${chain.length} skill(s).`);
+    skills = await apiRequest(`/api/companies/${config.companyId}/skills`);
+    skills = skills.filter((s) => s.status === "published");
   } catch (err) {
-    spinner.fail("Error resolviendo dependencias.");
-    console.error(chalk.red(err.message));
+    spinner.fail("No se pudieron cargar los skills.");
+    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) {
+    spinner.fail(`Skill no encontrado: ${skillPath}`);
+    console.log(
+      chalk.dim("  Usa 'skill-manager list' para ver los skills disponibles.")
+    );
     process.exit(1);
   }
 
+  // Find children (skills whose path starts with target path)
+  const children = skills.filter(
+    (s) =>
+      s.path !== target.path &&
+      s.path.startsWith(target.path + "/") &&
+      !s.path.endsWith("/_index")
+  );
+
+  spinner.stop();
+
+  // Build install list
+  const toInstall = [target];
+
+  if (children.length > 0) {
+    console.log(
+      chalk.blue.bold(
+        `\n  ${target.name} tiene ${children.length} skill(s) hijo(s):\n`
+      )
+    );
+    for (const child of children) {
+      const desc = child.description ? chalk.dim(` — ${child.description}`) : "";
+      console.log(`    ${chalk.cyan(child.path)}${desc}`);
+    }
+    console.log();
+
+    const { childAction } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "childAction",
+        message: "¿Qué quieres hacer?",
+        choices: [
+          { name: "Instalar solo el padre", value: "parent" },
+          { name: "Instalar padre + todos los hijos", value: "all" },
+          { name: "Seleccionar cuáles instalar", value: "select" },
+        ],
+      },
+    ]);
+
+    if (childAction === "all") {
+      toInstall.push(...children);
+    } else if (childAction === "select") {
+      const { selected } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selected",
+          message: "Selecciona los skills a instalar:",
+          choices: children.map((c) => ({
+            name: `${c.path} ${chalk.dim(c.description || "")}`,
+            value: c.path,
+            checked: false,
+          })),
+        },
+      ]);
+      const selectedSkills = children.filter((c) =>
+        selected.includes(c.path)
+      );
+      toInstall.push(...selectedSkills);
+    }
+  }
+
   // Show what will be installed
-  console.log();
-  console.log(chalk.blue.bold("  Skills a instalar (en orden):"));
-  for (const [i, skill] of chain.entries()) {
-    const arrow = i < chain.length - 1 ? "├─" : "└─";
-    console.log(`  ${arrow} ${skill.path} ${chalk.gray(`v${skill.version}`)}`);
+  console.log(chalk.blue.bold("\n  Skills a instalar:\n"));
+  for (const [i, skill] of toInstall.entries()) {
+    const arrow = i < toInstall.length - 1 ? "├─" : "└─";
+    console.log(
+      `  ${arrow} ${skill.path} ${chalk.gray(`v${skill.version}`)}`
+    );
   }
   console.log();
 
@@ -31,6 +107,8 @@ export async function install(skillPath, options = {}) {
   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) {
@@ -66,28 +144,26 @@ export async function install(skillPath, options = {}) {
         message: "¿Dónde instalar las skills?",
         choices: [
           { name: "Global (solo para ti, en ~/)", value: "personal" },
-          { name: "Proyecto (commitear al repo)", value: "project" },
+          { name: "Proyecto (en el repo actual)", value: "project" },
         ],
       },
     ]);
     scope = chosen;
   }
-  // Normalize "global" to "personal"
   if (scope === "global") scope = "personal";
 
-  // Install each skill in each tool
+  // Install
   const adapters = toolNames.map((name) => getAdapter(name));
   let installed = 0;
 
-  for (const skill of chain) {
+  for (const skill of toInstall) {
     const installSpinner = ora(`Instalando ${skill.path}...`).start();
     try {
-      const skillFile = `${skill.path}/SKILL.md`;
-      const content = await fetchFileContent(skillFile);
-
+      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) {
@@ -100,6 +176,8 @@ export async function install(skillPath, options = {}) {
   console.log();
   const toolList = adapters.map((a) => a.displayName).join(" y ");
   console.log(
-    chalk.green(`✔ ${installed} skill(s) instalada(s) en ${toolList} (${scope})`)
+    chalk.green(
+      `✔ ${installed} skill(s) instalada(s) en ${toolList} (${scope})`
+    )
   );
 }

package/src/commands/list.js

@@ -1,29 +1,58 @@
 import chalk from "chalk";
 import ora from "ora";
-import { getAllSkills } from "../manifest.js";
+import { requireConfig } from "../utils/config.js";
+import { apiRequest } from "../utils/api.js";
+import { shouldCheckUpdates } from "../utils/installed.js";
+import { checkUpdatesPassive } from "./update.js";
 
-const SECTIONS = [
-  { prefix: "user/", label: "User Skills" },
-  { prefix: "internal/", label: "Internal Skills" },
-  { prefix: "external/", label: "External Skills" },
-];
+const LEVEL_ICONS = {
+  root: "🏢",
+  user: "👤",
+  habilidades: "🛠",
+  area: "📂",
+  team: "👥",
+  sector: "🏭",
+  proyecto: "📦",
+};
+
+const TYPE_LABELS = {
+  contexto: chalk.blue("contexto"),
+  habilidad: chalk.magenta("habilidad"),
+  agente: chalk.green("agente"),
+};
 
 export async function list(options = {}) {
-  const spinner = ora("Cargando catálogo de skills...").start();
+  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 {
-    skills = await getAllSkills();
-    spinner.succeed("Catálogo cargado.");
+    skills = await apiRequest(`/api/companies/${config.companyId}/skills`);
+    spinner.stop();
   } catch (err) {
-    spinner.fail("Error cargando el catálogo.");
-    console.error(chalk.red(err.message));
-    process.exit(1);
+    spinner.fail("No se pudieron cargar los skills.");
+    throw err;
   }
 
+  // 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) {
-    const term = options.filter.toLowerCase();
-    skills = skills.filter((s) => s.path.toLowerCase().includes(term));
+    const q = options.filter.toLowerCase();
+    skills = skills.filter(
+      (s) =>
+        s.name.toLowerCase().includes(q) ||
+        s.path.toLowerCase().includes(q) ||
+        (s.description || "").toLowerCase().includes(q)
+    );
   }
 
   if (skills.length === 0) {
@@ -31,39 +60,39 @@ export async function list(options = {}) {
     return;
   }
 
-  for (const section of SECTIONS) {
-    const group = skills.filter((s) => s.path.startsWith(section.prefix));
-    if (group.length === 0) continue;
+  // Group by level
+  const groups = {};
+  for (const s of skills) {
+    const level = s.level || "otro";
+    if (!groups[level]) groups[level] = [];
+    groups[level].push(s);
+  }
 
-    console.log();
-    console.log(chalk.blue.bold(`  ${section.label}`));
-    console.log(chalk.blue("  " + "─".repeat(40)));
+  console.log(chalk.bold(`\n  ${skills.length} skills disponibles\n`));
 
-    for (const skill of group) {
-      const parent = skill.parent
-        ? chalk.dim(` ← ${skill.parent}`)
-        : "";
-      console.log(
-        `  ${chalk.white(skill.path)}  ${chalk.gray(`v${skill.version}`)}${parent}`
-      );
-    }
-  }
+  const levelOrder = [
+    "root",
+    "habilidades",
+    "area",
+    "team",
+    "sector",
+    "proyecto",
+    "user",
+  ];
 
-  // Skills that don't match any section
-  const uncategorized = skills.filter(
-    (s) => !SECTIONS.some((sec) => s.path.startsWith(sec.prefix))
-  );
-  if (uncategorized.length > 0) {
-    console.log();
-    console.log(chalk.blue.bold("  Other"));
-    console.log(chalk.blue("  " + "─".repeat(40)));
-    for (const skill of uncategorized) {
-      console.log(
-        `  ${chalk.white(skill.path)}  ${chalk.gray(`v${skill.version}`)}`
-      );
+  for (const level of levelOrder) {
+    const items = groups[level];
+    if (!items) continue;
+
+    const icon = LEVEL_ICONS[level] || "•";
+    console.log(chalk.bold(`  ${icon} ${level.toUpperCase()}`));
+
+    for (const s of items) {
+      const type = TYPE_LABELS[s.skill_type] || s.skill_type;
+      const path = chalk.cyan(s.path);
+      const desc = s.description ? chalk.dim(` — ${s.description}`) : "";
+      console.log(`    ${path}  ${type}${desc}`);
     }
+    console.log();
   }
-
-  console.log();
-  console.log(chalk.dim(`  Total: ${skills.length} skills`));
 }

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/sync.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+import ora from "ora";
+import { requireConfig } from "../utils/config.js";
+import { generateFindSkill } from "../utils/find-skill.js";
+import { getAdapter } from "../adapters/index.js";
+
+export async function sync() {
+  const config = await requireConfig();
+
+  const spinner = ora("Actualizando find-skill...").start();
+  try {
+    const findSkillContent = await generateFindSkill(config);
+    const adapter = getAdapter(config.defaultTool);
+    await adapter.install("find-skill", findSkillContent, "personal");
+    spinner.succeed("Find-skill actualizado con tus permisos más recientes");
+  } catch (err) {
+    spinner.fail("No se pudo actualizar el find-skill");
+    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/api.js

@@ -1,7 +1,7 @@
 import { getValidToken, clearCredentials } from "./auth.js";
 import { loadConfig } from "./config.js";
 
-const DEFAULT_API_URL = "https://skillsmanager.basetis.com";
+const DEFAULT_API_URL = "http://localhost:3001";
 
 async function getApiUrl() {
   const config = await loadConfig();

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/find-skill.js

@@ -0,0 +1,123 @@
+import { apiRequest } from "./api.js";
+
+export async function generateFindSkill(config) {
+  const permissions = await apiRequest("/api/me/permissions");
+
+  if (!permissions.company) {
+    throw new Error("No perteneces a ninguna empresa.");
+  }
+
+  const { company, entities, projects } = permissions;
+  const tool = config.defaultTool || "tu herramienta";
+  const toolLabel = {
+    claude: "Claude Code",
+    cursor: "Cursor",
+    windsurf: "Windsurf",
+    gemini: "Gemini CLI",
+    codex: "Codex",
+  }[config.defaultTool] || config.defaultTool;
+
+  const me = await apiRequest("/api/me");
+
+  let md = `# Skill Finder — ${company.name}
+
+Eres un asistente de descubrimiento de skills para ${me.name} (${me.email}).
+Tu función es ayudar al usuario a encontrar e instalar los skills relevantes
+para su proyecto usando el CLI de Basetis Skill Manager.
+
+## Tu usuario
+- Nombre: ${me.name}
+- Empresa: ${company.name}
+- Rol: ${company.role}
+- Herramienta: ${toolLabel}
+
+## Instrucciones
+
+### Cuándo recomendar
+- Cuando el usuario empiece a trabajar en un proyecto nuevo
+- Cuando detectes tecnologías en el proyecto para las que hay skills disponibles
+- Cuando el usuario pregunte por buenas prácticas o configuración
+- Cuando el usuario haga algo que un skill podría mejorar
+
+### Cómo recomendar
+- Analiza los ficheros del proyecto (package.json, tsconfig.json, Dockerfile, etc.)
+- Menciona el skill y qué aporta en UNA línea
+- Da el comando exacto para instalar
+- No insistas si el usuario no quiere — menciona una vez y ya
+
+### Qué puede instalar este usuario
+
+#### Habilidades (cross-cutting, para todos en ${company.name})
+Skills de lenguajes, frameworks, herramientas y buenas prácticas compartidas.
+
+\`\`\`bash
+skill-manager list --filter habilidades
+\`\`\`
+
+Ejemplos de cuándo recomendar:
+- Si detectas TypeScript → \`skill-manager install habilidades/typescript\`
+- Si detectas React → \`skill-manager install habilidades/react\`
+- Si detectas Express → \`skill-manager install habilidades/express-api\`
+- Si detectas PostgreSQL → \`skill-manager install habilidades/postgresql\`
+`;
+
+  // Areas
+  const areas = entities.filter((e) => e.type === "area");
+  if (areas.length > 0) {
+    md += `
+#### Áreas: ${areas.map((a) => a.name).join(", ")}
+Skills específicos de las áreas donde eres miembro.
+
+${areas.map((a) => `\`\`\`bash\nskill-manager list --filter area/${a.slug}\n\`\`\``).join("\n")}
+`;
+  }
+
+  // Teams
+  const teams = entities.filter((e) => e.type === "team");
+  if (teams.length > 0) {
+    md += `
+#### Equipos: ${teams.map((t) => t.name).join(", ")}
+Skills específicos de tus equipos.
+
+${teams.map((t) => `\`\`\`bash\nskill-manager list --filter team/${t.slug}\n\`\`\``).join("\n")}
+`;
+  }
+
+  // Sectors
+  const sectors = entities.filter((e) => e.type === "sector");
+  if (sectors.length > 0) {
+    md += `
+#### Sectores: ${sectors.map((s) => s.name).join(", ")}
+
+${sectors.map((s) => `\`\`\`bash\nskill-manager list --filter sector/${s.slug}\n\`\`\``).join("\n")}
+`;
+  }
+
+  // Projects
+  if (projects.length > 0) {
+    md += `
+#### Proyectos: ${projects.map((p) => p.name).join(", ")}
+Skills específicos de tus proyectos asignados.
+
+${projects.map((p) => `\`\`\`bash\nskill-manager list --filter proyecto/${p.slug}\n\`\`\``).join("\n")}
+`;
+  }
+
+  md += `
+### Qué NO hacer
+- No menciones skills de áreas, equipos o proyectos que no aparecen en las secciones anteriores
+- No muestres el catálogo completo — recomienda solo lo relevante al contexto actual
+- No expongas emails, tokens ni información interna del sistema
+- No intentes modificar archivos de configuración del skill manager directamente
+- No instales skills tú mismo — siempre recomienda el comando CLI al usuario
+
+### Comandos útiles
+- Ver todo lo disponible: \`skill-manager list\`
+- Filtrar: \`skill-manager list --filter <texto>\`
+- Instalar: \`skill-manager install <path>\`
+- Ver quién eres: \`skill-manager whoami\`
+- Actualizar este skill: \`skill-manager sync\`
+`;
+
+  return md;
+}

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);
+}