helix-assistant-cli 0.0.0-stage → 0.2.4

package/dist/commands/mcp.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleListMcp = handleListMcp;
+exports.handleCreateMcp = handleCreateMcp;
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+async function handleListMcp(client) {
+    console.log(`\n${(0, colors_1.BOLD)('🔌 Servidores y Herramientas MCP:')}\n`);
+    try {
+        const servers = await client.getMcpServers();
+        if (!servers || servers.length === 0) {
+            console.log((0, colors_1.GRAY)('  No hay servidores MCP configurados actualmente.'));
+            console.log((0, colors_1.DIM)('  Usa /create-mcp para configurar uno nuevo.\n'));
+            return;
+        }
+        for (const server of servers) {
+            let statusBadge = chalk_1.default.gray('idle');
+            if (server.status === 'connected') {
+                statusBadge = chalk_1.default.green('● Conectado');
+            }
+            else if (server.status === 'connecting') {
+                statusBadge = chalk_1.default.yellow('⏳ Conectando');
+            }
+            else if (server.status === 'error') {
+                statusBadge = chalk_1.default.red('✖ Error');
+            }
+            console.log(`  ${(0, colors_1.CYAN_BOLD)('◈')} ${(0, colors_1.formatMcp)(server.name)}  [${statusBadge}]`);
+            console.log(`    ${(0, colors_1.GRAY)('Comando:')} ${chalk_1.default.white(server.command)}`);
+            if (server.error) {
+                console.log(`    ${(0, colors_1.RED)('Error:')} ${server.error}`);
+            }
+            if (server.tools && server.tools.length > 0) {
+                console.log(`    ${(0, colors_1.DIM)('Herramientas provistas:')}`);
+                for (const tool of server.tools) {
+                    console.log(`      ${(0, colors_1.DIM)('•')} ${(0, colors_1.formatMcp)(tool.name)}${tool.description ? (0, colors_1.DIM)(` - ${tool.description}`) : ''}`);
+                }
+            }
+            console.log('');
+        }
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  Error al obtener servidores MCP: ${err.message}\n`));
+    }
+}
+async function handleCreateMcp(client) {
+    console.log(`\n${(0, colors_1.BOLD)('⚙️  Registrar Nuevo Servidor MCP')}\n`);
+    const answers = await (0, prompts_1.default)([
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Nombre identificador del servidor MCP (ej. filesystem, github, fetch):',
+            validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) ? true : 'Usa solo letras, números, guiones y guiones bajos',
+        },
+        {
+            type: 'text',
+            name: 'command',
+            message: 'Comando ejecutable o npx (ej. npx -y @modelcontextprotocol/server-filesystem C:\\work):',
+            validate: (v) => (v && v.trim() ? true : 'El comando es requerido'),
+        },
+        {
+            type: 'text',
+            name: 'env',
+            message: 'Variables de entorno opcionales (formato KEY=VALUE,KEY2=VALUE2):',
+            initial: '',
+        },
+    ]);
+    if (!answers.name || !answers.command) {
+        console.log((0, colors_1.YELLOW)('\nOperación cancelada.\n'));
+        return;
+    }
+    const envObj = {};
+    if (answers.env && typeof answers.env === 'string') {
+        const pairs = answers.env.split(',');
+        for (const pair of pairs) {
+            const [k, v] = pair.split('=');
+            if (k && v)
+                envObj[k.trim()] = v.trim();
+        }
+    }
+    try {
+        const currentSettings = await client.getSettings();
+        const existingServers = currentSettings.mcp_servers || [];
+        // Filter out existing with same name
+        const updatedServers = existingServers.filter((s) => s.name !== answers.name);
+        updatedServers.push({
+            name: answers.name.trim(),
+            command: answers.command.trim(),
+            env: Object.keys(envObj).length > 0 ? envObj : undefined,
+        });
+        console.log((0, colors_1.GRAY)(`\nGuardando servidor MCP ${(0, colors_1.formatMcp)(answers.name)}...`));
+        await client.saveSettings({ mcp_servers: updatedServers });
+        console.log((0, colors_1.GREEN)(`✔ ¡Servidor MCP ${(0, colors_1.formatMcp)(answers.name)} registrado con éxito!`));
+        console.log((0, colors_1.DIM)(`  HELIX sincronizará las herramientas automáticamente.\n`));
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`✖ Error al registrar servidor MCP: ${err.message}\n`));
+    }
+}

package/dist/commands/mic.d.ts

@@ -0,0 +1,2 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleMicrophoneCommand(client: AgentClient, action?: string, currentVoiceState?: boolean): Promise<boolean>;

package/dist/commands/mic.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMicrophoneCommand = handleMicrophoneCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+async function handleMicrophoneCommand(client, action, currentVoiceState = true) {
+    const normalizedAction = action?.toLowerCase().trim();
+    if (normalizedAction === 'enable' || normalizedAction === 'on' || normalizedAction === 'true') {
+        try {
+            console.log((0, colors_1.GRAY)('\nActivando micrófono en el agente HELIX...'));
+            await client.saveSettings({ voice_enabled: true });
+            console.log(`${(0, colors_1.GREEN)('🟢 Micrófono:')} ${chalk_1.default.greenBright.bold('ACTIVO')} ${(0, colors_1.DIM)('(Escuchando wake word: "hey helix").')}\n`);
+            return true;
+        }
+        catch (err) {
+            console.log((0, colors_1.RED)(`✖ Error al activar micrófono: ${err.message}\n`));
+            return currentVoiceState;
+        }
+    }
+    if (normalizedAction === 'disable' || normalizedAction === 'off' || normalizedAction === 'false') {
+        try {
+            console.log((0, colors_1.GRAY)('\nDesactivando micrófono en el agente HELIX...'));
+            await client.saveSettings({ voice_enabled: false });
+            console.log(`${(0, colors_1.RED)('🔴 Micrófono:')} ${chalk_1.default.redBright.bold('INACTIVO')} ${(0, colors_1.DIM)('(Entrada por voz deshabilitada).')}\n`);
+            return false;
+        }
+        catch (err) {
+            console.log((0, colors_1.RED)(`✖ Error al desactivar micrófono: ${err.message}\n`));
+            return currentVoiceState;
+        }
+    }
+    // If no action or invalid action, show current status and instructions
+    try {
+        const settings = await client.getSettings();
+        const isEnabled = settings.voice_enabled ?? currentVoiceState;
+        const wakeWord = settings.wake_word || 'hey helix';
+        console.log(`\n${(0, colors_1.BOLD)('🎤 Estado del Micrófono y Reconocimiento de Voz:')}\n`);
+        if (isEnabled) {
+            console.log(`  Estado:      ${(0, colors_1.GREEN)('🟢 ACTIVO')}`);
+            console.log(`  Wake Word:   ${chalk_1.default.cyan.bold(`"${wakeWord}"`)}`);
+            console.log(`  Detalles:    El agente procesará tu voz al decir "${wakeWord}".`);
+        }
+        else {
+            console.log(`  Estado:      ${(0, colors_1.RED)('🔴 INACTIVO')}`);
+            console.log(`  Detalles:    La captura de voz está desactivada.`);
+        }
+        console.log(`\n  ${(0, colors_1.DIM)('Uso: /microphone enable | /microphone disable')}\n`);
+        return isEnabled;
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  Error al consultar configuración de voz: ${err.message}\n`));
+        return currentVoiceState;
+    }
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,3 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleListSkills(client: AgentClient, specificSkill?: string): Promise<void>;
+export declare function handleCreateSkill(client: AgentClient): Promise<void>;

package/dist/commands/skills.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleListSkills = handleListSkills;
+exports.handleCreateSkill = handleCreateSkill;
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+async function handleListSkills(client, specificSkill) {
+    try {
+        const skills = await client.getSkills();
+        if (!skills || skills.length === 0) {
+            console.log((0, colors_1.GRAY)('\n  No hay skills registradas en el agente.\n'));
+            return;
+        }
+        if (specificSkill) {
+            const match = skills.find((s) => s.name.toLowerCase() === specificSkill.toLowerCase() || `@${s.name.toLowerCase()}` === specificSkill.toLowerCase());
+            if (match) {
+                console.log(`\n${(0, colors_1.BOLD)('Detalles de la Skill:')}`);
+                console.log(`  Nombre:       ${(0, colors_1.formatSkill)(match.name)}`);
+                console.log(`  Descripción:  ${chalk_1.default.white(match.description || 'Sin descripción')}`);
+                if (match.triggers && match.triggers.length > 0) {
+                    console.log(`  Disparadores: ${(0, colors_1.DIM)(match.triggers.join(', '))}`);
+                }
+                if (match.instructions) {
+                    console.log(`  Instrucciones:\n${(0, colors_1.GRAY)('    ' + match.instructions.replace(/\n/g, '\n    '))}`);
+                }
+                console.log('');
+                return;
+            }
+            console.log((0, colors_1.YELLOW)(`\n  Skill "${specificSkill}" no encontrada. Listando todas las disponibles:\n`));
+        }
+        console.log(`\n${(0, colors_1.BOLD)('⚡ Skills Registradas en HELIX:')}\n`);
+        for (const skill of skills) {
+            const nameTag = (0, colors_1.formatSkill)(skill.name);
+            const isCustom = skill.custom ? chalk_1.default.hex('#FFA500')(' [custom]') : '';
+            console.log(`  ${(0, colors_1.ORANGE_BOLD)('✦')} ${nameTag}${isCustom}`);
+            if (skill.description) {
+                console.log(`    ${(0, colors_1.DIM)(skill.description)}`);
+            }
+            if (skill.triggers && skill.triggers.length > 0) {
+                console.log(`    ${(0, colors_1.GRAY)('Triggers:')} ${(0, colors_1.DIM)(skill.triggers.slice(0, 4).join(', '))}`);
+            }
+            console.log('');
+        }
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  Error al obtener skills: ${err.message}\n`));
+    }
+}
+async function handleCreateSkill(client) {
+    console.log(`\n${(0, colors_1.BOLD)('🛠️  Crear Nueva Skill en HELIX')}\n`);
+    const answers = await (0, prompts_1.default)([
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Nombre de la skill (ej. web-summarizer, code-auditor):',
+            validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v)
+                ? true
+                : 'El nombre solo puede contener letras, números, guiones y guiones bajos',
+        },
+        {
+            type: 'text',
+            name: 'description',
+            message: 'Descripción corta de la funcionalidad:',
+            validate: (v) => (v && v.trim() ? true : 'La descripción es requerida'),
+        },
+        {
+            type: 'text',
+            name: 'triggers',
+            message: 'Palabras clave disparadoras (separadas por coma, opcional):',
+            initial: '',
+        },
+        {
+            type: 'text',
+            name: 'instructions',
+            message: 'Instrucciones o system prompt para la ejecución de la skill:',
+            validate: (v) => (v && v.trim() ? true : 'Las instrucciones son requeridas'),
+        },
+    ]);
+    if (!answers.name || !answers.description || !answers.instructions) {
+        console.log((0, colors_1.YELLOW)('\nOperación cancelada.\n'));
+        return;
+    }
+    const triggersList = typeof answers.triggers === 'string'
+        ? answers.triggers.split(',').map((t) => t.trim()).filter(Boolean)
+        : [];
+    const skillPayload = {
+        name: answers.name.trim(),
+        description: answers.description.trim(),
+        triggers: triggersList,
+        instructions: answers.instructions.trim(),
+    };
+    try {
+        console.log((0, colors_1.GRAY)(`\nGuardando skill ${(0, colors_1.formatSkill)(skillPayload.name)}...`));
+        await client.saveSkill(skillPayload);
+        console.log((0, colors_1.GREEN)(`✔ ¡Skill ${(0, colors_1.formatSkill)(skillPayload.name)} creada con éxito!`));
+        console.log((0, colors_1.DIM)(`  Puedes invocarla usando: ${(0, colors_1.formatSkill)(skillPayload.name)} <tu consulta>\n`));
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`✖ Error al crear la skill: ${err.message}\n`));
+    }
+}

package/dist/config/env.d.ts

@@ -0,0 +1,6 @@
+export declare function loadHelixEnv(): void;
+export declare function getWsPort(): number;
+export declare function getWsUrl(override?: string): string;
+export declare function getTokenFilePath(): string;
+export declare function getWsToken(override?: string): string | undefined;
+export declare function getSettingsFilePath(): string;

package/dist/config/env.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHelixEnv = loadHelixEnv;
+exports.getWsPort = getWsPort;
+exports.getWsUrl = getWsUrl;
+exports.getTokenFilePath = getTokenFilePath;
+exports.getWsToken = getWsToken;
+exports.getSettingsFilePath = getSettingsFilePath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const dotenv_1 = __importDefault(require("dotenv"));
+// Discover .env from current directory, parent dirs, or monorepo root
+function loadHelixEnv() {
+    const searchDirs = [
+        process.cwd(),
+        path_1.default.resolve(process.cwd(), '../..'),
+        path_1.default.resolve(__dirname, '../../..'),
+        path_1.default.resolve(__dirname, '../../../..'),
+    ];
+    for (const dir of searchDirs) {
+        const envPath = path_1.default.join(dir, '.env');
+        if (fs_1.default.existsSync(envPath)) {
+            dotenv_1.default.config({ path: envPath });
+            break;
+        }
+    }
+}
+// Automatically load on import
+loadHelixEnv();
+function getWsPort() {
+    if (process.env.AGENT_WS_PORT && !isNaN(Number(process.env.AGENT_WS_PORT))) {
+        return Number(process.env.AGENT_WS_PORT);
+    }
+    return 8765;
+}
+function getWsUrl(override) {
+    if (override)
+        return override;
+    if (process.env.AGENT_WS_URL)
+        return process.env.AGENT_WS_URL;
+    return `ws://127.0.0.1:${getWsPort()}`;
+}
+function getTokenFilePath() {
+    const appData = process.env.APPDATA || (process.platform === 'darwin' ? path_1.default.join(process.env.HOME || '', 'Library/Application Support') : path_1.default.join(process.env.HOME || '', '.config'));
+    return path_1.default.join(appData, 'HELIX', '.ws_token');
+}
+function getWsToken(override) {
+    if (override)
+        return override;
+    if (process.env.HELIX_WS_TOKEN)
+        return process.env.HELIX_WS_TOKEN;
+    const tokenFile = getTokenFilePath();
+    if (fs_1.default.existsSync(tokenFile)) {
+        try {
+            const saved = fs_1.default.readFileSync(tokenFile, 'utf-8').trim();
+            if (saved.length >= 16) {
+                process.env.HELIX_WS_TOKEN = saved;
+                return saved;
+            }
+        }
+        catch { }
+    }
+    return undefined;
+}
+function getSettingsFilePath() {
+    const appData = process.env.APPDATA || (process.platform === 'darwin' ? path_1.default.join(process.env.HOME || '', 'Library/Application Support') : path_1.default.join(process.env.HOME || '', '.config'));
+    return path_1.default.join(appData, 'HELIX', 'settings.json');
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// ═══════════════════════════════════════════════════════════════
+// Cross-Platform Terminal & Stream Encoding Setup
+// Compatible with: Windows CMD (CP850/437/1252/65001), PowerShell,
+// Linux terminal (xterm/kitty/gnome), and Bash (MSYS2/Git Bash/WSL).
+// ═══════════════════════════════════════════════════════════════
+if (process.stdin.setEncoding) {
+    process.stdin.setEncoding('utf-8');
+}
+if (process.stdout.setDefaultEncoding) {
+    process.stdout.setDefaultEncoding('utf-8');
+}
+if (process.stderr.setDefaultEncoding) {
+    process.stderr.setDefaultEncoding('utf-8');
+}
+// On Windows, force console code page to 65001 (UTF-8)
+if (process.platform === 'win32') {
+    try {
+        const { execSync } = require('child_process');
+        execSync('chcp 65001 >nul 2>&1', { stdio: 'ignore' });
+    }
+    catch {
+        // Silently continue if chcp is unavailable
+    }
+}
+const commander_1 = require("commander");
+const repl_1 = require("./ui/repl");
+const env_1 = require("./config/env");
+const agent_client_1 = require("./client/agent-client");
+const apikey_1 = require("./commands/apikey");
+const colors_1 = require("./ui/colors");
+const banner_1 = require("./ui/banner");
+async function readStdin() {
+    if (process.stdin.isTTY) {
+        return '';
+    }
+    return new Promise((resolve) => {
+        let input = '';
+        const onData = (chunk) => {
+            input += chunk.toString();
+        };
+        process.stdin.on('data', onData);
+        process.stdin.once('end', () => {
+            cleanup();
+            if (input.charCodeAt(0) === 0xfeff)
+                input = input.slice(1);
+            resolve(input.trim());
+        });
+        process.stdin.once('error', () => {
+            cleanup();
+            resolve('');
+        });
+        // If no data arrives and stream is not ended within 300ms, abort to prevent hanging
+        const timer = setTimeout(() => {
+            cleanup();
+            if (input.charCodeAt(0) === 0xfeff)
+                input = input.slice(1);
+            resolve(input.trim());
+        }, 300);
+        function cleanup() {
+            clearTimeout(timer);
+            process.stdin.removeListener('data', onData);
+            process.stdin.pause();
+        }
+        process.stdin.resume();
+    });
+}
+const program = new commander_1.Command();
+program
+    .name('helix')
+    .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
+    .version('0.1.0')
+    .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', (0, env_1.getWsUrl)())
+    .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', (0, env_1.getWsToken)())
+    .action(async (options) => {
+    // Default action: start interactive chat REPL
+    const repl = new repl_1.HelixRepl({
+        wsUrl: options.wsUrl || (0, env_1.getWsUrl)(),
+        wsToken: options.token || (0, env_1.getWsToken)(),
+    });
+    await repl.start();
+});
+program
+    .command('chat')
+    .description('Iniciar sesión de chat interactivo con HELIX')
+    .action(async () => {
+    const opts = program.opts();
+    const repl = new repl_1.HelixRepl({
+        wsUrl: opts.wsUrl || (0, env_1.getWsUrl)(),
+        wsToken: opts.token || (0, env_1.getWsToken)(),
+    });
+    await repl.start();
+});
+program
+    .command('run [prompt...]')
+    .description('Ejecutar un prompt directamente y esperar la respuesta (soporta pipes: cat file | helix run)')
+    .action(async (promptParts) => {
+    let promptText = (promptParts || []).join(' ').trim();
+    if (!promptText || promptText === '-') {
+        promptText = await readStdin();
+    }
+    if (!promptText) {
+        console.error((0, colors_1.RED)('Error: Debes proporcionar un prompt como argumento o a través de stdin (ej: echo "hola" | helix run).'));
+        process.exit(1);
+    }
+    const opts = program.opts();
+    const client = new agent_client_1.AgentClient({
+        wsUrl: opts.wsUrl || (0, env_1.getWsUrl)(),
+        wsToken: opts.token || (0, env_1.getWsToken)(),
+        autoReconnect: false,
+    });
+    console.log((0, colors_1.DIM)(`Prompt: ${promptText}\n`));
+    console.log((0, colors_1.CYAN)(`Conectando con HELIX en ${client.url}...`));
+    try {
+        await client.connect();
+    }
+    catch (err) {
+        console.error((0, colors_1.RED)(`No se pudo conectar al agente HELIX: ${err.message}`));
+        process.exit(1);
+    }
+    const convId = `cli_run_${Date.now()}`;
+    client.on('react_step', (step) => {
+        process.stdout.write(`\r${(0, colors_1.DIM)(`[ReAct Step ${step?.iteration || 1}...]`)}`);
+    });
+    client.on('agent_message', (payload) => {
+        process.stdout.write('\r\x1b[K');
+        console.log(payload?.content || '');
+        client.close();
+        process.exit(0);
+    });
+    client.sendUserText(promptText, convId);
+    // Timeout safety
+    setTimeout(() => {
+        console.error((0, colors_1.RED)('\nTiempo de espera agotado sin respuesta del agente.'));
+        client.close();
+        process.exit(1);
+    }, 60000);
+});
+program
+    .command('status')
+    .description('Consultar el estado del agente y los subsistemas')
+    .action(async () => {
+    const opts = program.opts();
+    const client = new agent_client_1.AgentClient({
+        wsUrl: opts.wsUrl || (0, env_1.getWsUrl)(),
+        wsToken: opts.token || (0, env_1.getWsToken)(),
+        autoReconnect: false,
+    });
+    console.log((0, banner_1.getAsciiLogo)());
+    console.log((0, colors_1.BOLD)('Consultando estado de HELIX...\n'));
+    try {
+        await client.connect();
+        console.log(`  ${(0, colors_1.GREEN)('● Conectado')} al agente en ${client.url}`);
+        const [settings, skills, mcpServers] = await Promise.all([
+            client.getSettings().catch(() => ({})),
+            client.getSkills().catch(() => []),
+            client.getMcpServers().catch(() => []),
+        ]);
+        const micStatus = settings.voice_enabled !== false ? (0, colors_1.GREEN)('🟢 Activo') : (0, colors_1.RED)('🔴 Inactivo');
+        console.log(`  Micrófono:   ${micStatus}`);
+        console.log(`  Skills:      ${(0, colors_1.ORANGE)(skills.length.toString())} registradas`);
+        console.log(`  MCP Servers: ${(0, colors_1.CYAN)(mcpServers.length.toString())} configurados`);
+        console.log('');
+        client.close();
+    }
+    catch (err) {
+        console.log(`  ${(0, colors_1.RED)('● Desconectado')} del agente en ${client.url}`);
+        console.log((0, colors_1.DIM)(`  Detalle: ${err.message}\n`));
+    }
+});
+program
+    .command('apikeys')
+    .description('Mostrar el estado de las claves API configuradas')
+    .action(async () => {
+    const opts = program.opts();
+    const client = new agent_client_1.AgentClient({
+        wsUrl: opts.wsUrl || (0, env_1.getWsUrl)(),
+        wsToken: opts.token || (0, env_1.getWsToken)(),
+        autoReconnect: false,
+    });
+    try {
+        await client.connect();
+        await (0, apikey_1.handleShowApiKey)(client);
+    }
+    catch (err) {
+        console.error((0, colors_1.RED)(`Error de conexión con el agente: ${err.message}`));
+    }
+    finally {
+        client.close();
+    }
+});
+program.parse(process.argv);

package/dist/ui/autocomplete.d.ts

@@ -0,0 +1,25 @@
+import type { AgentClient } from '../client/agent-client';
+export interface CommandDefinition {
+    command: string;
+    description: string;
+    usage?: string;
+}
+export declare const SLASH_COMMANDS: CommandDefinition[];
+export declare class Autocompleter {
+    private client?;
+    private skills;
+    private mcpTools;
+    constructor(client?: AgentClient | undefined);
+    refreshSuggestions(): Promise<void>;
+    getSkills(): string[];
+    getMcpTools(): string[];
+    /**
+     * Completer function matching readline specification:
+     * (line: string) => [string[], string]
+     */
+    completer(line: string): [string[], string];
+    /**
+     * Formats the list of commands for display.
+     */
+    renderHelp(): void;
+}