helix-assistant-cli 0.0.0-stage → 0.2.1

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,139 @@
+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';
+
+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')
+  .action(async (promptText: string) => {
+    const opts = program.opts();
+    const client = new AgentClient({
+      wsUrl: opts.wsUrl || getWsUrl(),
+      wsToken: opts.token || getWsToken(),
+      autoReconnect: false,
+    });
+
+    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);
+    }
+
+    console.log(DIM(`Prompt: ${promptText}\n`));
+    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);

package/src/ui/autocomplete.ts

@@ -0,0 +1,153 @@
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import { formatSkill, formatMcp, ORANGE, CYAN, MAGENTA, DIM } from './colors';
+
+export interface CommandDefinition {
+  command: string;
+  description: string;
+  usage?: string;
+}
+
+export const SLASH_COMMANDS: CommandDefinition[] = [
+  { command: '/create-skill', description: 'Crear una nueva skill interactiva para HELIX' },
+  { command: '/skill', description: 'Listar o inspeccionar skills registradas', usage: '/skill [nombre]' },
+  { command: '/mcp', description: 'Listar servidores MCP y sus herramientas' },
+  { command: '/create-mcp', description: 'Registrar y configurar un nuevo servidor MCP' },
+  { command: '/browser', description: 'Ver estado del navegador web o abrir URLs', usage: '/browser [open <url>]' },
+  { command: '/config-apikey', description: 'Configurador interactivo de API Keys (OpenAI, Anthropic, Gemini, etc.)' },
+  { command: '/show-apikey', description: 'Ver estado y validez de las API Keys configuradas' },
+  { command: '/microphone', description: 'Ver o alternar estado del micrófono', usage: '/microphone [enable|disable]' },
+  { command: '/tasks', description: 'Ver tareas activas y recientes del agente' },
+  { command: '/models', description: 'Listar modelos disponibles de proveedores configurados' },
+  { command: '/status', description: 'Mostrar resumen del estado del sistema' },
+  { command: '/clear', description: 'Limpiar pantalla y restaurar el banner de HELIX' },
+  { command: '/stop', description: 'Parada de emergencia de todas las tareas activas' },
+  { command: '/help', description: 'Mostrar ayuda de comandos y atajos' },
+  { command: '/exit', description: 'Salir del CLI' },
+];
+
+export class Autocompleter {
+  private skills: string[] = [];
+  private mcpTools: string[] = [];
+
+  constructor(private client?: AgentClient) {}
+
+  public async refreshSuggestions(): Promise<void> {
+    if (!this.client || !this.client.connected) return;
+    try {
+      const skills = await this.client.getSkills();
+      if (skills) {
+        this.skills = skills.map((s) => s.name);
+      }
+    } catch {
+      // Ignored if client is offline
+    }
+
+    try {
+      const servers = await this.client.getMcpServers();
+      if (servers) {
+        const tools: string[] = [];
+        for (const s of servers) {
+          tools.push(s.name);
+          if (s.tools) {
+            for (const t of s.tools) {
+              tools.push(`${s.name}_${t.name}`);
+            }
+          }
+        }
+        this.mcpTools = tools;
+      }
+    } catch {
+      // Ignored
+    }
+  }
+
+  public getSkills(): string[] {
+    return this.skills;
+  }
+
+  public getMcpTools(): string[] {
+    return this.mcpTools;
+  }
+
+  /**
+   * Completer function matching readline specification:
+   * (line: string) => [string[], string]
+   */
+  public completer(line: string): [string[], string] {
+    const trimmed = line.trimStart();
+
+    // 1. Skill sub-arguments for /skill <name>
+    if (trimmed.startsWith('/skill ')) {
+      const arg = trimmed.slice('/skill '.length).toLowerCase();
+      const hits = this.skills
+        .filter((s) => s.toLowerCase().startsWith(arg))
+        .map((s) => `/skill ${s}`);
+      return [hits.length ? hits : this.skills.map((s) => `/skill ${s}`), line];
+    }
+
+    // 2. Microphone sub-arguments
+    if (trimmed.startsWith('/microphone ')) {
+      const arg = trimmed.slice('/microphone '.length).toLowerCase();
+      const options = ['/microphone enable', '/microphone disable'];
+      const hits = options.filter((o) => o.toLowerCase().startsWith(trimmed.toLowerCase()));
+      return [hits.length ? hits : options, line];
+    }
+
+    // 3. Browser sub-arguments
+    if (trimmed.startsWith('/browser ')) {
+      const options = ['/browser open https://'];
+      return [options, line];
+    }
+
+    // 4. Slash command autocompletion
+    if (trimmed.startsWith('/')) {
+      const hits = SLASH_COMMANDS
+        .map((c) => c.command)
+        .filter((c) => c.toLowerCase().startsWith(trimmed.toLowerCase()));
+      return [hits.length ? hits : SLASH_COMMANDS.map((c) => c.command), line];
+    }
+
+    // 5. In-line @skill mention autocompletion
+    const lastAtMatch = /(?:^|\s)(@)([a-zA-Z0-9_-]*)$/.exec(line);
+    if (lastAtMatch) {
+      const prefix = line.slice(0, line.length - lastAtMatch[2].length);
+      const query = lastAtMatch[2].toLowerCase();
+      const matches = this.skills.filter((s) => s.toLowerCase().startsWith(query));
+      const hits = (matches.length ? matches : this.skills).map((s) => `${prefix}${s} `);
+      return [hits, line];
+    }
+
+    // 6. In-line #mcp mention autocompletion
+    const lastHashMatch = /(?:^|\s)(#)([a-zA-Z0-9_-]*)$/.exec(line);
+    if (lastHashMatch) {
+      const prefix = line.slice(0, line.length - lastHashMatch[2].length);
+      const query = lastHashMatch[2].toLowerCase();
+      const matches = this.mcpTools.filter((t) => t.toLowerCase().startsWith(query));
+      const hits = (matches.length ? matches : this.mcpTools).map((t) => `${prefix}${t} `);
+      return [hits, line];
+    }
+
+    return [[], line];
+  }
+
+  /**
+   * Formats the list of commands for display.
+   */
+  public renderHelp(): void {
+    console.log('');
+    console.log(`  ${chalk.hex('#FF8C00').bold('⬡ Comandos Disponibles')}  ${chalk.gray('(/ + [Tab] para autocompletar)')}`);
+    console.log(`  ${chalk.gray('─'.repeat(50))}`);
+    for (const cmd of SLASH_COMMANDS) {
+      const usage = cmd.usage ? `  ${chalk.gray(cmd.usage)}` : '';
+      console.log(`  ${chalk.magenta(cmd.command.padEnd(16))} ${chalk.gray(cmd.description)}${usage}`);
+    }
+
+    console.log('');
+    console.log(`  ${chalk.hex('#FF8C00').bold('⬡ Prefijos Especiales')}`);
+    console.log(`  ${chalk.gray('─'.repeat(50))}`);
+    console.log(`  ${formatSkill('nombre')}            ${chalk.gray('Invoca una skill registrada')}`);
+    console.log(`  ${formatMcp('herramienta')}       ${chalk.gray('Invoca herramientas MCP')}`);
+    console.log('');
+  }
+}