@basetisia/skill-manager 0.1.0

package/src/commands/list.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getAllSkills } from "../manifest.js";
+
+const SECTIONS = [
+  { prefix: "user/", label: "User Skills" },
+  { prefix: "internal/", label: "Internal Skills" },
+  { prefix: "external/", label: "External Skills" },
+];
+
+export async function list(options = {}) {
+  const spinner = ora("Cargando catálogo de skills...").start();
+
+  let skills;
+  try {
+    skills = await getAllSkills();
+    spinner.succeed("Catálogo cargado.");
+  } catch (err) {
+    spinner.fail("Error cargando el catálogo.");
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  if (options.filter) {
+    const term = options.filter.toLowerCase();
+    skills = skills.filter((s) => s.path.toLowerCase().includes(term));
+  }
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow("No se encontraron skills."));
+    return;
+  }
+
+  for (const section of SECTIONS) {
+    const group = skills.filter((s) => s.path.startsWith(section.prefix));
+    if (group.length === 0) continue;
+
+    console.log();
+    console.log(chalk.blue.bold(`  ${section.label}`));
+    console.log(chalk.blue("  " + "─".repeat(40)));
+
+    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}`
+      );
+    }
+  }
+
+  // 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}`)}`
+      );
+    }
+  }
+
+  console.log();
+  console.log(chalk.dim(`  Total: ${skills.length} skills`));
+}

package/src/commands/login.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+import ora from "ora";
+import { startLoginFlow, loadCredentials, parseIdToken } from "../utils/auth.js";
+
+export async function login() {
+  // Check if already logged in
+  const creds = await loadCredentials();
+  if (creds) {
+    const user = parseIdToken(creds.id_token);
+    if (user && creds.expires_at > Date.now()) {
+      console.log(
+        chalk.yellow(`Ya estás autenticado como ${user.email}. Iniciando nuevo login...\n`)
+      );
+    }
+  }
+
+  const spinner = ora("Abriendo navegador para autenticación...").start();
+
+  try {
+    const user = await startLoginFlow();
+    spinner.succeed(
+      chalk.green(`Autenticado como ${chalk.bold(user.email)}`)
+    );
+    console.log(chalk.dim("  Token guardado en ~/.skill-manager/credentials.json"));
+  } catch (err) {
+    spinner.fail(chalk.red("Error de autenticación"));
+    throw err;
+  }
+}

package/src/commands/logout.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+import { loadCredentials, clearCredentials } from "../utils/auth.js";
+
+export async function logout() {
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.log(chalk.dim("No hay sesión activa."));
+    return;
+  }
+
+  await clearCredentials();
+  console.log(chalk.green("Sesión cerrada correctamente."));
+}

package/src/commands/status.js

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import ora from "ora";
+import { detectInstalledTools } from "../adapters/index.js";
+import { getSkillInfo } from "../manifest.js";
+
+export async function status() {
+  const spinner = ora("Detectando herramientas instaladas...").start();
+  const tools = await detectInstalledTools();
+
+  if (tools.length === 0) {
+    spinner.fail("No se detectó ninguna herramienta de IA instalada.");
+    return;
+  }
+  spinner.succeed(`${tools.length} herramienta(s) detectada(s).`);
+
+  for (const adapter of tools) {
+    console.log();
+    console.log(chalk.blue.bold(`  ${adapter.displayName}`));
+    console.log(chalk.blue("  " + "─".repeat(50)));
+
+    for (const scope of ["personal", "project"]) {
+      const skills = await adapter.getInstalledSkills(scope);
+      if (skills.length === 0) continue;
+
+      const label = scope === "personal" ? "Global" : "Proyecto";
+      console.log(chalk.dim(`  [${label}]`));
+
+      for (const skill of skills) {
+        let catalogVersion = null;
+        let statusIcon;
+        let statusColor;
+
+        try {
+          const info = await getSkillInfo(skill.path);
+          catalogVersion = info.version;
+          if (skill.version === catalogVersion) {
+            statusIcon = "✓ al día";
+            statusColor = chalk.green;
+          } else {
+            statusIcon = `⬆ ${catalogVersion} disponible`;
+            statusColor = chalk.yellow;
+          }
+        } catch {
+          statusIcon = "? no en catálogo";
+          statusColor = chalk.gray;
+        }
+
+        const installed = chalk.white(skill.version);
+        console.log(
+          `  ${chalk.white(skill.path.padEnd(35))} ${installed.padEnd(10)}  ${statusColor(statusIcon)}`
+        );
+      }
+    }
+  }
+  console.log();
+}

package/src/commands/whoami.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+import { loadCredentials, parseIdToken } from "../utils/auth.js";
+
+export async function whoami() {
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.log(chalk.yellow("No estás autenticado."));
+    console.log(chalk.dim("Ejecuta: skill-manager login"));
+    return;
+  }
+
+  const user = parseIdToken(creds.id_token);
+  if (!user) {
+    console.log(chalk.red("Token inválido. Ejecuta: skill-manager login"));
+    return;
+  }
+
+  const expired = creds.expires_at < Date.now();
+  const expiresIn = Math.round((creds.expires_at - Date.now()) / 60_000);
+
+  console.log(chalk.bold("  Nombre:"), user.name);
+  console.log(chalk.bold("  Email: "), user.email);
+
+  if (expired) {
+    console.log(chalk.bold("  Token: "), chalk.red("expirado (se renovará automáticamente)"));
+  } else {
+    console.log(chalk.bold("  Token: "), chalk.green(`válido (${expiresIn} min restantes)`));
+  }
+}

package/src/manifest.js

@@ -0,0 +1,84 @@
+import yaml from "js-yaml";
+import { requireConfig } from "./utils/config.js";
+import { fetchFileContent } from "./utils/gitlab.js";
+
+let cachedManifest = null;
+
+export async function fetchManifest(configOverride) {
+  if (cachedManifest) return cachedManifest;
+
+  const config = configOverride || (await requireConfig());
+  let raw;
+  try {
+    raw = await fetchFileContent("manifest.yml", config);
+  } catch (err) {
+    if (err.message.includes("no existe")) {
+      throw new Error(
+        "No se puede conectar al repositorio. Verifica tu token y URL."
+      );
+    }
+    throw err;
+  }
+
+  let manifest;
+  try {
+    manifest = yaml.load(raw);
+  } catch {
+    throw new Error("El manifest.yml tiene un formato incorrecto.");
+  }
+
+  if (!manifest || !manifest.skills || !Array.isArray(manifest.skills)) {
+    throw new Error("El manifest.yml tiene un formato incorrecto.");
+  }
+
+  cachedManifest = manifest;
+  return manifest;
+}
+
+export async function getAllSkills(configOverride) {
+  const manifest = await fetchManifest(configOverride);
+  return manifest.skills.map((s) => ({
+    path: s.path,
+    version: s.version || "0.0.0",
+    parent: s.parent || null,
+    upstream: s.upstream || null,
+  }));
+}
+
+export async function getSkillInfo(skillPath, configOverride) {
+  const skills = await getAllSkills(configOverride);
+  const skill = skills.find((s) => s.path === skillPath);
+  if (!skill) {
+    throw new Error(`La skill '${skillPath}' no existe en el catálogo.`);
+  }
+  return skill;
+}
+
+export async function resolveChain(skillPath, configOverride) {
+  const skills = await getAllSkills(configOverride);
+  const byPath = new Map(skills.map((s) => [s.path, s]));
+
+  const skill = byPath.get(skillPath);
+  if (!skill) {
+    throw new Error(`La skill '${skillPath}' no existe en el catálogo.`);
+  }
+
+  const chain = [skill];
+  let current = skill;
+  while (current.parent) {
+    const parent = byPath.get(current.parent);
+    if (!parent) {
+      throw new Error(
+        `La skill padre '${current.parent}' referenciada por '${current.path}' no existe en el catálogo.`
+      );
+    }
+    chain.unshift(parent);
+    current = parent;
+  }
+
+  return chain;
+}
+
+export function clearCache() {
+  cachedManifest = null;
+}

package/src/manifest.test.js

@@ -0,0 +1,183 @@
+import { describe, it, beforeEach, mock } from "node:test";
+import assert from "node:assert/strict";
+import yaml from "js-yaml";
+import { fetchManifest, getAllSkills, getSkillInfo, resolveChain, clearCache } from "./manifest.js";
+
+const MOCK_MANIFEST = {
+  skills: [
+    { path: "external/sector/pharma", version: "1.0.0", parent: null, upstream: null },
+    { path: "external/client/alexion", version: "1.2.0", parent: "external/sector/pharma", upstream: null },
+    { path: "external/project/alexion-cockpit", version: "2.0.0", parent: "external/client/alexion", upstream: null },
+    { path: "internal/tooling/eslint-config", version: "0.5.0", parent: null, upstream: null },
+  ],
+};
+
+const MOCK_CONFIG = {
+  registry: {
+    type: "gitlab",
+    url: "https://git.basetis.com",
+    projectId: "okr-ia/basetisskills",
+    token: "fake-token",
+    branch: "main",
+  },
+  defaultTool: "claude",
+};
+
+function mockFetch() {
+  return mock.fn(() =>
+    Promise.resolve({
+      ok: true,
+      text: () => Promise.resolve(yaml.dump(MOCK_MANIFEST)),
+    })
+  );
+}
+
+describe("manifest", () => {
+  beforeEach(() => {
+    clearCache();
+  });
+
+  it("fetchManifest parses yaml and returns manifest", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      const manifest = await fetchManifest(MOCK_CONFIG);
+      assert.equal(manifest.skills.length, 4);
+      assert.equal(manifest.skills[0].path, "external/sector/pharma");
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("fetchManifest caches result on second call", async () => {
+    const original = globalThis.fetch;
+    const mockedFetch = mockFetch();
+    globalThis.fetch = mockedFetch;
+    try {
+      await fetchManifest(MOCK_CONFIG);
+      await fetchManifest(MOCK_CONFIG);
+      assert.equal(mockedFetch.mock.callCount(), 1);
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("getAllSkills returns normalized skill objects", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      const skills = await getAllSkills(MOCK_CONFIG);
+      assert.equal(skills.length, 4);
+      assert.deepEqual(skills[0], {
+        path: "external/sector/pharma",
+        version: "1.0.0",
+        parent: null,
+        upstream: null,
+      });
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("getSkillInfo returns a specific skill", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      const skill = await getSkillInfo("external/client/alexion", MOCK_CONFIG);
+      assert.equal(skill.path, "external/client/alexion");
+      assert.equal(skill.parent, "external/sector/pharma");
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("getSkillInfo throws for unknown skill", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      await assert.rejects(
+        () => getSkillInfo("unknown/skill", MOCK_CONFIG),
+        { message: "La skill 'unknown/skill' no existe en el catálogo." }
+      );
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("resolveChain returns full parent chain in order", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      const chain = await resolveChain("external/project/alexion-cockpit", MOCK_CONFIG);
+      const paths = chain.map((s) => s.path);
+      assert.deepEqual(paths, [
+        "external/sector/pharma",
+        "external/client/alexion",
+        "external/project/alexion-cockpit",
+      ]);
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("resolveChain returns single element for skill without parent", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      const chain = await resolveChain("internal/tooling/eslint-config", MOCK_CONFIG);
+      assert.equal(chain.length, 1);
+      assert.equal(chain[0].path, "internal/tooling/eslint-config");
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("resolveChain throws for unknown skill", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mockFetch();
+    try {
+      await assert.rejects(
+        () => resolveChain("nonexistent/skill", MOCK_CONFIG),
+        { message: "La skill 'nonexistent/skill' no existe en el catálogo." }
+      );
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("fetchManifest throws on malformed yaml", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mock.fn(() =>
+      Promise.resolve({
+        ok: true,
+        text: () => Promise.resolve("{ invalid: [yaml"),
+      })
+    );
+    try {
+      await assert.rejects(
+        () => fetchManifest(MOCK_CONFIG),
+        { message: "El manifest.yml tiene un formato incorrecto." }
+      );
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("fetchManifest throws on manifest without skills array", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = mock.fn(() =>
+      Promise.resolve({
+        ok: true,
+        text: () => Promise.resolve(yaml.dump({ version: "1.0" })),
+      })
+    );
+    try {
+      await assert.rejects(
+        () => fetchManifest(MOCK_CONFIG),
+        { message: "El manifest.yml tiene un formato incorrecto." }
+      );
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+});

package/src/utils/api.js

@@ -0,0 +1,39 @@
+import { getValidToken, clearCredentials } from "./auth.js";
+import { loadConfig } from "./config.js";
+
+const DEFAULT_API_URL = "https://skillsmanager.basetis.com";
+
+async function getApiUrl() {
+  const config = await loadConfig();
+  return config?.apiUrl || DEFAULT_API_URL;
+}
+
+export async function apiRequest(path, options = {}) {
+  const token = await getValidToken();
+  const apiUrl = await getApiUrl();
+
+  const response = await fetch(`${apiUrl}${path}`, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (response.status === 401) {
+    await clearCredentials();
+    throw new Error("Sesión inválida. Ejecuta: skill-manager login");
+  }
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`API error ${response.status}: ${body}`);
+  }
+
+  return response.json();
+}
+
+export async function requireAuth() {
+  await getValidToken();
+}