helix-assistant-cli 0.0.0-stage → 0.2.4

package/src/commands/mcp.ts

@@ -0,0 +1,105 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import type { McpServerConfig } from '../client/types';
+import { formatMcp, CYAN_BOLD, GREEN, RED, YELLOW, GRAY, BOLD, DIM } from '../ui/colors';
+
+export async function handleListMcp(client: AgentClient): Promise<void> {
+  console.log(`\n${BOLD('🔌 Servidores y Herramientas MCP:')}\n`);
+
+  try {
+    const servers = await client.getMcpServers();
+    if (!servers || servers.length === 0) {
+      console.log(GRAY('  No hay servidores MCP configurados actualmente.'));
+      console.log(DIM('  Usa /create-mcp para configurar uno nuevo.\n'));
+      return;
+    }
+
+    for (const server of servers) {
+      let statusBadge = chalk.gray('idle');
+      if (server.status === 'connected') {
+        statusBadge = chalk.green('● Conectado');
+      } else if (server.status === 'connecting') {
+        statusBadge = chalk.yellow('⏳ Conectando');
+      } else if (server.status === 'error') {
+        statusBadge = chalk.red('✖ Error');
+      }
+
+      console.log(`  ${CYAN_BOLD('◈')} ${formatMcp(server.name)}  [${statusBadge}]`);
+      console.log(`    ${GRAY('Comando:')} ${chalk.white(server.command)}`);
+      if (server.error) {
+        console.log(`    ${RED('Error:')} ${server.error}`);
+      }
+      if (server.tools && server.tools.length > 0) {
+        console.log(`    ${DIM('Herramientas provistas:')}`);
+        for (const tool of server.tools) {
+          console.log(`      ${DIM('•')} ${formatMcp(tool.name)}${tool.description ? DIM(` - ${tool.description}`) : ''}`);
+        }
+      }
+      console.log('');
+    }
+  } catch (err) {
+    console.log(RED(`  Error al obtener servidores MCP: ${(err as Error).message}\n`));
+  }
+}
+
+export async function handleCreateMcp(client: AgentClient): Promise<void> {
+  console.log(`\n${BOLD('⚙️  Registrar Nuevo Servidor MCP')}\n`);
+
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'name',
+      message: 'Nombre identificador del servidor MCP (ej. filesystem, github, fetch):',
+      validate: (v: string) =>
+        /^[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: string) => (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(YELLOW('\nOperación cancelada.\n'));
+    return;
+  }
+
+  const envObj: Record<string, string> = {};
+  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 as McpServerConfig[]) || [];
+
+    // 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(GRAY(`\nGuardando servidor MCP ${formatMcp(answers.name)}...`));
+    await client.saveSettings({ mcp_servers: updatedServers });
+
+    console.log(GREEN(`✔ ¡Servidor MCP ${formatMcp(answers.name)} registrado con éxito!`));
+    console.log(DIM(`  HELIX sincronizará las herramientas automáticamente.\n`));
+  } catch (err) {
+    console.log(RED(`✖ Error al registrar servidor MCP: ${(err as Error).message}\n`));
+  }
+}

package/src/commands/mic.ts

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import { GREEN, RED, YELLOW, GRAY, BOLD, DIM } from '../ui/colors';
+
+export async function handleMicrophoneCommand(
+  client: AgentClient,
+  action?: string,
+  currentVoiceState: boolean = true
+): Promise<boolean> {
+  const normalizedAction = action?.toLowerCase().trim();
+
+  if (normalizedAction === 'enable' || normalizedAction === 'on' || normalizedAction === 'true') {
+    try {
+      console.log(GRAY('\nActivando micrófono en el agente HELIX...'));
+      await client.saveSettings({ voice_enabled: true });
+      console.log(`${GREEN('🟢 Micrófono:')} ${chalk.greenBright.bold('ACTIVO')} ${DIM('(Escuchando wake word: "hey helix").')}\n`);
+      return true;
+    } catch (err) {
+      console.log(RED(`✖ Error al activar micrófono: ${(err as Error).message}\n`));
+      return currentVoiceState;
+    }
+  }
+
+  if (normalizedAction === 'disable' || normalizedAction === 'off' || normalizedAction === 'false') {
+    try {
+      console.log(GRAY('\nDesactivando micrófono en el agente HELIX...'));
+      await client.saveSettings({ voice_enabled: false });
+      console.log(`${RED('🔴 Micrófono:')} ${chalk.redBright.bold('INACTIVO')} ${DIM('(Entrada por voz deshabilitada).')}\n`);
+      return false;
+    } catch (err) {
+      console.log(RED(`✖ Error al desactivar micrófono: ${(err as Error).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 as string) || 'hey helix';
+
+    console.log(`\n${BOLD('🎤 Estado del Micrófono y Reconocimiento de Voz:')}\n`);
+    if (isEnabled) {
+      console.log(`  Estado:      ${GREEN('🟢 ACTIVO')}`);
+      console.log(`  Wake Word:   ${chalk.cyan.bold(`"${wakeWord}"`)}`);
+      console.log(`  Detalles:    El agente procesará tu voz al decir "${wakeWord}".`);
+    } else {
+      console.log(`  Estado:      ${RED('🔴 INACTIVO')}`);
+      console.log(`  Detalles:    La captura de voz está desactivada.`);
+    }
+    console.log(`\n  ${DIM('Uso: /microphone enable | /microphone disable')}\n`);
+    return isEnabled;
+  } catch (err) {
+    console.log(RED(`  Error al consultar configuración de voz: ${(err as Error).message}\n`));
+    return currentVoiceState;
+  }
+}

package/src/commands/skills.ts

@@ -0,0 +1,109 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import { formatSkill, ORANGE_BOLD, GREEN, RED, YELLOW, GRAY, BOLD, DIM } from '../ui/colors';
+
+export async function handleListSkills(client: AgentClient, specificSkill?: string): Promise<void> {
+  try {
+    const skills = await client.getSkills();
+    if (!skills || skills.length === 0) {
+      console.log(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${BOLD('Detalles de la Skill:')}`);
+        console.log(`  Nombre:       ${formatSkill(match.name)}`);
+        console.log(`  Descripción:  ${chalk.white(match.description || 'Sin descripción')}`);
+        if (match.triggers && match.triggers.length > 0) {
+          console.log(`  Disparadores: ${DIM(match.triggers.join(', '))}`);
+        }
+        if (match.instructions) {
+          console.log(`  Instrucciones:\n${GRAY('    ' + match.instructions.replace(/\n/g, '\n    '))}`);
+        }
+        console.log('');
+        return;
+      }
+      console.log(YELLOW(`\n  Skill "${specificSkill}" no encontrada. Listando todas las disponibles:\n`));
+    }
+
+    console.log(`\n${BOLD('⚡ Skills Registradas en HELIX:')}\n`);
+    for (const skill of skills) {
+      const nameTag = formatSkill(skill.name);
+      const isCustom = skill.custom ? chalk.hex('#FFA500')(' [custom]') : '';
+      console.log(`  ${ORANGE_BOLD('✦')} ${nameTag}${isCustom}`);
+      if (skill.description) {
+        console.log(`    ${DIM(skill.description)}`);
+      }
+      if (skill.triggers && skill.triggers.length > 0) {
+        console.log(`    ${GRAY('Triggers:')} ${DIM(skill.triggers.slice(0, 4).join(', '))}`);
+      }
+      console.log('');
+    }
+  } catch (err) {
+    console.log(RED(`  Error al obtener skills: ${(err as Error).message}\n`));
+  }
+}
+
+export async function handleCreateSkill(client: AgentClient): Promise<void> {
+  console.log(`\n${BOLD('🛠️  Crear Nueva Skill en HELIX')}\n`);
+
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'name',
+      message: 'Nombre de la skill (ej. web-summarizer, code-auditor):',
+      validate: (v: string) =>
+        /^[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: string) => (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: string) => (v && v.trim() ? true : 'Las instrucciones son requeridas'),
+    },
+  ]);
+
+  if (!answers.name || !answers.description || !answers.instructions) {
+    console.log(YELLOW('\nOperación cancelada.\n'));
+    return;
+  }
+
+  const triggersList = typeof answers.triggers === 'string'
+    ? answers.triggers.split(',').map((t: string) => t.trim()).filter(Boolean)
+    : [];
+
+  const skillPayload = {
+    name: answers.name.trim(),
+    description: answers.description.trim(),
+    triggers: triggersList,
+    instructions: answers.instructions.trim(),
+  };
+
+  try {
+    console.log(GRAY(`\nGuardando skill ${formatSkill(skillPayload.name)}...`));
+    await client.saveSkill(skillPayload);
+    console.log(GREEN(`✔ ¡Skill ${formatSkill(skillPayload.name)} creada con éxito!`));
+    console.log(DIM(`  Puedes invocarla usando: ${formatSkill(skillPayload.name)} <tu consulta>\n`));
+  } catch (err) {
+    console.log(RED(`✖ Error al crear la skill: ${(err as Error).message}\n`));
+  }
+}

package/src/config/env.ts

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

package/src/index.ts

@@ -0,0 +1,208 @@
+// ═══════════════════════════════════════════════════════════════
+// 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
+  }
+}
+
+import fs from 'node:fs';
+import { Command } from 'commander';
+import { HelixRepl } from './ui/repl';
+import { getWsUrl, getWsToken } from './config/env';
+import { AgentClient } from './client/agent-client';
+import type { HelixSettings } from './client/types';
+import { handleShowApiKey } from './commands/apikey';
+import { ORANGE, CYAN, GREEN, RED, BOLD, DIM } from './ui/colors';
+import { getAsciiLogo } from './ui/banner';
+
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) {
+    return '';
+  }
+  return new Promise((resolve) => {
+    let input = '';
+    const onData = (chunk: Buffer | string) => {
+      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 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', getWsUrl())
+  .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', getWsToken())
+  .action(async (options) => {
+    // Default action: start interactive chat REPL
+    const repl = new HelixRepl({
+      wsUrl: options.wsUrl || getWsUrl(),
+      wsToken: options.token || 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 HelixRepl({
+      wsUrl: opts.wsUrl || getWsUrl(),
+      wsToken: opts.token || 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: string[]) => {
+    let promptText = (promptParts || []).join(' ').trim();
+    if (!promptText || promptText === '-') {
+      promptText = await readStdin();
+    }
+    if (!promptText) {
+      console.error(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 AgentClient({
+      wsUrl: opts.wsUrl || getWsUrl(),
+      wsToken: opts.token || getWsToken(),
+      autoReconnect: false,
+    });
+
+    console.log(DIM(`Prompt: ${promptText}\n`));
+    console.log(CYAN(`Conectando con HELIX en ${client.url}...`));
+    try {
+      await client.connect();
+    } catch (err) {
+      console.error(RED(`No se pudo conectar al agente HELIX: ${(err as Error).message}`));
+      process.exit(1);
+    }
+
+    const convId = `cli_run_${Date.now()}`;
+
+    client.on('react_step', (step: { iteration?: number }) => {
+      process.stdout.write(`\r${DIM(`[ReAct Step ${step?.iteration || 1}...]`)}`);
+    });
+
+    client.on('agent_message', (payload: { content?: string }) => {
+      process.stdout.write('\r\x1b[K');
+      console.log(payload?.content || '');
+      client.close();
+      process.exit(0);
+    });
+
+    client.sendUserText(promptText, convId);
+
+    // Timeout safety
+    setTimeout(() => {
+      console.error(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 AgentClient({
+      wsUrl: opts.wsUrl || getWsUrl(),
+      wsToken: opts.token || getWsToken(),
+      autoReconnect: false,
+    });
+
+    console.log(getAsciiLogo());
+    console.log(BOLD('Consultando estado de HELIX...\n'));
+
+    try {
+      await client.connect();
+      console.log(`  ${GREEN('● Conectado')} al agente en ${client.url}`);
+
+      const [settings, skills, mcpServers] = await Promise.all([
+        client.getSettings().catch(() => ({} as HelixSettings)),
+        client.getSkills().catch(() => []),
+        client.getMcpServers().catch(() => []),
+      ]);
+
+      const micStatus = settings.voice_enabled !== false ? GREEN('🟢 Activo') : RED('🔴 Inactivo');
+      console.log(`  Micrófono:   ${micStatus}`);
+      console.log(`  Skills:      ${ORANGE(skills.length.toString())} registradas`);
+      console.log(`  MCP Servers: ${CYAN(mcpServers.length.toString())} configurados`);
+      console.log('');
+      client.close();
+    } catch (err) {
+      console.log(`  ${RED('● Desconectado')} del agente en ${client.url}`);
+      console.log(DIM(`  Detalle: ${(err as Error).message}\n`));
+    }
+  });
+
+program
+  .command('apikeys')
+  .description('Mostrar el estado de las claves API configuradas')
+  .action(async () => {
+    const opts = program.opts();
+    const client = new AgentClient({
+      wsUrl: opts.wsUrl || getWsUrl(),
+      wsToken: opts.token || getWsToken(),
+      autoReconnect: false,
+    });
+
+    try {
+      await client.connect();
+      await handleShowApiKey(client);
+    } catch (err) {
+      console.error(RED(`Error de conexión con el agente: ${(err as Error).message}`));
+    } finally {
+      client.close();
+    }
+  });
+
+program.parse(process.argv);