dave-code 1.0.4 → 1.2.0

package/bin/check.js

@@ -0,0 +1,11 @@
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const directory = path.dirname(fileURLToPath(import.meta.url));
+const files = fs.readdirSync(directory).filter(file => file.endsWith('.js')).sort();
+for (const file of files) {
+  const result = spawnSync(process.execPath, ['--check', path.join(directory, file)], { stdio: 'inherit' });
+  if (result.status !== 0) process.exit(result.status || 1);
+}

package/bin/cliMenu.js

@@ -8,7 +8,23 @@
  */
 
 import readline from 'readline';
-import ora from 'ora';
+import { formatConversationMessage } from './terminalRenderer.js';
+import { displayWidth as getStringWidth, truncateEnd, padEnd } from './textWidth.js';
+
+const truncateDisplay = (str, maxWidth) => truncateEnd(str, maxWidth, '...');
+
+function enterMenuScreen(stdout) {
+  stdout.write('\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J');
+}
+
+function redrawMenuScreen(stdout, draw) {
+  stdout.write('\x1b[H\x1b[2J');
+  draw();
+}
+
+function exitMenuScreen(stdout) {
+  stdout.write('\x1b[?25h\x1b[?1049l');
+}
 
 export function selectMenu(title, description, options, defaultIndex = 0) {
   return new Promise((resolve) => {
@@ -23,51 +39,57 @@ export function selectMenu(title, description, options, defaultIndex = 0) {
     }
     stdin.resume();
 
-    // Hide terminal cursor
-    stdout.write('\x1b[?25l');
+    enterMenuScreen(stdout);
 
     function draw() {
-      stdout.write(`\n\x1b[1;36m${title}\x1b[0m\n`);
-      stdout.write(`\x1b[90m${description}\x1b[0m\n\n`);
+      const width = Math.max(24, Math.min(stdout.columns || 100, 120));
+      const compact = width < 64;
+      const nameWidth = Math.max(12, Math.floor(width * 0.42));
+      const descWidth = Math.max(10, width - nameWidth - 10);
+
+      stdout.write(`\x1b[1;36m${truncateDisplay(title, width)}\x1b[0m\n`);
+      for (const line of String(description || '').split(/\r?\n/).slice(0, 18)) {
+        stdout.write(`\x1b[90m${truncateDisplay(line, width)}\x1b[0m\n`);
+      }
+      stdout.write('\n');
       
       for (let i = 0; i < options.length; i++) {
         const opt = options[i];
+        const name = truncateDisplay(opt.name, compact ? width - 8 : nameWidth);
+        const desc = truncateDisplay(opt.desc, compact ? width - 7 : descWidth);
         if (i === cursor) {
-          stdout.write(` \x1b[32m›\x1b[0m \x1b[1;32m${i + 1}. ${opt.name}\x1b[0m   \x1b[90m${opt.desc}\x1b[0m\n`);
+          stdout.write(` \x1b[32m›\x1b[0m \x1b[1;32m${i + 1}. ${name}\x1b[0m${compact ? '\n     \x1b[90m' + desc + '\x1b[0m' : '   \x1b[90m' + desc + '\x1b[0m'}\n`);
         } else {
-          stdout.write(`   ${i + 1}. ${opt.name}   \x1b[90m${opt.desc}\x1b[0m\n`);
+          stdout.write(`   ${i + 1}. ${name}${compact ? '\n     \x1b[90m' + desc + '\x1b[0m' : '   \x1b[90m' + desc + '\x1b[0m'}\n`);
         }
       }
-      stdout.write('\n\x1b[90mUse Arrow Keys (↑/↓) to navigate, Enter to select, Esc to cancel\x1b[0m\n');
+      stdout.write('\n\x1b[90mUse ↑/↓ or number keys, Enter to select, Esc to cancel\x1b[0m\n');
     }
 
-    function clearLines(count) {
-      for (let i = 0; i < count; i++) {
-        stdout.write('\x1b[1A\x1b[2K');
-      }
+    function redrawMenu() {
+      redrawMenuScreen(stdout, draw);
     }
 
-    const totalLines = options.length + 6;
-    draw();
+    redrawMenu();
 
     function onKeypress(str, key) {
       if (!key) return;
       
       if (key.name === 'up') {
         cursor = (cursor - 1 + options.length) % options.length;
-        clearLines(totalLines);
-        draw();
+        redrawMenu();
       } else if (key.name === 'down') {
         cursor = (cursor + 1) % options.length;
-        clearLines(totalLines);
-        draw();
+        redrawMenu();
+      } else if (/^[1-9]$/.test(str || '') && Number(str) <= options.length) {
+        cursor = Number(str) - 1;
+        cleanup();
+        resolve(cursor);
       } else if (key.name === 'return') {
         cleanup();
-        stdout.write('\x1b[?25h'); // Show cursor
         resolve(cursor);
       } else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
         cleanup();
-        stdout.write('\x1b[?25h');
         resolve(-1);
       }
     }
@@ -78,6 +100,7 @@ export function selectMenu(title, description, options, defaultIndex = 0) {
         stdin.setRawMode(oldRawMode);
       }
       stdin.pause();
+      exitMenuScreen(stdout);
     }
 
     stdin.on('keypress', onKeypress);
@@ -153,12 +176,21 @@ export function chatInputPrompt(placeholder, currentLang) {
     const stdout = process.stdout;
     
     const footerText = currentLang === 'cn' 
-      ? '? 获取帮助 · Ctrl+C 退出' 
-      : '? for help · Ctrl+C to exit';
+      ? '/help 获取帮助 · Ctrl+C 退出' 
+      : '/help for help · Ctrl+C to exit';
+
+    const promptWidth = () => Math.max(24, Math.min(stdout.columns || 96, 120));
+    function renderPromptLine(value, { muted = false } = {}) {
+      const inner = promptWidth() - 2;
+      const visible = padEnd(truncateDisplay(value, inner), inner);
+      if (process.env.NO_COLOR) return `> ${visible}\n`;
+      const foreground = muted ? '\x1b[90m' : '\x1b[37m';
+      return `\x1b[48;5;236m\x1b[36m>\x1b[39m ${foreground}${visible}\x1b[0m\n`;
+    }
 
-    stdout.write('\x1b[90m───────────────────────────────────────────────────────────────────────────────────────────────\x1b[0m\n');
-    stdout.write(`› \x1b[90m${placeholder}\x1b[0m\n`);
-    stdout.write(`\x1b[90m${footerText}\x1b[0m`);
+    stdout.write(`\x1b[90m${'─'.repeat(promptWidth())}\x1b[0m\n`);
+    stdout.write(renderPromptLine(placeholder, { muted: true }));
+    stdout.write(`\x1b[90m${truncateDisplay(footerText, promptWidth())}\x1b[0m`);
     
     stdout.write('\x1b[1A\x1b[3G');
 
@@ -172,23 +204,22 @@ export function chatInputPrompt(placeholder, currentLang) {
     let chars = [];
     let cursorIndex = 0;
 
-    function getStringWidth(str) {
-      const cleanStr = str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
-      let width = 0;
-      for (let i = 0; i < cleanStr.length; i++) {
-        const code = cleanStr.charCodeAt(i);
-        if (
-          (code >= 0x4e00 && code <= 0x9fff) ||
-          (code >= 0x3400 && code <= 0x4dbf) ||
-          (code >= 0x3000 && code <= 0x303f) ||
-          (code >= 0xff00 && code <= 0xffef)
-        ) {
-          width += 2;
-        } else {
-          width += 1;
-        }
+    function getInputView() {
+      const available = Math.max(8, promptWidth() - 3);
+      let start = 0;
+      while (start < cursorIndex && getStringWidth(chars.slice(start, cursorIndex).join('')) > available - 1) {
+        start++;
+      }
+      const prefix = start > 0 ? '…' : '';
+      let visible = prefix;
+      for (let i = start; i < chars.length; i++) {
+        if (getStringWidth(visible + chars[i]) > available) break;
+        visible += chars[i];
       }
-      return width;
+      return {
+        visible,
+        cursorLeft: prefix + chars.slice(start, cursorIndex).join('')
+      };
     }
 
     function redraw() {
@@ -197,16 +228,15 @@ export function chatInputPrompt(placeholder, currentLang) {
       
       const valueStr = chars.join('');
       if (valueStr.length === 0) {
-        stdout.write(`› \x1b[90m${placeholder}\x1b[0m\n`);
+        stdout.write(renderPromptLine(placeholder, { muted: true }));
       } else {
-        stdout.write(`› ${valueStr}\n`);
+        stdout.write(renderPromptLine(getInputView().visible));
       }
       
-      stdout.write(`\x1b[90m${footerText}\x1b[0m`);
+      stdout.write(`\x1b[90m${truncateDisplay(footerText, promptWidth())}\x1b[0m`);
       stdout.write('\x1b[1A');
       
-      const leftPart = chars.slice(0, cursorIndex).join('');
-      const cursorCol = 3 + (chars.length === 0 ? 0 : getStringWidth(leftPart));
+      const cursorCol = 3 + (chars.length === 0 ? 0 : getStringWidth(getInputView().cursorLeft));
       stdout.write(`\x1b[${cursorCol}G`);
     }
 
@@ -214,9 +244,16 @@ export function chatInputPrompt(placeholder, currentLang) {
       if (!key) return;
 
       if (key.name === 'return') {
+        const submitted = chars.join('').trim();
         cleanup();
-        stdout.write('\x1b[1B\x1b[1G\x1b[2K\r');
-        resolve(chars.join('').trim());
+        stdout.write('\x1b[1G\x1b[J');
+        if (submitted) {
+          stdout.write(`${formatConversationMessage(
+            { role: 'user', content: submitted },
+            { color: Boolean(stdout.isTTY && !process.env.NO_COLOR), width: promptWidth() }
+          )}\n`);
+        }
+        resolve(submitted);
       } else if (key.name === 'backspace') {
         if (cursorIndex > 0) {
           chars.splice(cursorIndex - 1, 1);
@@ -287,6 +324,10 @@ export function waitForEnter(promptText) {
         cleanup();
         stdout.write('\n');
         resolve();
+      } else if (key && (key.name === 'escape' || (key.ctrl && key.name === 'c'))) {
+        cleanup();
+        stdout.write('\n');
+        resolve();
       }
     }
     
@@ -302,146 +343,155 @@ export function waitForEnter(promptText) {
   });
 }
 
-export function startSpinner(prefixText) {
-  const spinner = ora({
-    text: prefixText,
-    color: 'cyan',
-    spinner: 'dots'
-  }).start();
+function centerAt(text, center, width) {
+  const value = String(text || '');
+  const start = Math.max(0, Math.min(width - getStringWidth(value), Math.round(center - getStringWidth(value) / 2)));
+  return { start, value };
+}
 
-  return () => {
-    spinner.stop();
-  };
+function overlayLine(width, entries) {
+  const cells = Array(width).fill(' ');
+  for (const entry of entries) {
+    let offset = entry.start;
+    for (const char of entry.value) {
+      if (offset >= width) break;
+      cells[offset] = char;
+      offset += getStringWidth(char);
+      if (getStringWidth(char) === 2 && offset - 1 < width) cells[offset - 1] = '';
+    }
+  }
+  return cells.join('');
 }
 
-export function selectEffortMenu(currentEffort, currentLang) {
-  const levels = ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'];
-  let cursor = levels.indexOf(currentEffort);
-  if (cursor === -1) cursor = 2; // Default to 'high'
-  
-  return new Promise((resolve) => {
-    const stdout = process.stdout;
-    const stdin = process.stdin;
-    
+export function renderWorkModeSelector(selectedMode = 'highway', currentLang = 'cn', { width = 86, color = true } = {}) {
+  const safeWidth = Math.max(48, Math.min(120, Math.floor(width || 86)));
+  const leftCenter = Math.floor(safeWidth * 0.25);
+  const rightCenter = Math.floor(safeWidth * 0.75);
+  const selectedCenter = selectedMode === 'thunder' ? rightCenter : leftCenter;
+  const green = color ? '\x1b[1;38;2;74;222;128m' : '';
+  const cyan = color ? '\x1b[1;36m' : '';
+  const muted = color ? '\x1b[90m' : '';
+  const white = color ? '\x1b[1;37m' : '';
+  const reset = color ? '\x1b[0m' : '';
+  const active = selectedMode === 'thunder' ? green : cyan;
+  const labels = currentLang === 'cn'
+    ? { left: '更快速', right: '更强大', highway: 'Highway', thunder: 'Thunder', highwayDesc: '专注的单 Agent 工作流', thunderDesc: 'PM 领导的办公室团队' }
+    : { left: 'Faster', right: 'Smarter', highway: 'Highway', thunder: 'Thunder', highwayDesc: 'Focused single-agent workflow', thunderDesc: 'PM-led office agent team' };
+  const title = overlayLine(safeWidth, [centerAt(labels.left, leftCenter, safeWidth), centerAt(labels.right, rightCenter, safeWidth)]);
+  const marker = overlayLine(safeWidth, [{ start: selectedCenter, value: '▲' }]);
+  const divider = Math.floor(safeWidth / 2);
+  const ruleChars = Array(safeWidth).fill('─');
+  ruleChars[divider] = '┊';
+  const names = overlayLine(safeWidth, [centerAt(labels.highway, leftCenter, safeWidth), centerAt(labels.thunder, rightCenter, safeWidth)]);
+  const desc = overlayLine(safeWidth, [centerAt(labels.highwayDesc, leftCenter, safeWidth), centerAt(labels.thunderDesc, rightCenter, safeWidth)]);
+  const coloredNames = selectedMode === 'thunder'
+    ? names.replace(labels.thunder, `${green}${labels.thunder}${reset}`)
+    : names.replace(labels.highway, `${cyan}${labels.highway}${reset}`);
+  return [
+    `${white}${title}${reset}`,
+    `${active}${marker}${reset}`,
+    `${muted}${ruleChars.join('')}${reset}`,
+    coloredNames,
+    `${muted}${desc}${reset}`,
+    '',
+    `${muted}${currentLang === 'cn' ? '←/→ 选择 · Enter 确认 · Esc 取消' : '←/→ select · Enter confirm · Esc cancel'}${reset}`
+  ].join('\n');
+}
+
+export function selectWorkModeMenu(currentMode = 'highway', currentLang = 'cn', { stdin = process.stdin, stdout = process.stdout } = {}) {
+  if (!stdin?.isTTY || !stdout?.isTTY) return Promise.resolve(currentMode);
+  return new Promise(resolve => {
+    let selected = currentMode === 'thunder' ? 'thunder' : 'highway';
+    const oldRawMode = Boolean(stdin.isRaw);
     readline.emitKeypressEvents(stdin);
-    const oldRawMode = stdin.isRawMode;
-    if (stdin.setRawMode) {
-      stdin.setRawMode(true);
-    }
+    if (stdin.setRawMode) stdin.setRawMode(true);
     stdin.resume();
-    
-    // Hide terminal cursor
-    stdout.write('\x1b[?25l');
-    
-    const title = currentLang === 'cn' ? '调整努力模式 (Adjust Effort Mode)' : 'Adjust Effort Mode';
-    const description = currentLang === 'cn' 
-      ? '选择模型的思考努力程度。努力程度越高，循环上限和阅读长度越大；ultracode 模式会执行大文件消化工作流以完全读完。'
-      : 'Select thinking effort level. Higher levels increase loop limits and file read sizes; ultracode triggers digestion workflows to read large files fully.';
-      
-    const footer = currentLang === 'cn'
-      ? '使用左右方向键 (←/→) 移动滑块, 回车 (Enter) 确认, Esc/Ctrl+C 取消'
-      : 'Use Arrow Keys (←/→) to navigate, Enter to select, Esc/Ctrl+C to cancel';
+    enterMenuScreen(stdout);
 
     function draw() {
-      stdout.write(`\n\x1b[1;36m${title}\x1b[0m\n`);
-      stdout.write(`\x1b[90m${description}\x1b[0m\n\n`);
-      
-      stdout.write(`Faster                                                              Smarter\n`);
-      stdout.write(`───────────────────────────────────────────────────┋───────────────────────\n`);
-      
-      // Calculate Pointer line (triangle)
-      const centers = [2, 12, 23, 36, 46, 60];
-      const selectedCenter = centers[cursor];
-      
-      let pointerChar = '▲';
-      // Triangle color: purple if ultracode, otherwise yellow
-      let pointerColor = cursor === 5 ? '\x1b[1;38;2;140;90;240m' : '\x1b[1;33m';
-      
-      let rawPointerLine = ' '.repeat(selectedCenter) + '▲' + ' '.repeat(76 - selectedCenter - 1);
-      let rawPointerLineChars = [...rawPointerLine];
-      rawPointerLineChars[50] = '┋';
-      
-      let coloredPointerLine = '';
-      for (let i = 0; i < rawPointerLineChars.length; i++) {
-        if (i === selectedCenter) {
-          coloredPointerLine += pointerColor + '▲\x1b[0m';
-        } else if (i === 50) {
-          coloredPointerLine += '\x1b[90m┋\x1b[0m';
-        } else {
-          coloredPointerLine += rawPointerLineChars[i];
-        }
-      }
-      stdout.write(`${coloredPointerLine}\n`);
-      
-      // Calculate Labels line
-      const optColors = levels.map((lvl, idx) => {
-        if (idx === cursor) {
-          return idx === 5 ? '\x1b[1;38;2;140;90;240m' : '\x1b[1;33m';
-        }
-        return '\x1b[90m';
-      });
-      
-      stdout.write(` `);
-      stdout.write(`${optColors[0]}low\x1b[0m` + `      `);
-      stdout.write(`${optColors[1]}medium\x1b[0m` + `      `);
-      stdout.write(`${optColors[2]}high\x1b[0m` + `        `);
-      stdout.write(`${optColors[3]}xhigh\x1b[0m` + `      `);
-      stdout.write(`${optColors[4]}max\x1b[0m` + `   \x1b[90m┋\x1b[0m     `);
-      stdout.write(`${optColors[5]}ultracode\x1b[0m\n`);
-      
-      // Print subtext line (spacing with divider)
-      stdout.write(' '.repeat(50) + '\x1b[90m┋\x1b[0m\n\n');
-      
-      stdout.write(`\x1b[90m${footer}\x1b[0m\n`);
+      const width = Math.max(48, Math.min(stdout.columns || 86, 110));
+      const topPadding = Math.max(1, Math.floor(((stdout.rows || 20) - 7) / 3));
+      stdout.write('\n'.repeat(topPadding));
+      stdout.write(renderWorkModeSelector(selected, currentLang, { width, color: !process.env.NO_COLOR }));
     }
-    
-    function clearLines(count) {
-      for (let i = 0; i < count; i++) {
-        stdout.write('\x1b[1A\x1b[2K');
-      }
+    function redraw() { redrawMenuScreen(stdout, draw); }
+    function cleanup() {
+      stdin.removeListener('keypress', onKeypress);
+      if (stdin.setRawMode) stdin.setRawMode(oldRawMode);
+      stdin.pause();
+      exitMenuScreen(stdout);
     }
-    
-    const totalLines = 10;
-    draw();
-    
-    function onKeypress(str, key) {
-      if (!key) return;
-      
-      if (key.name === 'left') {
-        if (cursor > 0) {
-          cursor--;
-          clearLines(totalLines);
-          draw();
-        }
-      } else if (key.name === 'right') {
-        if (cursor < 5) {
-          cursor++;
-          clearLines(totalLines);
-          draw();
-        }
+    function onKeypress(str, key = {}) {
+      if (['left', 'right', 'up', 'down', 'tab'].includes(key.name)) {
+        selected = selected === 'highway' ? 'thunder' : 'highway';
+        redraw();
+      } else if (str === '1') {
+        selected = 'highway'; cleanup(); resolve(selected);
+      } else if (str === '2') {
+        selected = 'thunder'; cleanup(); resolve(selected);
       } else if (key.name === 'return') {
-        cleanup();
-        stdout.write('\x1b[?25h'); // Show cursor
-        resolve(levels[cursor]);
+        cleanup(); resolve(selected);
       } else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
-        cleanup();
-        stdout.write('\x1b[?25h');
-        resolve(null);
+        cleanup(); resolve(null);
       }
     }
-    
-    function cleanup() {
-      stdin.removeListener('keypress', onKeypress);
-      if (stdin.setRawMode) {
-        stdin.setRawMode(oldRawMode);
-      }
-      stdin.pause();
-    }
-    
     stdin.on('keypress', onKeypress);
+    redraw();
   });
 }
 
+export function renderThunderActivationFrame(frame = 0, { width = 86, height = 16, currentLang = 'cn', color = true } = {}) {
+  const safeWidth = Math.max(40, Math.min(140, Math.floor(width || 86)));
+  const safeHeight = Math.max(10, Math.min(36, Math.floor(height || 16)));
+  const shades = color
+    ? ['\x1b[48;2;5;32;20m', '\x1b[48;2;8;55;31m', '\x1b[48;2;11;78;43m', '\x1b[48;2;16;104;57m', '\x1b[48;2;24;132;73m']
+    : ['', '', '', '', ''];
+  const reset = color ? '\x1b[0m' : '';
+  const lines = [];
+  for (let row = 0; row < safeHeight; row++) {
+    let line = '';
+    for (let col = 0; col < safeWidth - 1; col += 2) {
+      const wave = Math.sin((col + frame * 5) / 8) + Math.cos((row * 3 - frame * 2) / 5);
+      const pulse = Math.sin((col + row * 5 + frame * 7) / 11);
+      const shade = Math.max(0, Math.min(shades.length - 1, Math.floor((wave + pulse + 3) / 1.4)));
+      line += `${shades[shade]}  ${reset}`;
+    }
+    if (safeWidth % 2 === 1) line += `${shades[(row + frame) % shades.length]} ${reset}`;
+    lines.push(line);
+  }
+  const titleRow = Math.floor(safeHeight / 2) - 1;
+  const title = '⚡  T H U N D E R  ⚡';
+  const subtitle = currentLang === 'cn' ? '办公室团队正在上线' : 'Office team coming online';
+  const place = (row, text, tone) => {
+    const plain = ' '.repeat(Math.max(0, Math.floor((safeWidth - getStringWidth(text)) / 2))) + text;
+    lines[row] = `${color ? tone : ''}${plain}${reset}` + ' '.repeat(Math.max(0, safeWidth - getStringWidth(plain)));
+  };
+  place(titleRow, title, '\x1b[1;97;48;2;14;86;48m');
+  place(titleRow + 2, subtitle, '\x1b[1;38;2;177;255;204;48;2;8;55;31m');
+  return lines.join('\n');
+}
+
+export async function runThunderActivationAnimation({ stdout = process.stdout, currentLang = 'cn', durationMs = 950, sleep = ms => new Promise(resolve => setTimeout(resolve, ms)) } = {}) {
+  if (!stdout || (stdout === process.stdout && (!stdout.isTTY || process.env.NO_COLOR || process.env.TERM === 'dumb'))) return;
+  const frameMs = 55;
+  const frames = Math.max(6, Math.floor(durationMs / frameMs));
+  enterMenuScreen(stdout);
+  try {
+    for (let frame = 0; frame < frames; frame++) {
+      stdout.write('\x1b[H');
+      stdout.write(renderThunderActivationFrame(frame, {
+        width: stdout.columns || 86,
+        height: Math.max(10, (stdout.rows || 20) - 1),
+        currentLang,
+        color: true
+      }));
+      await sleep(frameMs);
+    }
+  } finally {
+    exitMenuScreen(stdout);
+  }
+}
+
 export function confirmPrompt(promptText) {
   return new Promise((resolve) => {
     const stdin = process.stdin;
@@ -487,4 +537,33 @@ export function confirmPrompt(promptText) {
   });
 }
 
-
+export function permissionPrompt(promptText) {
+  return new Promise(resolve => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(promptText);
+    readline.emitKeypressEvents(stdin);
+    const oldRawMode = stdin.isRawMode;
+    if (stdin.setRawMode) stdin.setRawMode(true);
+    stdin.resume();
+    function cleanup() {
+      stdin.removeListener('keypress', onKeypress);
+      if (stdin.setRawMode) stdin.setRawMode(oldRawMode);
+      stdin.pause();
+    }
+    function onKeypress(str, key) {
+      if (!key) return;
+      const char = String(str || '').toLowerCase();
+      if (char === 'y' || char === 'a') {
+        cleanup();
+        stdout.write(`${char}\n`);
+        resolve(char === 'a' ? 'always' : true);
+      } else if (char === 'n' || key.name === 'return' || key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        cleanup();
+        stdout.write('n\n');
+        resolve(false);
+      }
+    }
+    stdin.on('keypress', onKeypress);
+  });
+}

package/bin/commandRouter.js

@@ -0,0 +1,70 @@
+function exactCommand(input, command) {
+  return input === command || input.startsWith(`${command} `);
+}
+
+export function parsePlanCreation(argument) {
+  const separator = argument.indexOf(':');
+  if (separator === -1) {
+    return { error: 'Use /plan <name>: <request>.' };
+  }
+  const name = argument.slice(0, separator).trim();
+  const request = argument.slice(separator + 1).trim();
+  if (!name || !request) return { error: 'Plan name and request are both required.' };
+  if ([...name].length > 60) return { error: 'Plan name must be 60 characters or fewer.' };
+  if (/[\u0000-\u001f\u007f]/.test(name)) return { error: 'Plan name cannot contain control characters.' };
+  return { name, request };
+}
+
+export function parseInputCommand(input, { findPlan = () => null } = {}) {
+  const trimmed = String(input || '').trim();
+  if (trimmed === '/mode') return { type: 'mode.menu' };
+  if (exactCommand(trimmed, '/mode')) {
+    const mode = trimmed.slice('/mode'.length).trim().toLowerCase();
+    return ['highway', 'thunder'].includes(mode)
+      ? { type: 'mode.set', mode }
+      : { type: 'error', error: 'Use /mode highway or /mode thunder.' };
+  }
+  if (trimmed === '/thunder') return { type: 'thunder.usage' };
+  if (exactCommand(trimmed, '/thunder')) {
+    const prompt = trimmed.slice('/thunder'.length).trim();
+    return prompt ? { type: 'agent', mode: 'chat', workMode: 'thunder', prompt, plan: null } : { type: 'thunder.usage' };
+  }
+  if (trimmed === '/agents') return { type: 'agents.menu' };
+  if (trimmed === '/note') return { type: 'note', action: 'status' };
+  if (exactCommand(trimmed, '/note')) {
+    const action = trimmed.slice('/note'.length).trim().toLowerCase();
+    return ['status', 'refresh', 'rebuild', 'clear'].includes(action)
+      ? { type: 'note', action }
+      : { type: 'error', error: 'Use /note status, refresh, rebuild, or clear.' };
+  }
+  if (trimmed === '/plan') return { type: 'plan.menu' };
+  if (exactCommand(trimmed, '/plan')) {
+    const parsed = parsePlanCreation(trimmed.slice('/plan'.length).trim());
+    return parsed.error ? { type: 'error', error: parsed.error } : { type: 'plan.create', ...parsed };
+  }
+
+  if (trimmed === '/code') return { type: 'code.usage' };
+  if (exactCommand(trimmed, '/code')) {
+    let argument = trimmed.slice('/code'.length).trim();
+    if (!argument) return { type: 'code.usage' };
+    if (argument.startsWith('--prompt ')) {
+      argument = argument.slice('--prompt '.length).trim();
+      return argument
+        ? { type: 'agent', mode: 'code', prompt: argument, plan: null }
+        : { type: 'code.usage' };
+    }
+    if (argument.startsWith('@')) {
+      const name = argument.slice(1).trim();
+      const plan = findPlan(name);
+      return plan
+        ? { type: 'agent', mode: 'code', prompt: plan.content, plan }
+        : { type: 'error', error: `Plan not found: ${name}` };
+    }
+    const plan = findPlan(argument);
+    return plan
+      ? { type: 'agent', mode: 'code', prompt: plan.content, plan }
+      : { type: 'agent', mode: 'code', prompt: argument, plan: null };
+  }
+
+  return { type: 'agent', mode: 'chat', prompt: trimmed, plan: null };
+}