@qubiit/lmagent 3.1.4 → 3.1.8

package/scripts/create_skill.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+
+/**
+ * LMAgent Skill Generator — v3.0.13
+ * 
+ * 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: 3.0.0
+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.7 | LMAgent Framework*
+`;
+}
+
+// ─── Main ─────────────────────────────────────────────────────
+async function main() {
+    console.log(c.bold('\n🛠️  LMAgent Skill Generator v3.0.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/fix_descriptions.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+const path = require('path');
+
+const skillsDir = path.join(__dirname, '..', '.agents', 'skills');
+
+function fixDescriptions() {
+    if (!fs.existsSync(skillsDir)) {
+        console.error('Skills directory not found:', skillsDir);
+        process.exit(1);
+    }
+
+    const skills = fs.readdirSync(skillsDir);
+    let updated = 0;
+
+    skills.forEach(skill => {
+        const skillPath = path.join(skillsDir, skill, 'SKILL.md');
+        if (fs.existsSync(skillPath)) {
+            let content = fs.readFileSync(skillPath, 'utf8');
+
+            // Regex to find description line
+            // Captures "description: value" where value is NOT double-quoted
+            // Note: This is a simple heuristic. It assumes description is on one line.
+            const regex = /^description: ([^"].*)$/m;
+
+            const match = content.match(regex);
+
+            if (match) {
+                const originalDescription = match[1].trim();
+                // Escape existing quotes if any (though regex excludes starting quote)
+                const escapedDescription = originalDescription.replace(/"/g, '\\"');
+                const newLine = `description: "${escapedDescription}"`;
+
+                content = content.replace(match[0], newLine);
+                fs.writeFileSync(skillPath, content, 'utf8');
+                console.log(`✅ Fixed ${skill}: ${originalDescription.substring(0, 30)}...`);
+                updated++;
+            } else {
+                // Check if it's already quoted
+                if (/^description: ".*"$/m.test(content)) {
+                    console.log(`👌 ${skill} already quoted.`);
+                } else {
+                    console.log(`⚠️ ${skill} description format not matching expected pattern.`);
+                }
+            }
+        }
+    });
+
+    console.log(`\nFixed ${updated} skills.`);
+}
+
+fixDescriptions();

package/scripts/token-analyzer.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+// ============================================================
+// LMAgent Token Analyzer
+// Mide el consumo de tokens del framework instalado en el proyecto
+// Uso: node scripts/token-analyzer.js [--json] [--report]
+// ============================================================
+
+const fs = require('fs');
+const path = require('path');
+
+const PKG_VERSION = require('../package.json').version;
+
+// Estimación estándar: ~4 chars = 1 token (GPT/Claude/Gemini)
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+
+function fileSizeKB(bytes) {
+    return (bytes / 1024).toFixed(1);
+}
+
+function scanDir(dir, extensions = ['.md', '.txt', '.mdc', '.toml', '.cursorrules']) {
+    const results = [];
+    if (!fs.existsSync(dir)) return results;
+    const walk = (current) => {
+        for (const item of fs.readdirSync(current)) {
+            const full = path.join(current, item);
+            const stat = fs.statSync(full);
+            if (stat.isDirectory()) {
+                walk(full);
+            } else if (extensions.some(ext => item.endsWith(ext))) {
+                const content = fs.readFileSync(full, 'utf8');
+                results.push({
+                    file: path.relative(process.cwd(), full),
+                    bytes: stat.size,
+                    tokens: estimateTokens(content),
+                    chars: content.length,
+                });
+            }
+        }
+    };
+    walk(dir);
+    return results;
+}
+
+function sumTokens(items) {
+    return items.reduce((acc, i) => acc + i.tokens, 0);
+}
+
+function sumBytes(items) {
+    return items.reduce((acc, i) => acc + i.bytes, 0);
+}
+
+function formatNum(n) {
+    return n.toLocaleString('en-US');
+}
+
+function padEnd(str, len) {
+    return String(str).padEnd(len);
+}
+
+function padStart(str, len) {
+    return String(str).padStart(len);
+}
+
+function row(label, files, tokens, kb) {
+    return `│ ${padEnd(label, 21)}│ ${padStart(files, 8)} │ ${padStart('~' + formatNum(tokens), 9)} │ ${padStart(kb + ' KB', 8)} │`;
+}
+
+function divider() {
+    return '├───────────────────────┼──────────┼───────────┼──────────┤';
+}
+
+function analyze(options = {}) {
+    const projectRoot = process.cwd();
+
+    // Detectar qué agentes están instalados
+    const IDE_CONFIGS = require('../install.js'); // No disponible como export, usamos detección manual
+    const agentDirs = [
+        { name: 'Cursor', rulesDir: '.cursor/rules', skillsDir: '.cursor/skills' },
+        { name: 'Claude Code', rulesDir: '.claude/rules', skillsDir: '.claude/skills' },
+        { name: 'Antigravity', rulesDir: '.agent/rules', skillsDir: '.agent/skills' },
+        { name: 'Gemini CLI', rulesDir: '.gemini/rules', skillsDir: '.gemini/skills' },
+        { name: 'Windsurf', rulesDir: '.windsurf/rules', skillsDir: '.windsurf/skills' },
+        { name: 'Cline', rulesDir: '.clinerules', skillsDir: '.cline/skills' },
+        { name: 'Roo Code', rulesDir: '.roo/rules', skillsDir: '.roo/skills' },
+        { name: 'VSCode Copilot', rulesDir: '.github/instructions', skillsDir: '.github/skills' },
+        { name: 'Augment', rulesDir: '.augment/rules', skillsDir: '.augment/skills' },
+        { name: 'Continue', rulesDir: '.continue/rules', skillsDir: '.continue/skills' },
+        { name: 'Codex', rulesDir: '.codex', skillsDir: '.codex/skills' },
+        { name: 'OpenHands', rulesDir: '.openhands/microagents', skillsDir: '.openhands/skills' },
+        { name: 'Junie', rulesDir: '.junie', skillsDir: '.junie/skills' },
+        { name: 'Goose', rulesDir: '.goose', skillsDir: '.goose/skills' },
+    ];
+
+    const installedAgents = agentDirs.filter(a =>
+        fs.existsSync(path.join(projectRoot, a.rulesDir)) ||
+        fs.existsSync(path.join(projectRoot, a.skillsDir))
+    );
+
+    // ── Entry Points (archivos raíz que el agente lee al arrancar) ──
+    const entryFiles = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', '.cursorrules', '.continuerules', '.goosehints',
+        '.openhands/microagents/repo.md', '.junie/guidelines.md', '.github/copilot-instructions.md'];
+    const entryItems = entryFiles
+        .map(f => path.join(projectRoot, f))
+        .filter(f => fs.existsSync(f))
+        .map(f => {
+            const content = fs.readFileSync(f, 'utf8');
+            return { file: path.relative(projectRoot, f), bytes: fs.statSync(f).size, tokens: estimateTokens(content), chars: content.length };
+        });
+
+    // ── Skills ──
+    const skillsItems = [];
+    for (const agent of installedAgents) {
+        const dir = path.join(projectRoot, agent.skillsDir);
+        skillsItems.push(...scanDir(dir));
+    }
+    // Deduplicar por contenido (mismo archivo copiado a múltiples agentes)
+    const skillsSeen = new Set();
+    const skillsUniq = skillsItems.filter(i => {
+        const key = path.basename(path.dirname(i.file)) + '/' + path.basename(i.file);
+        if (skillsSeen.has(key)) return false;
+        skillsSeen.add(key);
+        return true;
+    });
+
+    // ── Rules ──
+    const rulesItems = [];
+    for (const agent of installedAgents) {
+        const dir = path.join(projectRoot, agent.rulesDir);
+        rulesItems.push(...scanDir(dir));
+    }
+    const rulesSeen = new Set();
+    const rulesUniq = rulesItems.filter(i => {
+        const key = path.basename(i.file);
+        if (rulesSeen.has(key)) return false;
+        rulesSeen.add(key);
+        return true;
+    });
+
+    // ── Workflows ──
+    const workflowsItems = [];
+    const workflowDirs = installedAgents.map(a => a.skillsDir.replace('/skills', '/workflows'));
+    for (const dir of workflowDirs) {
+        workflowsItems.push(...scanDir(path.join(projectRoot, dir)));
+    }
+    const wfSeen = new Set();
+    const workflowsUniq = workflowsItems.filter(i => {
+        const key = path.basename(i.file);
+        if (wfSeen.has(key)) return false;
+        wfSeen.add(key);
+        return true;
+    });
+
+    // ── Totales ──
+    const totalTokens = sumTokens(entryItems) + sumTokens(skillsUniq) + sumTokens(rulesUniq) + sumTokens(workflowsUniq);
+    const totalFiles = entryItems.length + skillsUniq.length + rulesUniq.length + workflowsUniq.length;
+    const totalBytes = sumBytes(entryItems) + sumBytes(skillsUniq) + sumBytes(rulesUniq) + sumBytes(workflowsUniq);
+
+    // ── Overhead real por sesión ──
+    // Solo se carga: entry point + 1 skill activo (on-demand)
+    const avgEntryTokens = sumTokens(entryItems);
+    const avgSkillTokens = skillsUniq.length > 0
+        ? Math.round(sumTokens(skillsUniq) / skillsUniq.length)
+        : 0;
+    const sessionOverhead = avgEntryTokens + avgSkillTokens;
+
+    const data = {
+        version: PKG_VERSION,
+        installedAgents: installedAgents.map(a => a.name),
+        categories: {
+            entryPoints: { files: entryItems.length, tokens: sumTokens(entryItems), bytes: sumBytes(entryItems) },
+            skills: { files: skillsUniq.length, tokens: sumTokens(skillsUniq), bytes: sumBytes(skillsUniq) },
+            rules: { files: rulesUniq.length, tokens: sumTokens(rulesUniq), bytes: sumBytes(rulesUniq) },
+            workflows: { files: workflowsUniq.length, tokens: sumTokens(workflowsUniq), bytes: sumBytes(workflowsUniq) },
+        },
+        total: { files: totalFiles, tokens: totalTokens, bytes: totalBytes },
+        sessionOverhead: { tokens: sessionOverhead, entryPoints: avgEntryTokens, avgSkill: avgSkillTokens },
+    };
+
+    if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+
+    // ── Tabla visual ──
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════╗');
+    console.log(`║       LMAgent Token Analyzer v${PKG_VERSION}${' '.repeat(Math.max(0, 22 - PKG_VERSION.length))}║`);
+    console.log('╚══════════════════════════════════════════════════════╝');
+    console.log('');
+
+    if (installedAgents.length === 0) {
+        console.log('⚠️  No se detectó ningún agente instalado en este proyecto.');
+        console.log('   Ejecuta `lmagent install` primero.');
+        return;
+    }
+
+    console.log(`🤖  Agentes detectados: ${installedAgents.map(a => a.name).join(', ')}`);
+    console.log('');
+    console.log('📊  Análisis de Consumo de Tokens del Framework');
+    console.log('');
+    console.log('┌───────────────────────┬──────────┬───────────┬──────────┐');
+    console.log('│ Categoría             │ Archivos │  Tokens   │   Tamaño │');
+    console.log('├───────────────────────┼──────────┼───────────┼──────────┤');
+    console.log(row('Entry Points', entryItems.length, sumTokens(entryItems), fileSizeKB(sumBytes(entryItems))));
+    console.log(row(`Skills (${skillsUniq.length} únicos)`, skillsUniq.length, sumTokens(skillsUniq), fileSizeKB(sumBytes(skillsUniq))));
+    console.log(row('Rules', rulesUniq.length, sumTokens(rulesUniq), fileSizeKB(sumBytes(rulesUniq))));
+    console.log(row('Workflows', workflowsUniq.length, sumTokens(workflowsUniq), fileSizeKB(sumBytes(workflowsUniq))));
+    console.log('├───────────────────────┼──────────┼───────────┼──────────┤');
+    console.log(row('TOTAL FRAMEWORK', totalFiles, totalTokens, fileSizeKB(totalBytes)));
+    console.log('└───────────────────────┴──────────┴───────────┴──────────┘');
+    console.log('');
+    console.log('⚡  Overhead real por sesión (contexto auto-cargado):');
+    console.log('');
+    console.log(`   Sin framework:   0 tokens de contexto de agente`);
+    console.log(`   Entry points:    ~${formatNum(avgEntryTokens)} tokens (leídos siempre)`);
+    console.log(`   Skill activo:    ~${formatNum(avgSkillTokens)} tokens promedio (on-demand)`);
+    console.log(`   ─────────────────────────────────────────────────`);
+    console.log(`   Overhead real:   ~${formatNum(sessionOverhead)} tokens por sesión  ← BAJO`);
+    console.log('');
+    console.log('💡  Los skills NO se cargan todos juntos. Solo se activa');
+    console.log('   el skill que el agente invoca (/dev, /front, /arch, etc.)');
+    console.log('');
+
+    if (options.report) {
+        generateReport(data, projectRoot);
+    }
+}
+
+function generateReport(data, projectRoot) {
+    const reportDir = path.join(projectRoot, '.agents');
+    if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
+
+    const reportPath = path.join(reportDir, 'token-report.md');
+    const now = new Date().toISOString().split('T')[0];
+
+    const md = `# LMAgent Token Report v${data.version}
+> Generado: ${now}
+
+## Agentes instalados
+${data.installedAgents.map(a => `- ${a}`).join('\n')}
+
+## Consumo por categoría
+
+| Categoría | Archivos | Tokens (est.) | Tamaño |
+|:---|---:|---:|---:|
+| Entry Points | ${data.categories.entryPoints.files} | ~${formatNum(data.categories.entryPoints.tokens)} | ${fileSizeKB(data.categories.entryPoints.bytes)} KB |
+| Skills | ${data.categories.skills.files} | ~${formatNum(data.categories.skills.tokens)} | ${fileSizeKB(data.categories.skills.bytes)} KB |
+| Rules | ${data.categories.rules.files} | ~${formatNum(data.categories.rules.tokens)} | ${fileSizeKB(data.categories.rules.bytes)} KB |
+| Workflows | ${data.categories.workflows.files} | ~${formatNum(data.categories.workflows.tokens)} | ${fileSizeKB(data.categories.workflows.bytes)} KB |
+| **TOTAL** | **${data.total.files}** | **~${formatNum(data.total.tokens)}** | **${fileSizeKB(data.total.bytes)} KB** |
+
+## Overhead real por sesión
+
+| Componente | Tokens |
+|:---|---:|
+| Entry Points (siempre cargados) | ~${formatNum(data.sessionOverhead.entryPoints)} |
+| Skill activo (promedio, on-demand) | ~${formatNum(data.sessionOverhead.avgSkill)} |
+| **Total overhead por sesión** | **~${formatNum(data.sessionOverhead.tokens)}** |
+
+> Los skills **no** se cargan todos juntos. Solo se activa el skill que el agente invoca.
+`;
+
+    fs.writeFileSync(reportPath, md, 'utf8');
+    console.log(`📄  Reporte guardado en: ${reportPath}`);
+}
+
+// CLI directo
+const args = process.argv.slice(2);
+const options = {
+    json: args.includes('--json'),
+    report: args.includes('--report'),
+};
+analyze(options);