@basetisia/skill-manager 0.1.1 → 0.2.0

package/bin/index.js

@@ -9,6 +9,7 @@ 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";
 
 const program = new Command();
 
@@ -80,6 +81,18 @@ 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("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.1",
+  "version": "0.2.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.js

@@ -1,29 +1,101 @@
 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";
 
 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;
+  }
+
+  // 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 +103,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,25 +140,22 @@ 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);
       }
@@ -100,6 +171,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,49 @@
 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";
 
-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();
 
+  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
+  skills = skills.filter((s) => s.status === "published");
+
+  // 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 +51,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/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/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/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;
+}