@ariasbruno/skillbase 0.1.1 → 1.1.0

package/src/core.js

@@ -5,9 +5,38 @@ import * as readline from 'node:readline';
 import { stdin as input, stdout as output } from 'node:process';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { getGlobalSkillsDir, getProjectRoot, getProjectSkillsDir, PROJECT_AGENTS_DIR, PROJECT_SKILLS_DIR } from './config.js';
+import { 
+  getGlobalSkillsDir, 
+  getProjectRoot, 
+  getProjectSkillsDir, 
+  PROJECT_AGENTS_DIR, 
+  PROJECT_SKILLS_DIR,
+  exists 
+} from './config.js';
 import { readManifest, removeSkillFromManifest, upsertSkill, writeJson, writeManifest } from './manifest.js';
 import { detectProjectTechnologies } from './recommendations.js';
+import { t } from './i18n.js';
+import {
+  bold,
+  dim,
+  dim2,
+  text,
+  cyan,
+  green,
+  yellow,
+  S_DIAMOND,
+  S_POINTER,
+  S_STEP,
+  S_SQUARE,
+  S_SQUARE_FILL,
+  S_BAR,
+  S_BAR_START,
+  S_BAR_END,
+  H_HIDE_CURSOR,
+  H_SHOW_CURSOR,
+  H_CLEAR_DOWN,
+  H_MOVE_UP
+} from './styles.js';
 const execFileAsync = promisify(execFile);
 
 function nowISO() {
@@ -20,13 +49,13 @@ export async function ensureDir(dir) {
   await fs.mkdir(dir, { recursive: true });
 }
 
-async function exists(target) {
-  try {
-    await fs.access(target);
-    return true;
-  } catch {
-    return false;
-  }
+function sanitizeSkillName(name) {
+  if (typeof name !== 'string') return '';
+  
+  return name
+    .replace(/[\\/]/g, '_')   
+    .replace(/\.\./g, '')     
+    .replace(/^[.~/]+/, '');  
 }
 
 export async function listGlobalSkills() {
@@ -36,6 +65,13 @@ export async function listGlobalSkills() {
   return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
 }
 
+export async function listProjectSkills(cwd = process.cwd()) {
+  const projectSkillsDir = getProjectSkillsDir(cwd);
+  if (!(await exists(projectSkillsDir))) return [];
+  const entries = await fs.readdir(projectSkillsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+
 async function copyDir(src, dst) {
   await fs.cp(src, dst, { recursive: true, force: true });
 }
@@ -61,14 +97,15 @@ function compareVersion(a, b) {
 }
 
 export async function addSkill(skillName, { sym = false, cwd = process.cwd() } = {}) {
-  const globalPath = path.join(getGlobalSkillsDir(), skillName);
+  const safeName = sanitizeSkillName(skillName);
+  const globalPath = path.join(getGlobalSkillsDir(), safeName);
   if (!(await exists(globalPath))) {
-    throw new Error(`La skill global "${skillName}" no existe en ${getGlobalSkillsDir()}`);
+    throw new Error(t('ERR_GLOBAL_NOT_FOUND', { name: skillName, dir: getGlobalSkillsDir() }));
   }
 
   const projectSkillsDir = getProjectSkillsDir(cwd);
   await ensureDir(projectSkillsDir);
-  const target = path.join(projectSkillsDir, skillName);
+  const target = path.join(projectSkillsDir, safeName);
 
   if (await exists(target)) {
     await fs.rm(target, { recursive: true, force: true });
@@ -93,21 +130,21 @@ export async function addSkillsInteractive({ cwd = process.cwd(), sym = false }
   const skills = await listGlobalSkills();
   if (!skills.length) return { selected: [], cancelled: false };
   const selection = await selectSkillsFromList(skills, {
-    title: 'Selecciona skills para instalar',
-    requireTTYMessage: 'La selección interactiva requiere una terminal TTY. Usa: skillbase add <skill>.'
+    title: t('UI_SELECT_MULTIPLE'),
+    requireTTYMessage: t('UI_REQUIRED_TTY')
   });
   if (selection.cancelled) return { selected: [], cancelled: true };
   const selectedSkills = selection.selected;
   for (const skill of selectedSkills) {
     await addSkill(skill, { cwd, sym });
   }
-  output.write(`\nInstaladas: ${selectedSkills.join(', ') || 'ninguna'}\n`);
+  output.write(`\n${t('INIT_INSTALLED', { list: selectedSkills.join(', ') || t('INIT_NONE') })}\n`);
   return { selected: selectedSkills, cancelled: false };
 }
 
-async function selectSkillsFromList(skills, { title, requireTTYMessage } = {}) {
+async function selectSkillsFromList(skills, { title, subtitle, requireTTYMessage } = {}) {
   if (!input.isTTY || !output.isTTY) {
-    throw new Error(requireTTYMessage || 'La selección interactiva requiere una terminal TTY.');
+    throw new Error(requireTTYMessage || t('UI_REQUIRED_TTY'));
   }
 
   const selected = new Set();
@@ -116,93 +153,96 @@ async function selectSkillsFromList(skills, { title, requireTTYMessage } = {}) {
   let renderedLines = 0;
   let firstRender = true;
 
-  // Tamaño de página adaptativo (mínimo 5, máximo 15 por defecto)
   const getPageSize = () => {
     const terminalRows = output.rows || 24;
-    const reservedRows = 8; // Header (5) + Footer (2) + Margen (1)
-    return Math.max(5, Math.min(15, terminalRows - reservedRows));
+    const reservedRows = 10;
+    return Math.max(5, Math.min(12, terminalRows - reservedRows));
   };
 
   readline.emitKeypressEvents(input);
   input.resume();
   if (typeof input.setRawMode === 'function') input.setRawMode(true);
 
+  output.write(H_HIDE_CURSOR);
+
   const render = () => {
     const pageSize = getPageSize();
-    
-    // Ajustar ventana (offset) según el cursor
-    if (cursor < offset) {
-      offset = cursor;
-    } else if (cursor >= offset + pageSize) {
-      offset = cursor - pageSize + 1;
-    }
+
+    if (cursor < offset) offset = cursor;
+    else if (cursor >= offset + pageSize) offset = cursor - pageSize + 1;
 
     const lines = [
-      '\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m',
-      `\x1b[1m${title || 'Selecciona skills'}\x1b[0m`,
-      '\x1b[2m↑/↓ navegar · espacio seleccionar · enter confirmar · esc cancelar\x1b[0m',
-      '\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m',
-      ''
+      `${cyan(S_BAR_START)}  ${bold(title || t('UI_SELECT_MULTIPLE'))}`,
+      `${cyan(S_BAR)}  ${dim2(subtitle || t('UI_AVAILABLE', { count: skills.length }))}`,
+      `${cyan(S_BAR)}`
     ];
 
-    // Indicador superior si hay más arriba
-    if (offset > 0) {
-      lines.push('\x1b[2m  ▲  y más...\x1b[0m');
-    } else {
-      lines.push('');
-    }
-
     const visibleSkills = skills.slice(offset, offset + pageSize);
     visibleSkills.forEach((skill, index) => {
       const realIndex = index + offset;
       const isSelected = selected.has(skill);
       const isCursor = realIndex === cursor;
-      const mark = isSelected ? '[x]' : '[ ]';
-      const pointer = isCursor ? '\x1b[32m❯\x1b[0m' : ' ';
-      const line = `${mark} ${skill}`;
-      lines.push(isCursor ? `${pointer} \x1b[1m${line}\x1b[0m` : `${pointer} ${line}`);
+
+      const check = isSelected
+        ? cyan(S_SQUARE_FILL)
+        : dim2(S_SQUARE);
+
+      const pointer = isCursor
+        ? cyan(S_POINTER)
+        : ' ';
+
+      // Formatear nombre: owner › name (si tiene /)
+      let label = skill;
+      if (skill.includes('/')) {
+        const [owner, ...nameParts] = skill.split('/');
+        const name = nameParts.join('/');
+        const ownerPart = isCursor ? bold(owner) : dim2(owner);
+        const namePart = isSelected ? cyan(name) : (isCursor ? bold(name) : text(name));
+        label = `${ownerPart} ${dim2(S_STEP)} ${namePart}`;
+      } else {
+        label = isCursor ? bold(skill) : (isSelected ? cyan(skill) : text(skill));
+      }
+
+      lines.push(`${cyan(S_BAR)}  ${pointer} ${check} ${label}`);
     });
 
-    // Rellenar hasta pageSize para mantener altura constante (evita parpadeos)
     for (let i = visibleSkills.length; i < pageSize; i += 1) {
-      lines.push('');
+      lines.push(`${cyan(S_BAR)}`);
     }
 
-    // Indicador inferior si hay más abajo
-    if (offset + pageSize < skills.length) {
-      lines.push('\x1b[2m  ▼  y más...\x1b[0m');
-    } else {
-      lines.push('');
-    }
+    lines.push(`${cyan(S_BAR)}`);
+    const status = `(${selected.size}/${skills.length})`;
+    const page = t('UI_PAGE', { current: Math.floor(offset / pageSize) + 1, total: Math.ceil(skills.length / pageSize) });
+    const controls = t('UI_CONTROLS', { status });
+    lines.push(`${cyan(S_BAR_END)}  ${dim2(`${page} · ${controls}`)}`);
 
+    const outputContent = lines.join('\n');
     if (!firstRender) {
-      readline.moveCursor(output, 0, -renderedLines);
-    }
-
-    for (let i = 0; i < lines.length; i += 1) {
-      readline.clearLine(output, 0);
-      readline.cursorTo(output, 0);
-      output.write(lines[i]);
-      if (i < lines.length - 1) output.write('\n');
+      output.write('\r' + H_MOVE_UP(renderedLines));
     }
+    output.write(H_CLEAR_DOWN + outputContent);
 
-    // Limpiar líneas residuales si el tamaño de renderizado cambió (vía redimensionado de terminal)
-    if (!firstRender && renderedLines > lines.length) {
-      for (let i = lines.length; i < renderedLines; i += 1) {
-        output.write('\n');
-        readline.clearLine(output, 0);
-      }
-    }
-
-    output.write('\n');
-    renderedLines = lines.length + 1;
+    renderedLines = lines.length - 1;
     firstRender = false;
   };
 
   render();
+  const cleanup = () => {
+    output.write('\n' + H_SHOW_CURSOR);
+    if (typeof input.setRawMode === 'function') input.setRawMode(false);
+    input.pause();
+    input.removeListener('keypress', onKeypress);
+  };
+
   let onKeypress;
   const outcome = await new Promise((resolve) => {
     onKeypress = (_, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        resolve({ cancelled: true });
+        return;
+      }
       if (key.name === 'up') {
         cursor = (cursor - 1 + skills.length) % skills.length;
         render();
@@ -220,24 +260,29 @@ async function selectSkillsFromList(skills, { title, requireTTYMessage } = {}) {
         render();
         return;
       }
+      if (key.name === 'a') {
+        if (selected.size === skills.length) {
+          selected.clear();
+        } else {
+          skills.forEach((s) => selected.add(s));
+        }
+        render();
+        return;
+      }
       if (key.name === 'return' || key.name === 'enter') {
+        cleanup();
         resolve({ cancelled: false });
         return;
       }
-      if (key.name === 'escape' || (key.name === 'c' && key.ctrl)) {
+      if (key.name === 'escape') {
+        cleanup();
         resolve({ cancelled: true });
       }
     };
     input.on('keypress', onKeypress);
   });
 
-  if (onKeypress) input.off('keypress', onKeypress);
-  if (typeof input.setRawMode === 'function') input.setRawMode(false);
-  input.pause();
-  output.write('\n');
-
   if (outcome.cancelled) {
-    output.write('\nSelección cancelada.\n');
     return { selected: [], cancelled: true };
   }
 
@@ -279,7 +324,7 @@ function parseRemoteSkillRef(skillRef) {
 async function fetchRemoteMetadata(skillRef) {
   const parsed = parseRemoteSkillRef(skillRef);
   if (!parsed.lookupKeys.length) {
-    throw new Error('Debes indicar una skill remota válida.');
+    throw new Error(t('ERR_REMOTE_INVALID'));
   }
 
   for (const key of parsed.lookupKeys) {
@@ -302,7 +347,7 @@ async function fetchRemoteMetadata(skillRef) {
   }
 
   throw new Error(
-    `No se pudo obtener metadata remota para "${skillRef}". Usa slug tipo "owner/skill" o URL de skills.sh.`
+    t('ERR_REMOTE_METADATA', { ref: skillRef })
   );
 }
 
@@ -313,12 +358,12 @@ async function downloadSkillFromRemote(skillRef, tmpDir) {
   const sourceUrl = metadata.downloadUrl || metadata.sourceUrl || metadata.repo || metadata.url;
 
   if (!sourceUrl) {
-    throw new Error(`La metadata remota de "${skillRef}" no contiene downloadUrl/sourceUrl/repo/url`);
+    throw new Error(t('ERR_REMOTE_NO_URL', { ref: skillRef }));
   }
 
   if (metadata.archiveUrl) {
     const archiveResponse = await fetch(metadata.archiveUrl);
-    if (!archiveResponse.ok) throw new Error(`No se pudo descargar archiveUrl (${archiveResponse.status})`);
+    if (!archiveResponse.ok) throw new Error(t('ERR_REMOTE_DOWNLOAD', { status: archiveResponse.status }));
     const archivePath = path.join(tmpDir, `${localName}.tgz`);
     const buffer = Buffer.from(await archiveResponse.arrayBuffer());
     await fs.writeFile(archivePath, buffer);
@@ -341,7 +386,7 @@ export async function installRemoteSkill(skillName, { cwd = process.cwd(), force
   await ensureDir(projectSkillsDir);
 
   if (/^https?:\/\/github\.com\//i.test(skillName)) {
-    throw new Error('Para instalar desde GitHub usa: skillbase install <repo-url> --remote --skill <nombre-skill>.');
+    throw new Error(t('ERR_GITHUB_USAGE'));
   }
 
   const tempBase = await fs.mkdtemp(path.join(os.tmpdir(), 'skillbase-'));
@@ -349,7 +394,7 @@ export async function installRemoteSkill(skillName, { cwd = process.cwd(), force
     const downloaded = await downloadSkillFromRemote(skillName, tempBase);
     const target = path.join(projectSkillsDir, downloaded.localName);
     if ((await exists(target)) && !force) {
-      throw new Error(`La skill "${downloaded.localName}" ya existe en el proyecto. Usa --force para reinstalar.`);
+      throw new Error(t('ERR_SKILL_EXISTS', { name: downloaded.localName }));
     }
     if (await exists(target)) await fs.rm(target, { recursive: true, force: true });
     await copyDir(downloaded.path, target);
@@ -372,7 +417,7 @@ export async function installRemoteSkill(skillName, { cwd = process.cwd(), force
 
 async function installRemoteFromGitHub(repoUrl, selectedSkill, { cwd = process.cwd(), force = false } = {}) {
   if (!selectedSkill) {
-    throw new Error('Falta --skill <nombre>. Ejemplo: skillbase install <repo-url> --remote --skill find-skills');
+    throw new Error(t('ERR_SKILL_REQUIRED'));
   }
 
   const projectSkillsDir = getProjectSkillsDir(cwd);
@@ -391,12 +436,12 @@ async function installRemoteFromGitHub(repoUrl, selectedSkill, { cwd = process.c
       }
     }
     if (!sourcePath) {
-      throw new Error(`No se encontró la skill "${selectedSkill}" en el repo remoto.`);
+      throw new Error(t('ERR_SKILL_NOT_FOUND_REMOTE', { name: selectedSkill }));
     }
 
     const target = path.join(projectSkillsDir, selectedSkill);
     if ((await exists(target)) && !force) {
-      throw new Error(`La skill "${selectedSkill}" ya existe en el proyecto. Usa --force para reinstalar.`);
+      throw new Error(t('ERR_SKILL_EXISTS', { name: selectedSkill }));
     }
     if (await exists(target)) await fs.rm(target, { recursive: true, force: true });
     await copyDir(sourcePath, target);
@@ -427,7 +472,7 @@ export async function installRemoteSkillRef(skillRef, options = {}) {
 export async function installFromManifest({ cwd = process.cwd(), remote = false, force = false } = {}) {
   const manifest = await readManifest(cwd);
   if (!manifest.skills.length) {
-    throw new Error('No hay skills en skillbase.json. Usa "skillbase add <skill>" o "skillbase install <skill> --remote".');
+    throw new Error(t('ERR_MANIFEST_EMPTY'));
   }
   for (const skill of manifest.skills) {
     if (remote || skill.source === 'remote') await installRemoteSkill(skill.name, { cwd, force });
@@ -436,12 +481,13 @@ export async function installFromManifest({ cwd = process.cwd(), remote = false,
 }
 
 export async function removeSkill(skillName, { cwd = process.cwd(), global = false } = {}) {
+  const safeName = sanitizeSkillName(skillName);
   if (global) {
-    await fs.rm(path.join(getGlobalSkillsDir(), skillName), { recursive: true, force: true });
+    await fs.rm(path.join(getGlobalSkillsDir(), safeName), { recursive: true, force: true });
     return;
   }
 
-  await fs.rm(path.join(getProjectSkillsDir(cwd), skillName), { recursive: true, force: true });
+  await fs.rm(path.join(getProjectSkillsDir(cwd), safeName), { recursive: true, force: true });
   const manifest = await readManifest(cwd);
   removeSkillFromManifest(manifest, skillName);
   await writeManifest(manifest, cwd);
@@ -536,8 +582,8 @@ export async function initProject({ cwd = process.cwd(), hard = false } = {}) {
 
   const selection = await selectSkillsFromList(suggested, {
     title: hard
-      ? 'Init --hard: selecciona skills recomendadas por nombre y tags'
-      : 'Init: selecciona skills recomendadas por nombre'
+      ? t('INIT_HARD_TITLE')
+      : t('INIT_TITLE')
   });
   if (selection.cancelled) return { technologies, suggested, installed: [], cancelled: true };
 

package/src/i18n.js

@@ -0,0 +1,34 @@
+import { getConfig } from './config.js';
+import { en } from './locales/en.js';
+import { es } from './locales/es.js';
+
+const locales = { en, es };
+
+let currentLang = getConfig().lang || 'en';
+
+/**
+ * Cambia el idioma actual en memoria
+ * @param {string} lang 'en' | 'es'
+ */
+export function setLanguage(lang) {
+  if (locales[lang]) {
+    currentLang = lang;
+  }
+}
+
+/**
+ * Traduce una clave al idioma actual
+ * @param {string} key Clave del diccionario
+ * @param {Object} params Parámetros para reemplazar en la cadena ({key: value})
+ * @returns {string} Texto traducido
+ */
+export function t(key, params = {}) {
+  const dict = locales[currentLang] || locales.en;
+  let textStr = dict[key] || locales.en[key] || key;
+
+  for (const [k, v] of Object.entries(params)) {
+    textStr = textStr.replace(new RegExp(`{${k}}`, 'g'), v);
+  }
+
+  return textStr;
+}

package/src/locales/en.js

@@ -0,0 +1,104 @@
+export const en = {
+  // General
+  USAGE: 'Usage:',
+  COMMANDS: 'Commands:',
+  OPTIONS: 'Common Options:',
+  SHORTCUTS: 'Shortcuts: l=ls, h=-h, a=add, i=install, rm=remove, c=check, up=update, m=migrate',
+  HELP_FOOTER: 'Use {cmd} to see all options and commands.',
+  USE_HELP: 'Use {cmd} to see all options and commands.',
+  CANCELLED: 'Operation cancelled.',
+  COMMANDS_AVAILABLE: 'Available commands:',
+  SELECTION_CANCELLED: 'Selection cancelled.',
+  UNKNOWN_COMMAND: 'Unknown command: {cmd}. Use skillbase -h',
+
+  // Commands info
+  DESC_INIT: 'Initialize project and detect stack [--hard]',
+  DESC_INIT_SHORT: 'Configure project and detect stack',
+  DESC_ADD: 'Add one or more skills to the project',
+  DESC_ADD_SHORT: 'Add new skill (global/project)',
+  DESC_LS: 'List installed skills (local or global with -g)',
+  DESC_LS_SHORT: 'List installed skills',
+  DESC_INSTALL: 'Install from manifest or remote [-r] [-k <name>]',
+  DESC_INSTALL_SHORT: 'Install dependencies from manifest',
+  DESC_REMOVE: 'Remove a skill from project or global [-g]',
+  DESC_CHECK: 'Check for updates for installed skills',
+  DESC_UPDATE: 'Update one or all skills',
+  DESC_MIGRATE: 'Migrate (~/.agents) or promote (-p) local skills to global',
+  DESC_MIGRATE_SHORT: 'Migrate or promote local skills',
+  DESC_LANG: 'Change tool language (en|es)',
+  DESC_LANG_SHORT: 'Change CLI language',
+
+  // Options info
+  OPT_REMOTE: 'Operate with remote repositories (GitHub/GitLab)',
+  OPT_FORCE: 'Force operation (overwrite files)',
+  OPT_SYM: 'Create symbolic links instead of copying (add only)',
+  OPT_GLOBAL: 'Operate globally (for ls and remove)',
+  OPT_HELP: 'Show this help',
+
+  // Command-specific messages
+  LS_GLOBAL_EMPTY: 'No global skills installed in {dir}',
+  LS_GLOBAL_TITLE: 'Global skills ({dir}):',
+  LS_PROJECT_EMPTY: 'No local skills installed in {dir}',
+  LS_PROJECT_TITLE: 'Project skills ({dir}):',
+
+  INIT_NO_STACK: 'No stack detected in the project.',
+  INIT_ANALYSIS: 'Stack analysis:',
+  INIT_RESUMEN: 'Summary:',
+  INIT_INSTALLED: 'Installed: {list}',
+  INIT_NONE: 'No skills were installed.',
+
+  ADD_NO_SELECTED: 'No skills selected to install.',
+  ADD_RESUMEN: 'Summary:',
+  ADD_SUCCESS: 'Skill "{skill}" installed.',
+  ADD_REMOTE_SUCCESS: 'Remote skill "{skill}" installed.',
+
+  REMOVE_GLOBAL_SUCCESS: 'Global skill "{skill}" removed.',
+  REMOVE_PROJECT_SUCCESS: 'Project skill "{skill}" removed.',
+  REMOVE_NOT_FOUND: 'Skill "{skill}" is not installed.',
+
+  CHECK_SEARCHING: 'Checking for updates...',
+  CHECK_UP_TO_DATE: 'All skills are up to date.',
+  CHECK_UPDATES_FOUND: 'Updates available:',
+  CHECK_UPDATE_HINT: 'Use {cmd} to update.',
+
+  UPDATE_START: 'Updating skills...',
+  UPDATE_SUCCESS: 'All skills updated.',
+  UPDATE_SINGLE_SUCCESS: 'Skill "{skill}" updated.',
+
+  MIGRATE_TITLE: 'Skills Migration',
+  MIGRATE_SOURCE: 'Source: {dir}',
+  MIGRATE_FOUND: 'Skills found: {count}',
+  MIGRATE_SUCCESS_LIST: 'Skills migrated to {dir}:',
+  MIGRATE_SKIPPED_LIST: 'Skipped (already exist):',
+  MIGRATE_RESUMEN_TITLE: 'Summary:',
+  MIGRATE_RESUMEN_SUCCESS: '{count} skills migrated successfully.',
+  MIGRATE_RESUMEN_DEST: 'Destination: {dir}',
+  MIGRATE_NONE: 'No new skills were migrated.',
+
+  LANG_SUCCESS: 'Language changed to {lang} successfully.',
+  LANG_INVALID: 'Unsupported language: {lang}. Use "en" or "es".',
+
+  // Interactive UI
+  UI_SELECT_ONE: 'Select a skill',
+  UI_SELECT_MULTIPLE: 'Select skills',
+  UI_CONTROLS: '↑↓ navigate • [space] sel. {status} • [a] all • [enter] install • [esc] exit',
+  UI_SELECTED: 'selected',
+  UI_PAGE: 'page {current}/{total}',
+  UI_AVAILABLE: '{count} skills available',
+  UI_REQUIRED_TTY: 'Interactive selection requires a TTY terminal. Use: skillbase add <skill>.',
+
+  // Core / Errors
+  ERR_GLOBAL_NOT_FOUND: 'Global skill "{name}" does not exist in {dir}',
+  ERR_REMOTE_INVALID: 'You must specify a valid remote skill.',
+  ERR_REMOTE_METADATA: 'Could not fetch remote metadata for "{ref}". Use slug like "owner/skill" or skills.sh URL.',
+  ERR_REMOTE_NO_URL: 'Remote metadata for "{ref}" does not contain downloadUrl/sourceUrl/repo/url',
+  ERR_REMOTE_DOWNLOAD: 'Could not download archiveUrl ({status})',
+  ERR_GITHUB_USAGE: 'To install from GitHub use: skillbase install <repo-url> --remote --skill <skill-name>.',
+  ERR_SKILL_EXISTS: 'Skill "{name}" already exists in the project. Use --force to reinstall.',
+  ERR_SKILL_REQUIRED: 'Missing --skill <name>. Example: skillbase install <repo-url> --remote --skill find-skills',
+  ERR_SKILL_NOT_FOUND_REMOTE: 'Skill "{name}" not found in remote repo.',
+  ERR_MANIFEST_EMPTY: 'No skills in skillbase.json. Use "skillbase add <skill>" or "skillbase install <skill> --remote".',
+  
+  INIT_HARD_TITLE: 'Init --hard: select skills recommended by name and tags',
+  INIT_TITLE: 'Init: select skills recommended by name',
+};

package/src/locales/es.js

@@ -0,0 +1,104 @@
+export const es = {
+  // General
+  USAGE: 'Uso:',
+  COMMANDS: 'Comandos:',
+  OPTIONS: 'Opciones comunes:',
+  SHORTCUTS: 'Atajos: l=ls, h=-h, a=add, i=install, rm=remove, c=check, up=update, m=migrate',
+  HELP_FOOTER: 'Usa {cmd} para ver todas las opciones y comandos.',
+  USE_HELP: 'Usa {cmd} para ver todas las opciones y comandos.',
+  CANCELLED: 'Operación cancelada.',
+  COMMANDS_AVAILABLE: 'Comandos disponibles:',
+  SELECTION_CANCELLED: 'Selección cancelada.',
+  UNKNOWN_COMMAND: 'Comando desconocido: {cmd}. Usa skillbase -h',
+
+  // Commands info
+  DESC_INIT: 'Inicializa el proyecto y detecta el stack [--hard]',
+  DESC_INIT_SHORT: 'Configura proyecto y detecta stack',
+  DESC_ADD: 'Añade una o varias skills al proyecto',
+  DESC_ADD_SHORT: 'Añadir nueva skill (global/proyecto)',
+  DESC_LS: 'Lista las skills instaladas (local o global con -g)',
+  DESC_LS_SHORT: 'Listar skills instaladas',
+  DESC_INSTALL: 'Instala desde el manifiesto o remoto [-r] [-k <nombre>]',
+  DESC_INSTALL_SHORT: 'Instalar dependencias del manifiesto',
+  DESC_REMOVE: 'Elimina una skill del proyecto o global [-g]',
+  DESC_CHECK: 'Busca actualizaciones de las skills instaladas',
+  DESC_UPDATE: 'Actualiza una o todas las skills',
+  DESC_MIGRATE: 'Migra (~/.agents) o promueve (-p) skills locales a global',
+  DESC_MIGRATE_SHORT: 'Migrar o promover skills locales',
+  DESC_LANG: 'Cambia el idioma de la herramienta (en|es)',
+  DESC_LANG_SHORT: 'Cambiar idioma de la CLI',
+
+  // Options info
+  OPT_REMOTE: 'Operar con repositorios remotos (GitHub/GitLab)',
+  OPT_FORCE: 'Forzar la operación (sobrescribir archivos)',
+  OPT_SYM: 'Crear enlaces simbólicos en vez de copiar (solo add)',
+  OPT_GLOBAL: 'Operar de forma global (para ls y remove)',
+  OPT_HELP: 'Mostrar esta ayuda',
+
+  // Command-specific messages
+  LS_GLOBAL_EMPTY: 'No hay skills globales instaladas en {dir}',
+  LS_GLOBAL_TITLE: 'Skills globales ({dir}):',
+  LS_PROJECT_EMPTY: 'No hay skills instaladas localmente en {dir}',
+  LS_PROJECT_TITLE: 'Skills del proyecto ({dir}):',
+
+  INIT_NO_STACK: 'No se detectó stack en el proyecto.',
+  INIT_ANALYSIS: 'Análisis de stack:',
+  INIT_RESUMEN: 'Resumen:',
+  INIT_INSTALLED: 'Instaladas: {list}',
+  INIT_NONE: 'No se instaló ninguna skill.',
+
+  ADD_NO_SELECTED: 'No se seleccionaron skills para instalar.',
+  ADD_RESUMEN: 'Resumen:',
+  ADD_SUCCESS: 'Skill "{skill}" instalada.',
+  ADD_REMOTE_SUCCESS: 'Skill remota "{skill}" instalada.',
+
+  REMOVE_GLOBAL_SUCCESS: 'Skill global "{skill}" eliminada.',
+  REMOVE_PROJECT_SUCCESS: 'Skill del proyecto "{skill}" eliminada.',
+  REMOVE_NOT_FOUND: 'La skill "{skill}" no está instalada.',
+
+  CHECK_SEARCHING: 'Buscando actualizaciones...',
+  CHECK_UP_TO_DATE: 'Todas las skills están al día.',
+  CHECK_UPDATES_FOUND: 'Hay actualizaciones disponibles:',
+  CHECK_UPDATE_HINT: 'Usa {cmd} para actualizar.',
+
+  UPDATE_START: 'Actualizando skills...',
+  UPDATE_SUCCESS: 'Todas las skills actualizadas.',
+  UPDATE_SINGLE_SUCCESS: 'Skill "{skill}" actualizada.',
+
+  MIGRATE_TITLE: 'Migración de skills',
+  MIGRATE_SOURCE: 'Origen: {dir}',
+  MIGRATE_FOUND: 'Skills encontradas: {count}',
+  MIGRATE_SUCCESS_LIST: 'Skills migradas a {dir}:',
+  MIGRATE_SKIPPED_LIST: 'Omitidas (ya existen):',
+  MIGRATE_RESUMEN_TITLE: 'Resumen:',
+  MIGRATE_RESUMEN_SUCCESS: '{count} skills migradas con éxito.',
+  MIGRATE_RESUMEN_DEST: 'Destino: {dir}',
+  MIGRATE_NONE: 'No se migraron nuevas skills.',
+
+  LANG_SUCCESS: 'Idioma cambiado a {lang} con éxito.',
+  LANG_INVALID: 'Idioma no soportado: {lang}. Usa "en" o "es".',
+
+  // Interfaz Interactiva
+  UI_SELECT_ONE: 'Seleccionar una skill',
+  UI_SELECT_MULTIPLE: 'Seleccionar skills',
+  UI_CONTROLS: '↑↓ navegar • [espacio] sel. {status} • [a] todo • [enter] instalar • [esc] salir',
+  UI_SELECTED: 'seleccionadas',
+  UI_PAGE: 'pág. {current}/{total}',
+  UI_AVAILABLE: '{count} skills disponibles',
+  UI_REQUIRED_TTY: 'La selección interactiva requiere una terminal TTY. Usa: skillbase add <skill>.',
+
+  // Core / Errores
+  ERR_GLOBAL_NOT_FOUND: 'La skill global "{name}" no existe en {dir}',
+  ERR_REMOTE_INVALID: 'Debes indicar una skill remota válida.',
+  ERR_REMOTE_METADATA: 'No se pudo obtener metadata remota para "{ref}". Usa slug tipo "owner/skill" o URL de skills.sh.',
+  ERR_REMOTE_NO_URL: 'La metadata remota de "{ref}" no contiene downloadUrl/sourceUrl/repo/url',
+  ERR_REMOTE_DOWNLOAD: 'No se pudo descargar archiveUrl ({status})',
+  ERR_GITHUB_USAGE: 'Para instalar desde GitHub usa: skillbase install <repo-url> --remote --skill <nombre-skill>.',
+  ERR_SKILL_EXISTS: 'La skill "{name}" ya existe en el proyecto. Usa --force para reinstalar.',
+  ERR_SKILL_REQUIRED: 'Falta --skill <nombre>. Ejemplo: skillbase install <repo-url> --remote --skill find-skills',
+  ERR_SKILL_NOT_FOUND_REMOTE: 'No se encontró la skill "{name}" en el repo remoto.',
+  ERR_MANIFEST_EMPTY: 'No hay skills en skillbase.json. Usa "skillbase add <skill>" o "skillbase install <skill> --remote".',
+
+  INIT_HARD_TITLE: 'Init --hard: selecciona skills recomendadas por nombre y tags',
+  INIT_TITLE: 'Init: selecciona skills recomendadas por nombre',
+};