helix-assistant-cli 0.0.0-stage → 0.2.1

package/dist/ui/repl.js

@@ -0,0 +1,402 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelixRepl = void 0;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const agent_client_1 = require("../client/agent-client");
+const autocomplete_1 = require("./autocomplete");
+const banner_1 = require("./banner");
+const colors_1 = require("./colors");
+const apikey_1 = require("../commands/apikey");
+const skills_1 = require("../commands/skills");
+const mcp_1 = require("../commands/mcp");
+const mic_1 = require("../commands/mic");
+const browser_1 = require("../commands/browser");
+class HelixRepl {
+    options;
+    rl = null;
+    client;
+    autocompleter;
+    conversationId;
+    conversationHistory = [];
+    voiceEnabled = true;
+    isCapturingVoice = false;
+    currentModel = null;
+    activeTaskId = null;
+    activeTasksCount = 0;
+    isProcessingPrompt = false;
+    constructor(options) {
+        this.options = options;
+        this.conversationId = `cli_conv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        this.client = new agent_client_1.AgentClient({
+            wsUrl: options.wsUrl,
+            wsToken: options.wsToken,
+        });
+        this.autocompleter = new autocomplete_1.Autocompleter(this.client);
+    }
+    async start() {
+        this._setupClientEvents();
+        try {
+            await this.client.connect();
+        }
+        catch {
+            // Connect in background if agent is still starting
+        }
+        await this._syncSettings();
+        await this.autocompleter.refreshSuggestions();
+        // Render persistent initial banner
+        this.refreshBanner(true);
+        this._startReadline();
+    }
+    async _syncSettings() {
+        if (!this.client.connected)
+            return;
+        try {
+            // CLI mode: disable camera/gesture engine and skip per-tool verification
+            // (verification adds 2 extra LLM round-trips per tool call, not needed in CLI context)
+            await this.client.saveSettings({
+                camera_enabled: false,
+                tool_verification_enabled: false,
+            }).catch(() => { });
+            const settings = await this.client.getSettings();
+            if (typeof settings.voice_enabled === 'boolean') {
+                this.voiceEnabled = settings.voice_enabled;
+            }
+            if (typeof settings.default_model === 'string') {
+                this.currentModel = settings.default_model;
+            }
+        }
+        catch {
+            // Fallback defaults
+        }
+    }
+    refreshBanner(clearScreen = false) {
+        const status = {
+            connected: this.client.connected,
+            wsUrl: this.client.url,
+            voiceEnabled: this.voiceEnabled,
+            isCapturingVoice: this.isCapturingVoice,
+            currentModel: this.currentModel,
+            activeTasksCount: this.activeTasksCount,
+        };
+        (0, banner_1.renderHeader)(status, clearScreen);
+    }
+    waitingLogged = false;
+    _setupClientEvents() {
+        this.client.on('connected', async () => {
+            this.waitingLogged = false;
+            await this._syncSettings();
+            await this.autocompleter.refreshSuggestions();
+            process.stdout.write(`\r\x1b[K${chalk_1.default.green('●')} ${chalk_1.default.greenBright.bold('Conectado al agente HELIX')}  \n`);
+            this._promptUser();
+        });
+        this.client.on('disconnected', () => {
+            if (this.client.isStarting) {
+                return; // Do not interrupt or print disconnect loops while agent is booting
+            }
+            if (!this.waitingLogged) {
+                this.waitingLogged = true;
+                console.log(`\n${(0, colors_1.RED)('●')} ${chalk_1.default.yellowBright('Esperando al servicio del agente HELIX en ws://127.0.0.1:8765...')}`);
+                console.log(`${(0, colors_1.GRAY)('  (Si no responde tras 3 reintentos, el CLI lo iniciará automáticamente en segundo plano)')}\n`);
+            }
+            this._promptUser();
+        });
+        this.client.on('auto_spawning_agent', () => {
+            process.stdout.write(`\n${(0, colors_1.CYAN_BOLD)('⚙️')} ${chalk_1.default.hex('#FF9F1C').bold('[AUTO-START]:')} Iniciando el servicio del agente HELIX en segundo plano...\n`);
+            process.stdout.write(`${(0, colors_1.GRAY)('  Por favor espere mientras termina de inicializarse (no se realizarán reintentos hasta que esté listo).')}\n`);
+        });
+        this.client.on('agent_starting_progress', (data) => {
+            process.stdout.write(`\r  ${chalk_1.default.hex('#FF9F1C')('⏳')} ${chalk_1.default.gray(`Inicializando subsistemas de HELIX en segundo plano... (${data.elapsedSec}s)`)}`);
+        });
+        this.client.on('agent_ready', () => {
+            process.stdout.write(`\r\x1b[K  ${chalk_1.default.green('✔')} ${chalk_1.default.greenBright('Servicio de HELIX listo. Conectando...')}\n\n`);
+        });
+        this.client.on('agent_start_failed', (data) => {
+            process.stdout.write(`\r\x1b[K\n  ${chalk_1.default.red('✖')} ${chalk_1.default.redBright('No se pudo iniciar el servicio automáticamente:')} ${chalk_1.default.gray(data?.error || 'Tiempo agotado')}\n`);
+            this._promptUser();
+        });
+        // Voice Capture indicator
+        this.client.on('voice_capture_started', () => {
+            this.isCapturingVoice = true;
+            process.stdout.write(`\n${chalk_1.default.bgRed.white.bold(' 🎙️  [VOZ DETECTADA - HEY HELIX]: Capturando audio... ')}\n`);
+        });
+        this.client.on('voice_capture_stopped', () => {
+            this.isCapturingVoice = false;
+            process.stdout.write(`\n${chalk_1.default.bgCyan.black.bold(' 🔊 [AUDIO RECIBIDO]: Procesando voz... ')}\n`);
+            this._promptUser();
+        });
+        // ReAct Step Progress
+        this.client.on('react_step', (step) => {
+            const iter = step?.iteration ?? 1;
+            const role = step?.role ? chalk_1.default.gray(` (${step.role})`) : '';
+            process.stdout.write(`\r  ${chalk_1.default.hex('#FF9F1C')('◆')} ${chalk_1.default.gray(`Paso ${iter}${role} — Razonando...`)}`);
+        });
+        // Agent assistant message
+        this.client.on('agent_message', (payload) => {
+            this.isProcessingPrompt = false;
+            this.activeTaskId = null;
+            if (this.activeTasksCount > 0)
+                this.activeTasksCount--;
+            const content = payload?.content ?? '';
+            const modelBadge = payload?.model
+                ? chalk_1.default.gray(` [${payload.model}]`)
+                : '';
+            // Clear any in-progress step line
+            process.stdout.write('\r\x1b[K');
+            // Branded header
+            console.log('');
+            console.log(`  ${chalk_1.default.hex('#FF8C00').bold('⬡ HELIX')}${modelBadge}`);
+            // Content with subtle left border
+            const contentLines = content.trim().split('\n');
+            for (const line of contentLines) {
+                console.log(`  ${chalk_1.default.gray('│')} ${line}`);
+            }
+            console.log('');
+            this.conversationHistory.push({ role: 'assistant', content });
+            this._promptUser();
+        });
+        // Confirmation request from agent
+        this.client.on('confirmation_request', async (req) => {
+            await this._handleConfirmationDialog(req);
+        });
+        // Task updates
+        this.client.on('task_update', (task) => {
+            if (task.status === 'RUNNING') {
+                this.activeTaskId = task.task_id || null;
+            }
+        });
+    }
+    async _handleConfirmationDialog(req) {
+        console.log(`\n${(0, colors_1.YELLOW_BOLD)('⚠️  CONFIRMACIÓN DE ACCIÓN REQUERIDA')}`);
+        console.log(`  Acción:      ${chalk_1.default.white.bold(req.action || req.tool || 'Acción del sistema')}`);
+        if (req.description) {
+            console.log(`  Descripción: ${(0, colors_1.DIM)(req.description)}`);
+        }
+        if (req.arguments && Object.keys(req.arguments).length > 0) {
+            console.log(`  Parámetros:  ${(0, colors_1.GRAY)(JSON.stringify(req.arguments))}`);
+        }
+        const answer = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'confirmed',
+            message: '¿Permitir al agente ejecutar esta acción?',
+            initial: true,
+        });
+        const reqId = req.request_id || req.id || '';
+        if (answer.confirmed) {
+            this.client.confirmAction(reqId);
+            console.log((0, colors_1.GREEN)('  ✔ Acción confirmada.\n'));
+        }
+        else {
+            this.client.rejectAction(reqId);
+            console.log((0, colors_1.RED)('  ✖ Acción rechazada.\n'));
+        }
+        this._promptUser();
+    }
+    _startReadline() {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            completer: (line) => this.autocompleter.completer(line),
+            terminal: true,
+        });
+        this.rl = rl;
+        rl.on('line', async (line) => {
+            await this._handleInputLine(line.trim());
+        });
+        rl.on('close', () => {
+            console.log((0, colors_1.DIM)('\nCerrando sesión de HELIX CLI...'));
+            this.client.close();
+            process.exit(0);
+        });
+        // Ctrl+C handling: Cancel active task if running, or exit
+        rl.on('SIGINT', () => {
+            if (this.isProcessingPrompt && this.activeTaskId) {
+                console.log((0, colors_1.YELLOW)('\n[!] Cancelando tarea activa...'));
+                this.client.cancelTask(this.activeTaskId);
+                this.isProcessingPrompt = false;
+                this.activeTaskId = null;
+                this._promptUser();
+            }
+            else {
+                console.log((0, colors_1.DIM)('\n¡Hasta pronto!'));
+                this.client.close();
+                process.exit(0);
+            }
+        });
+        this._promptUser();
+    }
+    _promptUser() {
+        if (!this.rl)
+            return;
+        const promptPrefix = `  ${chalk_1.default.hex('#FF8C00').bold('helix')} ${chalk_1.default.gray('❯')} `;
+        this.rl.setPrompt(promptPrefix);
+        this.rl.prompt();
+    }
+    async _handleInputLine(line) {
+        if (!line) {
+            this._promptUser();
+            return;
+        }
+        if (this.client.isStarting) {
+            console.log(`\n  ${chalk_1.default.yellow('⚠️')}  ${chalk_1.default.yellowBright('El servicio de HELIX se está iniciando en segundo plano. Espera a que termine antes de enviar comandos o reintentar.')}\n`);
+            this._promptUser();
+            return;
+        }
+        // --- Slash commands handling ---
+        if (line.startsWith('/')) {
+            const parts = line.split(/\s+/);
+            const cmd = parts[0].toLowerCase();
+            const args = line.slice(cmd.length).trim();
+            switch (cmd) {
+                case '/help':
+                    this.autocompleter.renderHelp();
+                    break;
+                case '/clear':
+                    this.refreshBanner(true);
+                    break;
+                case '/config-apikey':
+                    this.rl?.pause();
+                    await (0, apikey_1.handleConfigApiKey)(this.client);
+                    this.rl?.resume();
+                    break;
+                case '/show-apikey':
+                    await (0, apikey_1.handleShowApiKey)(this.client);
+                    break;
+                case '/skill':
+                    await (0, skills_1.handleListSkills)(this.client, args || undefined);
+                    break;
+                case '/create-skill':
+                    this.rl?.pause();
+                    await (0, skills_1.handleCreateSkill)(this.client);
+                    await this.autocompleter.refreshSuggestions();
+                    this.rl?.resume();
+                    break;
+                case '/mcp':
+                    await (0, mcp_1.handleListMcp)(this.client);
+                    break;
+                case '/create-mcp':
+                    this.rl?.pause();
+                    await (0, mcp_1.handleCreateMcp)(this.client);
+                    await this.autocompleter.refreshSuggestions();
+                    this.rl?.resume();
+                    break;
+                case '/microphone': {
+                    const newState = await (0, mic_1.handleMicrophoneCommand)(this.client, args, this.voiceEnabled);
+                    this.voiceEnabled = newState;
+                    break;
+                }
+                case '/browser':
+                    await (0, browser_1.handleBrowserCommand)(this.client, args);
+                    break;
+                case '/tasks':
+                    await this._handleListTasks();
+                    break;
+                case '/models':
+                    await this._handleListModels();
+                    break;
+                case '/status':
+                    await this._handleStatus();
+                    break;
+                case '/stop':
+                    console.log((0, colors_1.RED_BOLD)('\n[PARADA DE EMERGENCIA]: Cancelando todas las tareas activas...'));
+                    this.client.emergencyStop();
+                    this.isProcessingPrompt = false;
+                    this.activeTaskId = null;
+                    console.log((0, colors_1.GREEN)('✔ Todas las tareas han sido detenidas.\n'));
+                    break;
+                case '/exit':
+                case '/quit':
+                    this.client.close();
+                    process.exit(0);
+                    break;
+                default:
+                    console.log((0, colors_1.YELLOW)(`Comando desconocido: "${cmd}". Escribe /help para ver la lista de comandos.`));
+                    break;
+            }
+            this._promptUser();
+            return;
+        }
+        // --- Direct chat message / @skill / #mcp ---
+        if (!this.client.connected) {
+            console.log((0, colors_1.YELLOW)('⚠ El agente no está conectado actualmente. Intentando enviar de todos modos...'));
+        }
+        // Highlight skills in strong orange (#FF8C00) and mcps in cyan
+        const knownSkills = this.autocompleter.getSkills();
+        const formattedEcho = (0, colors_1.highlightMentions)(line, knownSkills);
+        // Record user message in history
+        this.conversationHistory.push({ role: 'user', content: line });
+        this.isProcessingPrompt = true;
+        this.activeTasksCount++;
+        process.stdout.write(`  ${chalk_1.default.gray('→')} ${formattedEcho}\n`);
+        process.stdout.write(`  ${chalk_1.default.hex('#FF9F1C')('◆')} ${chalk_1.default.gray('Procesando...')}`);
+        const sent = this.client.sendUserText(line, this.conversationId, this.conversationHistory.slice(-10));
+        if (!sent) {
+            process.stdout.write('\r\x1b[K');
+            console.log((0, colors_1.RED)('✖ Error: No se pudo enviar el mensaje (WebSocket desconectado).'));
+            this.isProcessingPrompt = false;
+            this.activeTasksCount = Math.max(0, this.activeTasksCount - 1);
+            this._promptUser();
+        }
+    }
+    async _handleListTasks() {
+        try {
+            const tasks = await this.client.getTasks();
+            console.log(`\n${(0, colors_1.BOLD)('📋 Tareas Registradas en HELIX:')}\n`);
+            if (!tasks || tasks.length === 0) {
+                console.log((0, colors_1.GRAY)('  No hay tareas recientes registradas.\n'));
+                return;
+            }
+            for (const t of tasks.slice(-10)) {
+                let statusBadge = chalk_1.default.gray(t.status);
+                if (t.status === 'COMPLETED')
+                    statusBadge = chalk_1.default.green('✔ Completada');
+                if (t.status === 'RUNNING')
+                    statusBadge = chalk_1.default.yellow('⏳ En ejecución');
+                if (t.status === 'FAILED')
+                    statusBadge = chalk_1.default.red('✖ Fallida');
+                if (t.status === 'CANCELLED')
+                    statusBadge = chalk_1.default.gray('○ Cancelada');
+                console.log(`  ${statusBadge} ${(0, colors_1.DIM)(t.task_id)}`);
+                if (t.prompt)
+                    console.log(`    ${chalk_1.default.white(t.prompt)}`);
+                console.log('');
+            }
+        }
+        catch (err) {
+            console.log((0, colors_1.RED)(`  Error al obtener tareas: ${err.message}\n`));
+        }
+    }
+    async _handleListModels() {
+        try {
+            const models = await this.client.getModels();
+            console.log(`\n${(0, colors_1.BOLD)('🧠 Modelos Disponibles en Proveedores Configurados:')}\n`);
+            if (!models || models.length === 0) {
+                console.log((0, colors_1.GRAY)('  No hay modelos disponibles. Configura tus API Keys con /config-apikey.\n'));
+                return;
+            }
+            for (const m of models) {
+                console.log(`  ${(0, colors_1.CYAN)('•')} ${chalk_1.default.bold(m.id)} ${(0, colors_1.DIM)(`[${m.provider}]`)}`);
+            }
+            console.log('');
+        }
+        catch (err) {
+            console.log((0, colors_1.RED)(`  Error al obtener modelos: ${err.message}\n`));
+        }
+    }
+    async _handleStatus() {
+        console.log('');
+        console.log(`  ${chalk_1.default.hex('#FF8C00').bold('⬡ Estado del Sistema')}`);
+        console.log(`  ${chalk_1.default.gray('─'.repeat(40))}`);
+        console.log(`  ${chalk_1.default.gray('Agente WS')}     ${this.client.connected ? chalk_1.default.green('● Conectado') : chalk_1.default.red('● Desconectado')} ${chalk_1.default.gray(this.client.url)}`);
+        console.log(`  ${chalk_1.default.gray('Micrófono')}     ${this.voiceEnabled ? chalk_1.default.green('● Activo') + chalk_1.default.gray(' (hey helix)') : chalk_1.default.red('● Inactivo')}`);
+        console.log(`  ${chalk_1.default.gray('Conversación')}  ${chalk_1.default.gray(this.conversationId)} ${chalk_1.default.gray(`(${this.conversationHistory.length} msgs)`)}`);
+        console.log(`  ${chalk_1.default.gray('Skills')}        ${chalk_1.default.hex('#FF8C00').bold(this.autocompleter.getSkills().length.toString())} registradas`);
+        console.log(`  ${chalk_1.default.gray('MCP Tools')}     ${chalk_1.default.cyan.bold(this.autocompleter.getMcpTools().length.toString())} disponibles`);
+        console.log('');
+    }
+}
+exports.HelixRepl = HelixRepl;

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "helix-assistant-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "HELIX - Interactive Terminal CLI for Windows AI Desktop Agent",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "helix": "bin/helix.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -w -p tsconfig.json",
+    "start": "node dist/index.js",
+    "test": "node --test --require ts-node/register/transpile-only tests/cli.test.ts"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
+    "prompts": "^2.4.2",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/prompts": "^2.4.9",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.0"
+  }
+}