@basetisia/skill-manager 0.1.0

package/src/adapters/codex.js

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

package/src/adapters/cursor.js

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

package/src/adapters/gemini.js

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

package/src/adapters/index.js

@@ -0,0 +1,45 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { homeDir } from "../utils/fs.js";
+
+import * as claude from "./claude.js";
+import * as gemini from "./gemini.js";
+import * as codex from "./codex.js";
+import * as cursor from "./cursor.js";
+import * as windsurf from "./windsurf.js";
+
+const adapters = [claude, gemini, codex, cursor, windsurf];
+
+export function getAdapter(toolName) {
+  const adapter = adapters.find((a) => a.toolName === toolName);
+  if (!adapter) {
+    throw new Error(`Herramienta no soportada: ${toolName}`);
+  }
+  return adapter;
+}
+
+export function getAllAdapters() {
+  return adapters;
+}
+
+export async function detectInstalledTools() {
+  const home = homeDir();
+  const checks = [
+    { adapter: claude, dir: join(home, ".claude") },
+    { adapter: gemini, dir: join(home, ".gemini") },
+    { adapter: codex, dir: join(home, ".codex") },
+    { adapter: cursor, dir: join(home, ".cursor") },
+    { adapter: windsurf, dir: join(home, ".windsurf") },
+  ];
+
+  const results = [];
+  for (const { adapter, dir } of checks) {
+    try {
+      await access(dir);
+      results.push(adapter);
+    } catch {
+      // directory not found, tool not installed
+    }
+  }
+  return results;
+}

package/src/adapters/shared.js

@@ -0,0 +1,48 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { readFile } from "../utils/fs.js";
+
+export function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: content };
+  try {
+    const meta = yaml.load(match[1]) || {};
+    return { meta, body: match[2] };
+  } catch {
+    return { meta: {}, body: content };
+  }
+}
+
+export async function scanInstalledSkills(baseDir, segments = [], results = []) {
+  const entries = await readdir(baseDir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      await scanInstalledSkills(
+        join(baseDir, entry.name),
+        [...segments, entry.name],
+        results
+      );
+    }
+    if (entry.name === "SKILL.md") {
+      const content = await readFile(join(baseDir, "SKILL.md"));
+      if (content) {
+        const { meta } = parseFrontmatter(content);
+        results.push({
+          path: segments.join("/"),
+          version: meta.version || "unknown",
+        });
+      }
+    }
+  }
+  return results;
+}
+
+export async function scanDir(dirPath, ext) {
+  try {
+    const entries = await readdir(dirPath);
+    return entries.filter((f) => f.endsWith(ext));
+  } catch {
+    return [];
+  }
+}

package/src/adapters/windsurf.js

@@ -0,0 +1,82 @@
+import { join, basename } from "node:path";
+import { homeDir, cwdDir, writeFile, readFile } from "../utils/fs.js";
+import { parseFrontmatter } from "./shared.js";
+
+export const toolName = "windsurf";
+export const displayName = "Windsurf";
+
+const GLOBAL_RULES = () => join(homeDir(), ".windsurf", "global_rules.md");
+
+function projectBase() {
+  return join(cwdDir(), ".windsurf", "rules");
+}
+
+export function getInstallPath(skillPath, scope) {
+  const skillName = basename(skillPath);
+  if (scope === "personal") {
+    return GLOBAL_RULES();
+  }
+  return join(projectBase(), `${skillName}.md`);
+}
+
+export async function install(skillPath, skillContent, scope) {
+  const skillName = basename(skillPath);
+
+  if (scope === "personal") {
+    const dest = GLOBAL_RULES();
+    const existing = (await readFile(dest)) || "";
+    const header = `\n## ${skillName}\n`;
+    // Replace existing section or append
+    const sectionRegex = new RegExp(
+      `\\n## ${skillName}\\n[\\s\\S]*?(?=\\n## |$)`
+    );
+    let updated;
+    if (sectionRegex.test(existing)) {
+      updated = existing.replace(sectionRegex, `${header}${skillContent}\n`);
+    } else {
+      updated = existing + `${header}${skillContent}\n`;
+    }
+    await writeFile(dest, updated);
+    return dest;
+  }
+
+  const dest = join(projectBase(), `${skillName}.md`);
+  await writeFile(dest, skillContent);
+  return dest;
+}
+
+export async function getInstalledSkills(scope) {
+  if (scope === "personal") {
+    const content = await readFile(GLOBAL_RULES());
+    if (!content) return [];
+    const sections = content.split(/\n## /).filter(Boolean);
+    return sections.map((section) => {
+      const lines = section.split("\n");
+      const name = lines[0].trim();
+      const body = lines.slice(1).join("\n");
+      const { meta } = parseFrontmatter(body);
+      return { path: name, version: meta.version || "unknown" };
+    });
+  }
+
+  // project scope
+  const { readdir } = await import("node:fs/promises");
+  const dir = projectBase();
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const file of files) {
+    const content = await readFile(join(dir, file));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    skills.push({
+      path: file.replace(/\.md$/, ""),
+      version: meta.version || "unknown",
+    });
+  }
+  return skills;
+}

package/src/commands/detect.js

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { readFile } from "../utils/fs.js";
+import { getAllSkills } from "../manifest.js";
+import { install } from "./install.js";
+
+const PROJECT_FILES = [
+  { file: "package.json", tags: ["node", "javascript", "typescript"] },
+  { file: "build.gradle", tags: ["kotlin", "jvm", "gradle", "android"] },
+  { file: "build.gradle.kts", tags: ["kotlin", "jvm", "gradle", "android"] },
+  { file: "pom.xml", tags: ["java", "jvm", "maven"] },
+  { file: "composer.json", tags: ["php"] },
+  { file: "requirements.txt", tags: ["python"] },
+  { file: "pyproject.toml", tags: ["python"] },
+  { file: "Cargo.toml", tags: ["rust"] },
+  { file: "go.mod", tags: ["go", "golang"] },
+];
+
+async function detectProjectTags() {
+  const tags = new Set();
+  for (const { file, tags: fileTags } of PROJECT_FILES) {
+    const content = await readFile(file);
+    if (content) {
+      for (const tag of fileTags) tags.add(tag);
+    }
+  }
+  return tags;
+}
+
+async function detectRemoteOrigin() {
+  const gitConfig = await readFile(".git/config");
+  if (!gitConfig) return null;
+  const match = gitConfig.match(/\[remote "origin"\]\s*\n\s*url\s*=\s*(.+)/);
+  if (!match) return null;
+  return match[1].trim();
+}
+
+export async function detect() {
+  const spinner = ora("Analizando proyecto...").start();
+
+  const [tags, remote, skills] = await Promise.all([
+    detectProjectTags(),
+    detectRemoteOrigin(),
+    getAllSkills().catch(() => []),
+  ]);
+
+  spinner.succeed("Análisis completo.");
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow("No se pudo cargar el catálogo de skills."));
+    return;
+  }
+
+  const recommendations = [];
+
+  // Always suggest internal/global if available
+  const globalSkill = skills.find((s) => s.path === "internal/global");
+  if (globalSkill) {
+    recommendations.push({
+      skill: globalSkill,
+      reason: "Skill base recomendada para todos los proyectos.",
+    });
+  }
+
+  // Match by project tags against user/development skills
+  if (tags.size > 0) {
+    const devSkills = skills.filter((s) => s.path.startsWith("user/"));
+    for (const skill of devSkills) {
+      const skillName = skill.path.toLowerCase();
+      for (const tag of tags) {
+        if (skillName.includes(tag)) {
+          recommendations.push({
+            skill,
+            reason: `Detectado: ${[...tags].join(", ")} en el proyecto.`,
+          });
+          break;
+        }
+      }
+    }
+  }
+
+  // Match by git remote against external/client or external/project skills
+  if (remote) {
+    const remoteNorm = remote.toLowerCase();
+    const clientSkills = skills.filter(
+      (s) =>
+        s.path.startsWith("external/client/") ||
+        s.path.startsWith("external/project/")
+    );
+    for (const skill of clientSkills) {
+      const name = skill.path.split("/").pop().toLowerCase();
+      if (remoteNorm.includes(name)) {
+        recommendations.push({
+          skill,
+          reason: `El remote origin coincide con "${name}".`,
+        });
+      }
+    }
+  }
+
+  if (recommendations.length === 0) {
+    console.log(chalk.yellow("\nNo se encontraron skills recomendadas para este proyecto."));
+    console.log(chalk.dim("Usa 'skill-manager list' para ver el catálogo completo."));
+    return;
+  }
+
+  // Show recommendations
+  console.log();
+  console.log(chalk.blue.bold("  Skills recomendadas:"));
+  console.log();
+  for (const rec of recommendations) {
+    console.log(`  ${chalk.white(rec.skill.path)} ${chalk.gray(`v${rec.skill.version}`)}`);
+    console.log(chalk.dim(`    → ${rec.reason}`));
+  }
+  console.log();
+
+  const { proceed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "proceed",
+      message: "¿Instalar las skills recomendadas?",
+      default: true,
+    },
+  ]);
+
+  if (!proceed) {
+    console.log(chalk.yellow("Operación cancelada."));
+    return;
+  }
+
+  for (const rec of recommendations) {
+    await install(rec.skill.path);
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,130 @@
+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";
+
+export async function init() {
+  const existing = await loadConfig();
+  if (existing) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Ya existe una configuración. ¿Deseas sobrescribirla?",
+        default: false,
+      },
+    ]);
+    if (!overwrite) {
+      console.log(chalk.yellow("Operación cancelada."));
+      return;
+    }
+  }
+
+  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",
+    },
+    {
+      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 },
+      ],
+    },
+  ]);
+
+  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,
+  };
+
+  // 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);
+  console.log(chalk.green("✔ Configuración guardada correctamente."));
+  console.log(chalk.dim(`  → ${getConfigPath()}`));
+}

package/src/commands/install.js

@@ -0,0 +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 { 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;
+  try {
+    chain = await resolveChain(skillPath);
+    spinner.succeed(`Cadena resuelta: ${chain.length} skill(s).`);
+  } catch (err) {
+    spinner.fail("Error resolviendo dependencias.");
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  // 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();
+
+  // Determine target tools
+  let toolNames = [];
+  if (options.tool) {
+    toolNames = options.tool.split(",").map((t) => t.trim());
+  } 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 (commitear al repo)", value: "project" },
+        ],
+      },
+    ]);
+    scope = chosen;
+  }
+  // Normalize "global" to "personal"
+  if (scope === "global") scope = "personal";
+
+  // Install each skill in each tool
+  const adapters = toolNames.map((name) => getAdapter(name));
+  let installed = 0;
+
+  for (const skill of chain) {
+    const installSpinner = ora(`Instalando ${skill.path}...`).start();
+    try {
+      const skillFile = `${skill.path}/SKILL.md`;
+      const content = await fetchFileContent(skillFile);
+
+      for (const adapter of adapters) {
+        await adapter.install(skill.path, content, scope);
+      }
+      installed++;
+      installSpinner.succeed(`Instalada ${skill.path}`);
+    } catch (err) {
+      installSpinner.fail(`Error instalando ${skill.path}`);
+      console.error(chalk.red(`  ${err.message}`));
+    }
+  }
+
+  // Summary
+  console.log();
+  const toolList = adapters.map((a) => a.displayName).join(" y ");
+  console.log(
+    chalk.green(`✔ ${installed} skill(s) instalada(s) en ${toolList} (${scope})`)
+  );
+}