@qubiit/lmagent 2.5.0

package/scripts/create_skill.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+
+/**
+ * LMAgent Skill Generator — v2.3.0
+ * 
+ * Genera la estructura completa de un nuevo skill interactivamente.
+ * 
+ * Uso:
+ *   node scripts/create_skill.js                    # Interactivo
+ *   node scripts/create_skill.js --name "My Skill"  # Semi-automático
+ */
+
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT = resolve(__dirname, '..');
+const SKILLS_DIR = join(ROOT, 'skills');
+
+// ─── Colores ──────────────────────────────────────────────────
+const c = {
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+
+// ─── Prompt interactivo ───────────────────────────────────────
+function createPrompt() {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return {
+        ask: (question, defaultValue = '') => {
+            return new Promise((resolve) => {
+                const suffix = defaultValue ? ` ${c.dim(`(${defaultValue})`)}` : '';
+                rl.question(`  ${c.cyan('?')} ${question}${suffix}: `, (answer) => {
+                    resolve(answer.trim() || defaultValue);
+                });
+            });
+        },
+        askList: (question, hint = 'separar con comas') => {
+            return new Promise((resolve) => {
+                rl.question(`  ${c.cyan('?')} ${question} ${c.dim(`(${hint})`)}: `, (answer) => {
+                    const items = answer.split(',').map(s => s.trim()).filter(Boolean);
+                    resolve(items);
+                });
+            });
+        },
+        askYesNo: (question, defaultValue = true) => {
+            return new Promise((resolve) => {
+                const hint = defaultValue ? 'S/n' : 's/N';
+                rl.question(`  ${c.cyan('?')} ${question} ${c.dim(`(${hint})`)}: `, (answer) => {
+                    if (!answer.trim()) return resolve(defaultValue);
+                    resolve(['s', 'si', 'sí', 'y', 'yes'].includes(answer.trim().toLowerCase()));
+                });
+            });
+        },
+        close: () => rl.close(),
+    };
+}
+
+// ─── Generar slug del nombre ──────────────────────────────────
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[áàäâ]/g, 'a')
+        .replace(/[éèëê]/g, 'e')
+        .replace(/[íìïî]/g, 'i')
+        .replace(/[óòöô]/g, 'o')
+        .replace(/[úùüû]/g, 'u')
+        .replace(/ñ/g, 'n')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+
+// ─── Generar SKILL.md ─────────────────────────────────────────
+function generateSkillMd(data) {
+    const expertise = data.expertise.map(e => `  - ${e}`).join('\n');
+    const activatesOn = data.activatesOn.map(a => `  - ${a}`).join('\n');
+    const triggers = data.triggers.map(t => `  - ${t}`).join('\n');
+
+    return `---
+name: ${data.name}
+description: ${data.description}
+role: ${data.role}
+type: ${data.type}
+version: 2.3
+icon: ${data.icon}
+expertise:
+${expertise}
+activates_on:
+${activatesOn}
+triggers:
+${triggers}
+---
+
+# ${data.name} Persona
+
+## 🧠 System Prompt
+> **Instrucciones para el LLM**: Copia este bloque en tu system prompt o contexto inicial.
+
+\`\`\`markdown
+Eres **${data.name}**, un experto en ${data.role.toLowerCase()}.
+Tu objetivo es **[DEFINIR OBJETIVO PRINCIPAL EN MAYÚSCULAS]**.
+Tu tono es **[Adjetivo 1, Adjetivo 2, Adjetivo 3]**.
+
+**Principios Core:**
+1. **[Principio 1]**: [Descripción]
+2. **[Principio 2]**: [Descripción]
+3. **[Principio 3]**: [Descripción]
+4. **[Principio 4]**: [Descripción]
+
+**Restricciones:**
+- NUNCA [restricción 1].
+- SIEMPRE [restricción 2].
+- SIEMPRE [restricción 3].
+- NUNCA [restricción 4].
+\`\`\`
+
+## 🔄 Arquitectura Cognitiva (Cómo Pensar)
+
+### 1. Fase de Análisis
+Antes de actuar, pregúntate:
+- **Input**: ¿Qué se necesita?
+- **Contexto**: ¿Qué restricciones existen?
+- **Riesgo**: ¿Qué puede salir mal?
+- **Salida**: ¿Cuál es el resultado esperado?
+
+### 2. Fase de Diseño
+- Definir **estructura** del entregable.
+- Planear **enfoque** paso a paso.
+- Identificar **dependencias** y **bloqueantes**.
+
+### 3. Fase de Ejecución
+- Implementar según el plan.
+- Verificar en cada paso.
+- Documentar decisiones.
+
+### 4. Auto-Corrección
+Antes de finalizar, verifica:
+- "¿Cumple con los criterios de aceptación?"
+- "¿Sigue los patrones del proyecto?"
+- "¿Es mantenible y documentado?"
+
+---
+
+## Rol
+
+${data.description}
+
+## Responsabilidades
+
+1. **[Responsabilidad 1]**: [Detalle]
+2. **[Responsabilidad 2]**: [Detalle]
+3. **[Responsabilidad 3]**: [Detalle]
+4. **[Responsabilidad 4]**: [Detalle]
+5. **[Responsabilidad 5]**: [Detalle]
+
+## Stack Técnico
+
+\`\`\`
+[Tecnología 1]    → [Propósito]
+[Tecnología 2]    → [Propósito]
+[Tecnología 3]    → [Propósito]
+\`\`\`
+
+## Interacción con Otros Roles
+
+| Rol | Colaboración |
+|-----|-------------|
+| [Rol 1] | [Cómo colaboran] |
+| [Rol 2] | [Cómo colaboran] |
+| [Rol 3] | [Cómo colaboran] |
+
+---
+
+## 🛠️ Herramientas Preferidas
+
+| Herramienta | Cuándo Usarla |
+|-------------|---------------|
+| \`view_file\` | [Cuándo] |
+| \`run_command\` | [Cuándo] |
+| \`grep_search\` | [Cuándo] |
+| \`write_to_file\` | [Cuándo] |
+
+## 📋 Definition of Done
+
+Antes de considerar una tarea terminada, verifica TODO:
+
+### Calidad
+- [ ] [Criterio 1]
+- [ ] [Criterio 2]
+- [ ] [Criterio 3]
+
+### Documentación
+- [ ] [Criterio de documentación 1]
+- [ ] [Criterio de documentación 2]
+
+---
+
+*Skill version: 2.3 | LMAgent Framework*
+`;
+}
+
+// ─── Main ─────────────────────────────────────────────────────
+async function main() {
+    console.log(c.bold('\n🛠️  LMAgent Skill Generator v2.3.0\n'));
+
+    const prompt = createPrompt();
+
+    try {
+        // Obtener datos del skill
+        const name = await prompt.ask('Nombre del skill', '');
+        if (!name) {
+            console.log(c.red('\n❌ El nombre es obligatorio.\n'));
+            process.exit(1);
+        }
+
+        const slug = slugify(name);
+        const skillDir = join(SKILLS_DIR, slug);
+
+        if (existsSync(skillDir)) {
+            console.log(c.red(`\n❌ Ya existe un skill en: ${skillDir}\n`));
+            process.exit(1);
+        }
+
+        const description = await prompt.ask('Descripción breve', '');
+        const role = await prompt.ask('Rol del skill', `Experto en ${name}`);
+        const icon = await prompt.ask('Icono (emoji)', '🔧');
+        const type = await prompt.ask('Tipo (agent_persona / methodology)', 'agent_persona');
+        const expertise = await prompt.askList('Áreas de expertise');
+        const activatesOn = await prompt.askList('Cuándo se activa (contextos)');
+
+        const triggerSuggestion = `/${slug.split('-')[0]}`;
+        const triggersRaw = await prompt.askList('Triggers (con /)', `ej: ${triggerSuggestion}`);
+        const triggers = triggersRaw.length > 0 ? triggersRaw : [triggerSuggestion];
+
+        const createDirs = await prompt.askYesNo('¿Crear subdirectorios (scripts/, references/, assets/)?', false);
+
+        // Confirmar
+        console.log(c.bold('\n📋 Resumen:'));
+        console.log(`   Nombre:      ${c.cyan(name)}`);
+        console.log(`   Slug:        ${c.dim(slug)}`);
+        console.log(`   Descripción: ${description}`);
+        console.log(`   Rol:         ${role}`);
+        console.log(`   Icono:       ${icon}`);
+        console.log(`   Tipo:        ${type}`);
+        console.log(`   Expertise:   ${expertise.join(', ')}`);
+        console.log(`   Activa en:   ${activatesOn.join(', ')}`);
+        console.log(`   Triggers:    ${triggers.join(', ')}`);
+        console.log(`   Extra dirs:  ${createDirs ? 'Sí' : 'No'}`);
+
+        const confirm = await prompt.askYesNo('\n¿Crear skill?', true);
+        if (!confirm) {
+            console.log(c.yellow('\n⚠️  Cancelado.\n'));
+            process.exit(0);
+        }
+
+        // Crear estructura
+        mkdirSync(skillDir, { recursive: true });
+
+        if (createDirs) {
+            mkdirSync(join(skillDir, 'scripts'), { recursive: true });
+            mkdirSync(join(skillDir, 'references'), { recursive: true });
+            mkdirSync(join(skillDir, 'assets'), { recursive: true });
+        }
+
+        // Generar SKILL.md
+        const skillMd = generateSkillMd({
+            name,
+            description,
+            role,
+            icon,
+            type,
+            expertise,
+            activatesOn,
+            triggers,
+        });
+
+        writeFileSync(join(skillDir, 'SKILL.md'), skillMd, 'utf-8');
+
+        console.log(c.green(`\n✅ Skill creado exitosamente en: ${skillDir}`));
+        console.log(c.dim('   Editá SKILL.md para completar las secciones con placeholders [...]'));
+        console.log(c.dim('   Ejecutá: node scripts/validate_skills.js ' + slug + ' para validar'));
+        console.log('');
+
+    } finally {
+        prompt.close();
+    }
+}
+
+main().catch(console.error);

package/scripts/validate_skills.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+/**
+ * LMAgent Skills Validator — v2.3.0
+ * 
+ * Valida la integridad de todos los skills del framework.
+ * Verifica: frontmatter YAML, campos obligatorios, estructura de directorio.
+ * 
+ * Uso:
+ *   node scripts/validate_skills.js          # Validar todos
+ *   node scripts/validate_skills.js backend  # Validar uno específico
+ * 
+ * Exit codes:
+ *   0 = Todo OK
+ *   1 = Errores encontrados
+ */
+
+import { readFileSync, readdirSync, existsSync, statSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import gradient from 'gradient-string';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT = resolve(__dirname, '..');
+const SKILLS_DIR = join(ROOT, 'skills');
+
+// ─── Configuración ────────────────────────────────────────────
+const REQUIRED_FIELDS = ['name', 'description', 'role', 'type', 'version', 'icon', 'expertise', 'activates_on', 'triggers'];
+const VALID_TYPES = ['agent_persona', 'methodology'];
+const CURRENT_VERSION = 2.5;
+const OPTIONAL_DIRS = ['scripts', 'references', 'assets'];
+
+// ─── Colores (sin dependencias) ───────────────────────────────
+const c = {
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+
+// ─── Parser de Frontmatter YAML (simple, sin deps) ───────────
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return null;
+
+    const yaml = match[1];
+    const result = {};
+    let currentKey = null;
+    let currentList = null;
+
+    for (const line of yaml.split(/\r?\n/)) {
+        // Lista: "  - item"
+        const listMatch = line.match(/^\s{2,}- (.+)/);
+        if (listMatch && currentKey) {
+            if (!currentList) {
+                currentList = [];
+                result[currentKey] = currentList;
+            }
+            currentList.push(listMatch[1].trim());
+            continue;
+        }
+
+        // Key-value: "key: value"
+        const kvMatch = line.match(/^(\w[\w_]*)\s*:\s*(.*)/);
+        if (kvMatch) {
+            currentKey = kvMatch[1];
+            const rawValue = kvMatch[2].trim();
+            currentList = null;
+
+            if (rawValue === '' || rawValue === '|' || rawValue === '>') {
+                // Será un bloque o lista
+                result[currentKey] = rawValue;
+            } else {
+                // Valor simple — limpiar comillas
+                result[currentKey] = rawValue.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+
+    return result;
+}
+
+// ─── Validar un Skill ─────────────────────────────────────────
+function validateSkill(skillDir) {
+    const skillName = skillDir.split(/[/\\]/).pop();
+    const skillMdPath = join(skillDir, 'SKILL.md');
+    const errors = [];
+    const warnings = [];
+
+    // 1. Verificar SKILL.md existe
+    if (!existsSync(skillMdPath)) {
+        errors.push('Falta archivo SKILL.md');
+        return { skillName, errors, warnings, frontmatter: null };
+    }
+
+    // 2. Parsear frontmatter
+    const content = readFileSync(skillMdPath, 'utf-8');
+    const fm = parseFrontmatter(content);
+
+    if (!fm) {
+        errors.push('No se encontró frontmatter YAML (debe empezar con ---)');
+        return { skillName, errors, warnings, frontmatter: null };
+    }
+
+    // 3. Verificar campos obligatorios
+    for (const field of REQUIRED_FIELDS) {
+        if (!(field in fm)) {
+            errors.push(`Campo obligatorio faltante: ${field}`);
+        } else if (fm[field] === '' || fm[field] === undefined) {
+            errors.push(`Campo obligatorio vacío: ${field}`);
+        }
+    }
+
+    // 4. Verificar tipo válido
+    if (fm.type && !VALID_TYPES.includes(fm.type)) {
+        warnings.push(`Tipo desconocido: "${fm.type}" (esperado: ${VALID_TYPES.join(', ')})`);
+    }
+
+    // 5. Verificar versión
+    if (fm.version) {
+        const ver = parseFloat(fm.version);
+        if (ver !== CURRENT_VERSION) {
+            warnings.push(`Versión ${fm.version} ≠ ${CURRENT_VERSION} (actual del framework)`);
+        }
+    }
+
+    // 6. Verificar que expertise sea una lista
+    if (fm.expertise && !Array.isArray(fm.expertise)) {
+        errors.push('Campo "expertise" debe ser una lista (array)');
+    }
+
+    // 7. Verificar que activates_on sea una lista
+    if (fm.activates_on && !Array.isArray(fm.activates_on)) {
+        errors.push('Campo "activates_on" debe ser una lista (array)');
+    }
+
+    // 8. Verificar que triggers sea una lista y empiece con /
+    if (fm.triggers) {
+        if (!Array.isArray(fm.triggers)) {
+            errors.push('Campo "triggers" debe ser una lista (array)');
+        } else {
+            for (const trigger of fm.triggers) {
+                if (!trigger.startsWith('/')) {
+                    warnings.push(`Trigger "${trigger}" no empieza con / (convención)`);
+                }
+            }
+        }
+    }
+
+    // 9. Verificar nombre del directorio vs nombre del skill
+    const expectedDirName = fm.name
+        ? fm.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+$/, '')
+        : null;
+    // Solo warning, no error, porque los nombres pueden variar razonablemente
+
+    // 10. Verificar secciones del contenido
+    const expectedSections = [
+        { name: 'System Prompt', alternatives: ['Persona', 'Role Definition'] },
+        { name: 'Definition of Done', alternatives: ['Done', 'Criterios de Aceptación'] }
+    ];
+
+    for (const section of expectedSections) {
+        const found = content.includes(section.name) ||
+            section.alternatives.some(alt => content.includes(alt));
+
+        if (!found) {
+            warnings.push(`Sección recomendada faltante: "${section.name}" (o alternativas: ${section.alternatives.join(', ')})`);
+        }
+    }
+
+    // 11. Verificar subdirectorios opcionales
+    const extras = [];
+    for (const dir of OPTIONAL_DIRS) {
+        const dirPath = join(skillDir, dir);
+        if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+            const files = readdirSync(dirPath);
+            extras.push(`${dir}/ (${files.length} archivos)`);
+        }
+    }
+
+    // 12. Verificar que el SKILL.md tenga contenido sustancial
+    const lines = content.split(/\r?\n/).length;
+    if (lines < 50) {
+        warnings.push(`SKILL.md tiene solo ${lines} líneas (recomendado: 100+)`);
+    }
+
+    return { skillName, errors, warnings, frontmatter: fm, extras, lines };
+}
+
+function main() {
+    const filterSkill = process.argv[2];
+
+    console.log(gradient.pastel.multiline('\n🚀 LMAgent Skills Validator v2.5.0\n'));
+    console.log(chalk.dim(`   Directorio: ${SKILLS_DIR}`));
+    console.log(chalk.dim(`   Campos obligatorios: ${REQUIRED_FIELDS.length}`));
+    console.log('');
+
+    const c = chalk;
+
+    if (!existsSync(SKILLS_DIR)) {
+        console.error(c.red('❌ No se encontró el directorio skills/'));
+        process.exit(1);
+    }
+
+    // Obtener lista de skills
+    let skillDirs = readdirSync(SKILLS_DIR)
+        .filter(item => {
+            const itemPath = join(SKILLS_DIR, item);
+            return statSync(itemPath).isDirectory();
+        })
+        .map(item => join(SKILLS_DIR, item));
+
+    if (filterSkill) {
+        skillDirs = skillDirs.filter(d => d.includes(filterSkill));
+        if (skillDirs.length === 0) {
+            console.error(c.red(`❌ No se encontró skill que contenga "${filterSkill}"`));
+            process.exit(1);
+        }
+    }
+
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    const results = [];
+
+    for (const skillDir of skillDirs) {
+        const result = validateSkill(skillDir);
+        results.push(result);
+        totalErrors += result.errors.length;
+        totalWarnings += result.warnings.length;
+    }
+
+    // ─── Reporte ────────────────────────────────────────────────
+    console.log(c.bold(`📊 Validando ${results.length} skills...\n`));
+
+    for (const r of results) {
+        const hasErrors = r.errors.length > 0;
+        const hasWarnings = r.warnings.length > 0;
+        const icon = hasErrors ? '❌' : hasWarnings ? '⚠️' : '✅';
+        const nameColor = hasErrors ? c.red : hasWarnings ? c.yellow : c.green;
+
+        let info = '';
+        if (r.frontmatter) {
+            info = c.dim(` (${r.frontmatter.icon || '?'} ${r.frontmatter.type || '?'} | ${r.lines || '?'} líneas)`);
+        }
+        if (r.extras && r.extras.length > 0) {
+            info += c.dim(` [${r.extras.join(', ')}]`);
+        }
+
+        console.log(`  ${icon} ${nameColor(r.skillName)}${info}`);
+
+        for (const err of r.errors) {
+            console.log(`     ${c.red('ERROR')}: ${err}`);
+        }
+        for (const warn of r.warnings) {
+            console.log(`     ${c.yellow('WARN')}: ${warn}`);
+        }
+    }
+
+    // ─── Resumen ────────────────────────────────────────────────
+    console.log(c.bold('\n' + '─'.repeat(60)));
+    console.log(c.bold('📋 Resumen:'));
+    console.log(`   Skills validados: ${c.cyan(results.length.toString())}`);
+    console.log(`   Errores:          ${totalErrors > 0 ? c.red(totalErrors.toString()) : c.green('0')}`);
+    console.log(`   Warnings:         ${totalWarnings > 0 ? c.yellow(totalWarnings.toString()) : c.green('0')}`);
+    console.log(c.bold('─'.repeat(60) + '\n'));
+
+    if (totalErrors > 0) {
+        console.log(c.red('❌ Validación FALLIDA — hay errores que corregir.\n'));
+        process.exit(1);
+    } else if (totalWarnings > 0) {
+        console.log(c.yellow('⚠️  Validación OK con warnings.\n'));
+        process.exit(0);
+    } else {
+        console.log(c.green('✅ Todos los skills son válidos.\n'));
+        process.exit(0);
+    }
+}
+
+main();