@koi-language/koi 1.0.6 → 1.1.0

package/src/runtime/cli-display.js

@@ -0,0 +1,26 @@
+/**
+ * CLI Display helpers for progress spinner text.
+ * Separated from agent.js to avoid circular dependencies with action files.
+ */
+
+/**
+ * Build display text for progress spinner based on action type.
+ * For MCP calls: "[🤖 Agent 🔌 mcp] tool(summary)"
+ * For others: "[🤖 Agent] Thinking" (or desc if provided)
+ */
+export function buildActionDisplay(agentName, action) {
+  const intent = action.intent || action.type;
+
+  if (intent === 'call_mcp' && action.mcp && action.tool) {
+    let inputSummary = '';
+    if (action.input && typeof action.input === 'object' && Object.keys(action.input).length > 0) {
+      const raw = JSON.stringify(action.input);
+      inputSummary = raw.length > 80 ? raw.substring(0, 77) + '...' : raw;
+    }
+    const toolCall = inputSummary ? `${action.tool}(${inputSummary})` : action.tool;
+    return `[🤖 ${agentName} 🔌 ${action.mcp}] ${toolCall}`;
+  }
+
+  const displayText = action.desc ? action.desc.replace(/\.\.\.$/, '') : 'Thinking';
+  return `[🤖 ${agentName}] ${displayText}`;
+}

package/src/runtime/cli-input.js

@@ -0,0 +1,421 @@
+/**
+ * CLI Input - Rich line editor with blinking underscore cursor, multi-line, and history.
+ *
+ * Features:
+ *   - Blinking underscore cursor (classic terminal style)
+ *   - Left/Right: move by character
+ *   - Option+Left/Right: move by word
+ *   - Up/Down: navigate visual lines
+ *   - Up at start of text: previous history entry
+ *   - Down at end of text: next history entry (empty at end)
+ *   - Ctrl+A / Home: beginning of line
+ *   - Ctrl+E / End: end of line
+ *   - Backspace / Option+Backspace: delete char / word
+ *   - Delete / Ctrl+D: delete at cursor
+ *   - Ctrl+U: clear before cursor
+ *   - Ctrl+K: clear after cursor
+ *   - Ctrl+W: delete word before cursor
+ *   - Enter: submit
+ *   - Ctrl+C / Escape: cancel
+ *
+ * Uses process.stdout.write exclusively — no console.log calls.
+ */
+
+import readline from 'readline';
+
+// Session-wide input history (persists across cliInput calls, resets on process exit)
+const inputHistory = [];
+
+/**
+ * Show a line editor with block cursor, multi-line support, and history.
+ * @param {string} promptText - The prompt prefix (shown in bold white)
+ * @returns {Promise<string>} The user's input text
+ */
+export function cliInput(promptText) {
+  return new Promise((resolve) => {
+    const stdout = process.stdout;
+    const stdin = process.stdin;
+
+    // Ensure prompt ends with space
+    const prompt = promptText.endsWith(' ') ? promptText : promptText + ' ';
+    const promptLen = prompt.length;
+
+    let text = '';
+    let cursor = 0;
+    let prevLineCount = 0;
+
+    // Blinking cursor state
+    let cursorVisible = true;
+    let blinkInterval = null;
+    let lastKeypressTime = 0;
+
+    // History navigation
+    let historyIndex = -1; // -1 = not browsing history
+    let savedText = '';     // current text saved before entering history
+
+    // --- Visual line calculations ---
+
+    function getCols() {
+      return stdout.columns || parseInt(process.env.COLUMNS) || 80;
+    }
+
+    function firstLineCap() {
+      return Math.max(1, getCols() - promptLen);
+    }
+
+    function cursorToRowCol(pos) {
+      const flc = firstLineCap();
+      const c = getCols();
+      if (pos < flc) return { row: 0, col: pos };
+      const rem = pos - flc;
+      return { row: 1 + Math.floor(rem / c), col: rem % c };
+    }
+
+    function rowColToCursor(row, col) {
+      const flc = firstLineCap();
+      const c = getCols();
+      if (row === 0) return Math.min(col, text.length, flc);
+      const pos = flc + (row - 1) * c + col;
+      return Math.min(pos, text.length);
+    }
+
+    function totalRows() {
+      const flc = firstLineCap();
+      const c = getCols();
+      if (text.length <= flc) return 1;
+      return 1 + Math.ceil((text.length - flc) / c);
+    }
+
+    function lineLen(row) {
+      const flc = firstLineCap();
+      const c = getCols();
+      if (row === 0) return Math.min(text.length, flc);
+      const start = flc + (row - 1) * c;
+      if (start >= text.length) return 0;
+      return Math.min(c, text.length - start);
+    }
+
+    // --- Rendering ---
+
+    function render() {
+      const flc = firstLineCap();
+      const c = getCols();
+      const numRows = totalRows();
+      const { row: curRow, col: curCol } = cursorToRowCol(cursor);
+
+      // Ensure cursor row exists (cursor at end of text may be on new row)
+      const renderRows = Math.max(numRows, curRow + 1);
+
+      // Move to first line of editor area
+      if (prevLineCount > 1) {
+        stdout.write(`\x1b[${prevLineCount - 1}A`);
+      }
+      stdout.write('\r');
+
+      for (let r = 0; r < renderRows; r++) {
+        // Overwrite in place (no \x1b[2K clear-first) to avoid flicker.
+        // After writing content, \x1b[K clears any leftover chars to the right.
+
+        // Compute text slice for this row
+        let lineStart, lineEnd;
+        if (r === 0) {
+          lineStart = 0;
+          lineEnd = Math.min(text.length, flc);
+          stdout.write(`\x1b[1m${prompt}\x1b[0m`);
+        } else {
+          lineStart = flc + (r - 1) * c;
+          lineEnd = Math.min(text.length, lineStart + c);
+        }
+
+        const lineText = (lineStart < text.length) ? text.substring(lineStart, lineEnd) : '';
+
+        if (r === curRow) {
+          // Render with blinking underscore cursor
+          const before = lineText.substring(0, curCol);
+          const atCursor = curCol < lineText.length ? lineText[curCol] : ' ';
+          const after = curCol < lineText.length ? lineText.substring(curCol + 1) : '';
+          if (cursorVisible) {
+            // Cursor ON: show character with underline decoration
+            stdout.write(`\x1b[36m${before}\x1b[4;36m${atCursor}\x1b[24m${after}\x1b[0m`);
+          } else {
+            // Cursor OFF: show character normally (no decoration)
+            stdout.write(`\x1b[36m${before}${atCursor}${after}\x1b[0m`);
+          }
+        } else {
+          stdout.write(`\x1b[36m${lineText}\x1b[0m`);
+        }
+
+        // Clear any leftover characters after content
+        stdout.write('\x1b[K');
+
+        if (r < renderRows - 1) stdout.write('\n');
+      }
+
+      // Clear leftover lines from previous render
+      if (prevLineCount > renderRows) {
+        const extra = prevLineCount - renderRows;
+        for (let i = 0; i < extra; i++) {
+          stdout.write('\n\x1b[2K');
+        }
+        stdout.write(`\x1b[${extra}A`);
+      }
+
+      prevLineCount = renderRows;
+    }
+
+    // --- History helpers ---
+
+    function historyUp() {
+      if (inputHistory.length === 0) return;
+      if (historyIndex === -1) {
+        savedText = text;
+        historyIndex = inputHistory.length - 1;
+      } else if (historyIndex > 0) {
+        historyIndex--;
+      } else {
+        return; // already at oldest
+      }
+      text = inputHistory[historyIndex];
+      cursor = 0;
+    }
+
+    function historyDown() {
+      if (historyIndex === -1) return;
+      if (historyIndex < inputHistory.length - 1) {
+        historyIndex++;
+        text = inputHistory[historyIndex];
+        cursor = text.length;
+      } else {
+        // Past last entry → restore saved text
+        text = savedText;
+        cursor = text.length;
+        historyIndex = -1;
+      }
+    }
+
+    // --- Setup ---
+
+    readline.emitKeypressEvents(stdin);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdout.write('\x1b[?25l'); // hide native cursor
+
+    // Start blink interval (500ms on, 500ms off = 1s cycle)
+    blinkInterval = setInterval(() => {
+      // Skip blink render if user is actively typing (prevents flicker)
+      if (Date.now() - lastKeypressTime < 100) return;
+      cursorVisible = !cursorVisible;
+      render();
+    }, 500);
+
+    function cleanup() {
+      if (blinkInterval) { clearInterval(blinkInterval); blinkInterval = null; }
+      stdin.removeListener('keypress', onKeypress);
+      stdin.setRawMode(wasRaw);
+      stdout.write('\x1b[?25h'); // restore native cursor
+    }
+
+    function submit() {
+      cleanup();
+
+      // Add to history if non-empty
+      if (text.trim()) {
+        inputHistory.push(text);
+      }
+      historyIndex = -1;
+
+      // Clear editor area and show final text (no cursor)
+      if (prevLineCount > 1) {
+        stdout.write(`\x1b[${prevLineCount - 1}A`);
+      }
+      stdout.write('\r');
+      for (let i = 0; i < prevLineCount; i++) {
+        stdout.write('\x1b[2K');
+        if (i < prevLineCount - 1) stdout.write('\n');
+      }
+      if (prevLineCount > 1) {
+        stdout.write(`\x1b[${prevLineCount - 1}A`);
+      }
+      stdout.write('\r');
+
+      // Write final output (let terminal wrap naturally)
+      stdout.write(`\x1b[1m${prompt}\x1b[0m\x1b[36m${text}\x1b[0m\n`);
+      resolve(text.trim());
+    }
+
+    function resetBlink() {
+      cursorVisible = true;
+      lastKeypressTime = Date.now();
+      if (blinkInterval) clearInterval(blinkInterval);
+      blinkInterval = setInterval(() => {
+        // Skip blink render if user is actively typing (prevents flicker)
+        if (Date.now() - lastKeypressTime < 100) return;
+        cursorVisible = !cursorVisible;
+        render();
+      }, 500);
+    }
+
+    function onKeypress(str, key) {
+      resetBlink();
+
+      if (key) {
+        // --- Submit / Cancel ---
+        if (key.name === 'return') { submit(); return; }
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+          cleanup();
+          stdout.write('\r\x1b[2K');
+          stdout.write(`\x1b[1m${prompt}\x1b[0m\n`);
+          resolve('');
+          return;
+        }
+
+        // --- Up / Down ---
+        if (key.name === 'up') {
+          const { row, col } = cursorToRowCol(cursor);
+          if (row > 0) {
+            // Move to previous visual line, clamp column
+            const targetCol = Math.min(col, lineLen(row - 1));
+            cursor = rowColToCursor(row - 1, targetCol);
+          } else if (cursor > 0) {
+            // First line, not at start → go to start
+            cursor = 0;
+          } else {
+            // At start → history up
+            historyUp();
+          }
+          render();
+          return;
+        }
+
+        if (key.name === 'down') {
+          const { row, col } = cursorToRowCol(cursor);
+          const lr = totalRows() - 1;
+          if (row < lr) {
+            // Move to next visual line, clamp column
+            const targetCol = Math.min(col, lineLen(row + 1));
+            cursor = rowColToCursor(row + 1, targetCol);
+          } else if (cursor < text.length) {
+            // Last line, not at end → go to end
+            cursor = text.length;
+          } else {
+            // At end → history down
+            historyDown();
+          }
+          render();
+          return;
+        }
+
+        // --- Left / Right ---
+        if (key.name === 'left') {
+          if (key.meta || key.ctrl) {
+            cursor = prevWordBoundary(text, cursor);
+          } else {
+            cursor = Math.max(0, cursor - 1);
+          }
+          render(); return;
+        }
+        if (key.name === 'right') {
+          if (key.meta || key.ctrl) {
+            cursor = nextWordBoundary(text, cursor);
+          } else {
+            cursor = Math.min(text.length, cursor + 1);
+          }
+          render(); return;
+        }
+
+        // ESC-b / ESC-f (word movement in some terminals)
+        if (key.meta && key.name === 'b') { cursor = prevWordBoundary(text, cursor); render(); return; }
+        if (key.meta && key.name === 'f') { cursor = nextWordBoundary(text, cursor); render(); return; }
+
+        // Home / End
+        if (key.name === 'home' || (key.ctrl && key.name === 'a')) { cursor = 0; render(); return; }
+        if (key.name === 'end' || (key.ctrl && key.name === 'e')) { cursor = text.length; render(); return; }
+
+        // --- Deletion ---
+        if (key.name === 'backspace') {
+          if (cursor > 0) {
+            if (key.meta || key.ctrl) {
+              const prev = prevWordBoundary(text, cursor);
+              text = text.substring(0, prev) + text.substring(cursor);
+              cursor = prev;
+            } else {
+              text = text.substring(0, cursor - 1) + text.substring(cursor);
+              cursor--;
+            }
+            render();
+          }
+          return;
+        }
+        if (key.name === 'delete' || (key.ctrl && key.name === 'd')) {
+          if (cursor < text.length) {
+            text = text.substring(0, cursor) + text.substring(cursor + 1);
+            render();
+          }
+          return;
+        }
+        if (key.ctrl && key.name === 'u') {
+          text = text.substring(cursor); cursor = 0; render(); return;
+        }
+        if (key.ctrl && key.name === 'k') {
+          text = text.substring(0, cursor); render(); return;
+        }
+        if (key.ctrl && key.name === 'w') {
+          if (cursor > 0) {
+            const prev = prevWordBoundary(text, cursor);
+            text = text.substring(0, prev) + text.substring(cursor);
+            cursor = prev;
+            render();
+          }
+          return;
+        }
+
+        // Skip other control/meta keys
+        if (key.ctrl || key.meta) return;
+      }
+
+      // Regular character input
+      if (str && str.length > 0 && str.charCodeAt(0) >= 32) {
+        let ch = str;
+        // Handle dead key combining characters (macOS international keyboards)
+        const code = str.charCodeAt(0);
+        if (code >= 0x0300 && code <= 0x036F) {
+          const deadKeyMap = {
+            0x0300: '`',   // combining grave → backtick
+            0x0301: "'",   // combining acute → apostrophe
+            0x0302: '^',   // combining circumflex → caret
+            0x0303: '~',   // combining tilde → tilde
+            0x0308: '"',   // combining diaeresis → double quote
+          };
+          ch = deadKeyMap[code] || '';
+        }
+        if (ch) {
+          text = text.substring(0, cursor) + ch + text.substring(cursor);
+          cursor += ch.length;
+          render();
+        }
+      }
+    }
+
+    stdin.on('keypress', onKeypress);
+    render();
+  });
+}
+
+// --- Word boundary helpers ---
+
+function prevWordBoundary(text, pos) {
+  if (pos <= 0) return 0;
+  let i = pos - 1;
+  while (i > 0 && text[i] === ' ') i--;
+  while (i > 0 && text[i - 1] !== ' ') i--;
+  return i;
+}
+
+function nextWordBoundary(text, pos) {
+  if (pos >= text.length) return text.length;
+  let i = pos;
+  while (i < text.length && text[i] !== ' ') i++;
+  while (i < text.length && text[i] === ' ') i++;
+  return i;
+}

package/src/runtime/cli-logger.js

@@ -17,7 +17,6 @@ class CLILogger {
     this.isAnimating = false; // Track if we're in animation mode
     this.indentStack = []; // Stack of messages showing delegation hierarchy
     this.indentLevel = 0;
-
     // Intercept console methods to auto-clear progress
     this.setupConsoleIntercept();
   }
@@ -141,10 +140,8 @@ class CLILogger {
       this.stopAnimation();
     }
 
-    // Clear previous line
-    if (this.isProgress) {
-      process.stdout.write('\r\x1b[K');
-    }
+    // Always clear current line (handles parent process leftovers like "🌊 Running...")
+    process.stdout.write('\r\x1b[K');
 
     // Write new message
     process.stdout.write(message);

package/src/runtime/cli-markdown.js

@@ -0,0 +1,61 @@
+/**
+ * CLI Markdown - Renders basic markdown to ANSI-formatted terminal text.
+ *
+ * Supports:
+ *   - **bold** → ANSI bold
+ *   - *italic* → ANSI italic
+ *   - `code` → ANSI cyan
+ *   - # Heading → bold + underline
+ *   - ## Heading → bold
+ *   - ### Heading → bold
+ *   - --- / ___ / *** → horizontal rule
+ */
+
+/**
+ * Convert markdown text to ANSI-formatted terminal output.
+ * @param {string} text - Raw markdown text
+ * @returns {string} ANSI-formatted text
+ */
+export function renderMarkdown(text) {
+  if (!text || typeof text !== 'string') return text;
+
+  const lines = text.split('\n');
+  const rendered = lines.map(line => renderLine(line));
+  return rendered.join('\n');
+}
+
+function renderLine(line) {
+  const trimmed = line.trim();
+
+  // Horizontal rules: ---, ___, ***
+  if (/^[-_*]{3,}\s*$/.test(trimmed)) {
+    const cols = process.stdout.columns || parseInt(process.env.COLUMNS) || 80;
+    return '\x1b[2m' + '─'.repeat(Math.min(cols, 60)) + '\x1b[0m';
+  }
+
+  // Headings
+  if (trimmed.startsWith('### ')) {
+    return '\x1b[1m' + renderInline(trimmed.substring(4)) + '\x1b[0m';
+  }
+  if (trimmed.startsWith('## ')) {
+    return '\x1b[1m' + renderInline(trimmed.substring(3)) + '\x1b[0m';
+  }
+  if (trimmed.startsWith('# ')) {
+    return '\x1b[1;4m' + renderInline(trimmed.substring(2)) + '\x1b[0m';
+  }
+
+  return renderInline(line);
+}
+
+function renderInline(text) {
+  // Inline code: `code` → cyan
+  text = text.replace(/`([^`]+)`/g, '\x1b[36m$1\x1b[39m');
+
+  // Bold: **text** → bold
+  text = text.replace(/\*\*([^*]+)\*\*/g, '\x1b[1m$1\x1b[22m');
+
+  // Italic: *text* → italic (but not ** which is already handled)
+  text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '\x1b[3m$1\x1b[23m');
+
+  return text;
+}

package/src/runtime/cli-select.js

@@ -0,0 +1,106 @@
+/**
+ * CLI Select - Simple interactive select menu using raw ANSI codes.
+ *
+ * Replaces the `prompts` library's select component to avoid
+ * interference with cli-logger's console intercept.
+ *
+ * Uses process.stdout.write exclusively — no console.log/error calls.
+ * Redraws line-by-line (no full-screen clear) to avoid flicker.
+ */
+
+import readline from 'readline';
+
+/**
+ * Show an interactive select menu.
+ * @param {string} message - The question/prompt to display
+ * @param {Array<{title: string, value: any, description?: string}>} choices
+ * @param {number} [initial=0] - Initially selected index
+ * @returns {Promise<any>} The selected choice's value, or undefined if cancelled
+ */
+export function cliSelect(message, choices, initial = 0) {
+  return new Promise((resolve) => {
+    let selected = initial;
+    const stdout = process.stdout;
+    const stdin = process.stdin;
+    let firstRender = true;
+
+    // Calculate actual terminal lines the header occupies (may wrap)
+    const termWidth = stdout.columns || 80;
+    const headerVisualLen = `? ${message} › Use arrow-keys. Return to submit.`.length;
+    const headerLines = Math.max(1, Math.ceil(headerVisualLen / termWidth));
+    const totalLines = headerLines + choices.length;
+
+    function render() {
+      // On re-render, move cursor to start of menu area and clear everything below
+      if (!firstRender) {
+        stdout.write(`\x1b[${totalLines}A`);
+        stdout.write('\x1b[J'); // Clear from cursor to end of screen
+      }
+
+      // Header line — clear line then write
+      stdout.write(`\x1b[2K? \x1b[1m${message}\x1b[0m \x1b[2m› Use arrow-keys. Return to submit.\x1b[0m\n`);
+
+      // Choices — clear each line individually then write
+      for (let i = 0; i < choices.length; i++) {
+        const choice = choices[i];
+        const desc = choice.description ? ` \x1b[2m- ${choice.description}\x1b[0m` : '';
+
+        if (i === selected) {
+          stdout.write(`\x1b[2K\x1b[36m❯   ${choice.title}${desc}\x1b[0m\n`);
+        } else {
+          stdout.write(`\x1b[2K    ${choice.title}${desc}\n`);
+        }
+      }
+
+      firstRender = false;
+    }
+
+    // Enable raw mode for keypress detection
+    readline.emitKeypressEvents(stdin);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    // Hide cursor
+    stdout.write('\x1b[?25l');
+
+    function cleanup() {
+      stdin.removeListener('keypress', onKeypress);
+      stdin.setRawMode(wasRaw);
+      // Show cursor
+      stdout.write('\x1b[?25h');
+    }
+
+    function onKeypress(str, key) {
+      if (!key) return;
+
+      if (key.name === 'up' || key.name === 'k') {
+        selected = selected > 0 ? selected - 1 : choices.length - 1;
+        render();
+      } else if (key.name === 'down' || key.name === 'j') {
+        selected = selected < choices.length - 1 ? selected + 1 : 0;
+        render();
+      } else if (key.name === 'return') {
+        cleanup();
+        // Overwrite menu with final selection (line-by-line clear)
+        stdout.write(`\x1b[${totalLines}A`);
+        stdout.write(`\x1b[2K? \x1b[1m${message}\x1b[0m \x1b[36m${choices[selected].title}\x1b[0m\n`);
+        for (let i = 1; i < totalLines; i++) {
+          stdout.write('\x1b[2K\n');
+        }
+        // Move back up past the blank lines
+        if (totalLines > 1) {
+          stdout.write(`\x1b[${totalLines - 1}A`);
+        }
+        resolve(choices[selected].value);
+      } else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        cleanup();
+        stdout.write('\n');
+        resolve(undefined);
+      }
+    }
+
+    stdin.on('keypress', onKeypress);
+    render();
+  });
+}