helix-assistant-cli 0.2.1 → 0.2.7

package/src/ui/markdown.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+
+/**
+ * Formats Markdown text for optimal display in terminal emulators,
+ * resolving visual noise from unparsed asterisks (*, **) and headers.
+ */
+export function formatTerminalMarkdown(content: string, plain = false): string {
+  if (!content) return '';
+
+  const lines = content.split('\n');
+  const formattedLines = lines.map((line) => {
+    let formatted = line;
+
+    // Headers (#, ##, ###)
+    const headerMatch = formatted.match(/^(#{1,6})\s+(.*)$/);
+    if (headerMatch) {
+      const title = headerMatch[2].trim();
+      if (plain) {
+        return title.toUpperCase();
+      }
+      return chalk.hex('#FF9F1C').bold(title);
+    }
+
+    // Bullet lists (* item, - item)
+    if (/^\s*[*+-]\s+/.test(formatted)) {
+      formatted = formatted.replace(/^(\s*)[*+-]\s+/, (_m, indent) => {
+        return plain ? `${indent}- ` : `${indent}${chalk.hex('#FF8C00')('•')} `;
+      });
+    }
+
+    // Inline bold (**text** or __text__)
+    formatted = formatted.replace(/(\*\*|__)(.*?)\1/g, (_m, _delim, text) => {
+      return plain ? text : chalk.bold(text);
+    });
+
+    // Inline italics (*text* or _text_)
+    formatted = formatted.replace(/(?<!\*)\*([^*]+)\*(?!\*)|(?<!_)_([^_]+)_(?!_)/g, (_m, t1, t2) => {
+      const text = t1 || t2;
+      return plain ? text : chalk.whiteBright(text);
+    });
+
+    // Inline code (`code`)
+    formatted = formatted.replace(/`([^`]+)`/g, (_m, code) => {
+      return plain ? code : chalk.cyan(code);
+    });
+
+    return formatted;
+  });
+
+  return formattedLines.join('\n');
+}

package/src/ui/repl.ts

@@ -25,10 +25,12 @@ import { handleCreateMcp, handleListMcp } from '../commands/mcp';
 import { handleMicrophoneCommand } from '../commands/mic';
 import { handleBrowserCommand } from '../commands/browser';
 import type { ConfirmationRequest } from '../client/types';
+import { formatTerminalMarkdown } from './markdown';
 
 export interface ReplOptions {
   wsUrl: string;
   wsToken?: string;
+  plain?: boolean;
 }
 
 export class HelixRepl {
@@ -43,9 +45,11 @@ export class HelixRepl {
   private activeTaskId: string | null = null;
   private activeTasksCount: number = 0;
   private isProcessingPrompt: boolean = false;
+  private plain: boolean = false;
 
   constructor(private options: ReplOptions) {
     this.conversationId = `cli_conv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+    this.plain = Boolean(options.plain);
     this.client = new AgentClient({
       wsUrl: options.wsUrl,
       wsToken: options.wsToken,
@@ -148,7 +152,7 @@ export class HelixRepl {
     // Voice Capture indicator
     this.client.on('voice_capture_started', () => {
       this.isCapturingVoice = true;
-      process.stdout.write(`\n${chalk.bgRed.white.bold(' 🎙️  [VOZ DETECTADA - HEY HELIX]: Capturando audio... ')}\n`);
+      process.stdout.write(`\n${chalk.bgRed.white.bold(' 🎙️   [VOZ DETECTADA - HEY HELIX]: Capturando audio... ')}\n`);
     });
 
     this.client.on('voice_capture_stopped', () => {
@@ -182,8 +186,9 @@ export class HelixRepl {
       console.log('');
       console.log(`  ${chalk.hex('#FF8C00').bold('⬡ HELIX')}${modelBadge}`);
 
-      // Content with subtle left border
-      const contentLines = content.trim().split('\n');
+      // Content with subtle left border and clean Markdown formatting
+      const formatted = formatTerminalMarkdown(content, this.plain);
+      const contentLines = formatted.trim().split('\n');
       for (const line of contentLines) {
         console.log(`  ${chalk.gray('│')} ${line}`);
       }
@@ -207,7 +212,7 @@ export class HelixRepl {
   }
 
   private async _handleConfirmationDialog(req: ConfirmationRequest): Promise<void> {
-    console.log(`\n${YELLOW_BOLD('⚠️  CONFIRMACIÓN DE ACCIÓN REQUERIDA')}`);
+    console.log(`\n${YELLOW_BOLD('⚠️   CONFIRMACIÓN DE ACCIÓN REQUERIDA')}`);
     console.log(`  Acción:      ${chalk.white.bold(req.action || req.tool || 'Acción del sistema')}`);
     if (req.description) {
       console.log(`  Descripción: ${DIM(req.description)}`);
@@ -216,31 +221,44 @@ export class HelixRepl {
       console.log(`  Parámetros:  ${GRAY(JSON.stringify(req.arguments))}`);
     }
 
-    const answer = await prompts({
-      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(GREEN('  ✔ Acción confirmada.\n'));
-    } else {
-      this.client.rejectAction(reqId);
-      console.log(RED('  ✖ Acción rechazada.\n'));
+    this.rl?.pause();
+    try {
+      const answer = await prompts({
+        type: 'confirm',
+        name: 'confirmed',
+        message: '¿Permitir al agente ejecutar esta acción?',
+        initial: true,
+      });
+
+      const reqId = req.request_id || req.id || '';
+      if (answer && answer.confirmed) {
+        this.client.confirmAction(reqId);
+        console.log(GREEN('  ✔ Acción confirmada.\n'));
+      } else {
+        this.client.rejectAction(reqId);
+        console.log(RED('  ✖ Acción rechazada.\n'));
+      }
+    } finally {
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        try {
+          process.stdin.setRawMode(false);
+        } catch {}
+      }
+      this.rl?.resume();
+      this._promptUser();
     }
-
-    this._promptUser();
   }
 
   private _startReadline(): void {
+    if (process.stdin.setEncoding) {
+      process.stdin.setEncoding('utf-8');
+    }
+    const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
       completer: (line: string) => this.autocompleter.completer(line),
-      terminal: true,
+      terminal: isInteractive,
     });
 
     this.rl = rl;
@@ -309,8 +327,14 @@ export class HelixRepl {
 
         case '/config-apikey':
           this.rl?.pause();
-          await handleConfigApiKey(this.client);
-          this.rl?.resume();
+          try {
+            await handleConfigApiKey(this.client);
+          } finally {
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+              try { process.stdin.setRawMode(false); } catch {}
+            }
+            this.rl?.resume();
+          }
           break;
 
         case '/show-apikey':
@@ -323,9 +347,15 @@ export class HelixRepl {
 
         case '/create-skill':
           this.rl?.pause();
-          await handleCreateSkill(this.client);
-          await this.autocompleter.refreshSuggestions();
-          this.rl?.resume();
+          try {
+            await handleCreateSkill(this.client);
+            await this.autocompleter.refreshSuggestions();
+          } finally {
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+              try { process.stdin.setRawMode(false); } catch {}
+            }
+            this.rl?.resume();
+          }
           break;
 
         case '/mcp':
@@ -334,9 +364,15 @@ export class HelixRepl {
 
         case '/create-mcp':
           this.rl?.pause();
-          await handleCreateMcp(this.client);
-          await this.autocompleter.refreshSuggestions();
-          this.rl?.resume();
+          try {
+            await handleCreateMcp(this.client);
+            await this.autocompleter.refreshSuggestions();
+          } finally {
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+              try { process.stdin.setRawMode(false); } catch {}
+            }
+            this.rl?.resume();
+          }
           break;
 
         case '/microphone': {

package/tests/cli.test.ts

@@ -3,6 +3,10 @@ import assert from 'node:assert/strict';
 import { Autocompleter, SLASH_COMMANDS } from '../src/ui/autocomplete';
 import { formatSkill, formatMcp, highlightMentions, ORANGE } from '../src/ui/colors';
 import { getAsciiLogo, getStatusBar, getVoiceIndicator } from '../src/ui/banner';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { discoverUserSkillNames } from '../src/skills/user-skill-discovery';
 
 test('Autocompleter suggests slash commands', () => {
   const completer = new Autocompleter();
@@ -68,6 +72,42 @@ test('Autocompleter handles @skills and #mcps autocompletion', () => {
   assert.deepEqual(skillSub, ['/skill web-search']);
 });
 
+test('User skill discovery is shallow, dynamic, and metadata-only', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'helix-cli-skills-'));
+  try {
+    fs.mkdirSync(path.join(root, 'meeting-notes'));
+    fs.writeFileSync(
+      path.join(root, 'meeting-notes', 'SKILL.md'),
+      '---\nname: meeting-notes\n---\nSECRET_INSTRUCTIONS_SHOULD_NOT_BE_READ',
+      'utf8',
+    );
+    fs.mkdirSync(path.join(root, 'not-a-skill.txt'));
+    fs.mkdirSync(path.join(root, 'nested', 'hidden-skill'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'nested', 'hidden-skill', 'SKILL.md'), 'secret', 'utf8');
+    fs.writeFileSync(path.join(root, 'README.md'), 'not a skill', 'utf8');
+
+    assert.deepEqual(discoverUserSkillNames(root), ['meeting-notes']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('Autocomplete merges default/remote skills with newly-created user skills', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'helix-cli-refresh-'));
+  try {
+    const completer = new Autocompleter(undefined, root);
+    (completer as any).remoteSkills = ['coding'];
+    (completer as any).skills = ['coding'];
+    fs.mkdirSync(path.join(root, 'custom-review'));
+    fs.writeFileSync(path.join(root, 'custom-review', 'SKILL.md'), '# user skill', 'utf8');
+
+    const [matches] = completer.completer('@custom');
+    assert.deepEqual(matches, ['@custom-review ']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('Colors: formatSkill applies strong orange formatting', () => {
   const formatted = formatSkill('web-researcher');
   assert.ok(formatted.includes('@web-researcher'));
@@ -139,3 +179,69 @@ test('Launcher: probePort resolves false on closed random port', async () => {
   const pythonExec = findPythonExecutable(process.cwd());
   assert.ok(pythonExec.length > 0);
 });
+
+test('CLI: run without arguments prints helpful error and exits with code 1', async () => {
+  const { execSync } = await import('node:child_process');
+  const path = await import('node:path');
+  const binPath = path.resolve(__dirname, '../bin/helix.js');
+  try {
+    execSync(`node "${binPath}" run`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    assert.fail('Should have exited with code 1');
+  } catch (err: any) {
+    assert.equal(err.status, 1);
+    const stderr = err.stderr.toString('utf-8');
+    assert.ok(stderr.includes('Debes proporcionar un prompt'));
+  }
+});
+
+test('CLI: run with piped UTF-8 Spanish text with BOM is decoded cleanly', async () => {
+  const { spawn } = await import('node:child_process');
+  const path = await import('node:path');
+  const binPath = path.resolve(__dirname, '../bin/helix.js');
+
+  const child = spawn('node', [binPath, 'run'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // Write UTF-8 BOM + Spanish text with accents
+  const payload = Buffer.concat([
+    Buffer.from([0xef, 0xbb, 0xbf]),
+    Buffer.from('¿Cuál es la configuración actual?', 'utf-8'),
+  ]);
+
+  child.stdin.write(payload);
+  child.stdin.end();
+
+  let stdout = '';
+  let stderr = '';
+  child.stdout.on('data', (d) => { stdout += d.toString('utf-8'); });
+  child.stderr.on('data', (d) => { stderr += d.toString('utf-8'); });
+
+  await new Promise<void>((resolve) => {
+    child.on('close', () => {
+      assert.ok(stdout.includes('¿Cuál es la configuración actual?'));
+      resolve();
+    });
+  });
+});
+
+
+
+test('Markdown: formatTerminalMarkdown parses bold, headers and bullets cleanly', async () => {
+  const { formatTerminalMarkdown } = await import('../src/ui/markdown');
+  const raw = '# Resumen\n\nAquí hay **texto importante** y un *detalle*:\n* Primer punto\n* Segundo punto\n`código`';
+
+  // Rich format
+  const formatted = formatTerminalMarkdown(raw);
+  assert.ok(!formatted.includes('**texto importante**'));
+  assert.ok(formatted.includes('texto importante'));
+  assert.ok(formatted.includes('• Primer punto'));
+
+  // Plain format
+  const plain = formatTerminalMarkdown(raw, true);
+  assert.ok(!plain.includes('**'));
+  assert.ok(!plain.includes('* Primer punto'));
+  assert.ok(plain.includes('- Primer punto'));
+  assert.ok(plain.includes('texto importante'));
+  assert.ok(plain.includes('RESUMEN'));
+});

package/tsconfig.json

@@ -9,10 +9,11 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
+    // @ts-ignore - node is deprecated but required for CommonJS compatibility with current dependencies
     "moduleResolution": "node",
     "resolveJsonModule": true,
     "declaration": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
-}
+}