cowork-cli 2.2.2 → 2.4.0

package/README.md

@@ -53,7 +53,8 @@ cwk "Explain the data flow in the engine/ models"
 
 ## ✨ Features that Matter
 
-- **Zero-Whitespace UI**: High-density terminal output designed for professionals. No fluff, no headers, just data.
+- **Zero-Whitespace UI**: High-density terminal output designed for professionals. No fluff, just clean, ansi-balanced structured layouts.
+- **Rich Terminal Markdown Rendering**: Custom lightweight layout engine supporting responsive headers, bullets, blockquotes, code blocks with clean borders, and subtle horizontal rules, with full CJK visual character column matching.
 - **Interactive Feedback**: The AI can request clarifications via the `askUser` tool or trigger an interactive `[ Yes ]  No` toggle using `askConfirm`.
 - **Smart Discovery**: Built-in `searchText`, `findFile`, and `projectTree` tools that respect your `.gitignore`.
 - **Web Research**: Dynamically search the web (`webSearch`) and read documentation (`webFetch`) directly from the CLI.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-cli",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "work with cowork",
   "bin": {
     "cwk": "bin/cli.js"

package/src/configs/sys.txt

@@ -8,8 +8,14 @@ You are Cowork (cwk), an interactive CLI tool acting as a Full Engineering Read-
 
 # CONSTRAINTS (Terminal Environment)
 - NO conversational filler, pleasantries, preambles, or postambles.
-- NO Markdown (no *, `, #, or code blocks). NO XML/HTML tags.
-- Output ONLY structured, concise plain text with simple spacing/indentation.
+- Use ONLY the following supported Markdown syntax elements:
+  * Headers: # (H1), ## (H2), ### (H3)
+  * Lists: starting with -, *, + (bullets) or 1. (numbers)
+  * Blockquotes: starting with >
+  * Fenced code blocks: using ```
+  * Inline styles: **bold**, *italic* (or _italic_), `inline code`
+  * Links: [label](url)
+  * Horizontal rules: ---
 - Cite code locations using: file_path:line_number.
 
 # EXECUTION & STYLE

package/src/engine/client.js

@@ -19,7 +19,8 @@ function clientLoader() {
   return new OpenAI({
     apiKey: config.model_api_key,
     baseURL: baseURL,
-    timeout: 60000 // 60 seconds timeout
+    timeout: 60000, // 60 seconds timeout
+    maxRetries: 0,  // Disable SDK's built-in retries to prevent overlapping attempts with BaseModel's retry loop.
   });
 }
 

package/src/engine/models/BaseModel.js

@@ -1,8 +1,22 @@
 import { toolDefinitions, dispatchTool } from '../tools/index.js';
-import { logger } from '../../utils/logger.js';
+import { logger, formatMain, formatDim } from '../../utils/logger.js';
 import { ui } from '../../utils/ui.js';
 import { outputFormatted } from '../../utils/outputFormatter.js';
 
+// Defined at module scope: avoid re-allocating on every caught error.
+// Transient Node.js-level network error codes that warrant an automatic retry.
+const TRANSIENT_NET_CODES = new Set([
+  'ECONNRESET',    // Connection forcibly closed by the remote side
+  'ETIMEDOUT',     // Connection or operation timed out
+  'ECONNREFUSED',  // Remote host actively refused the connection
+  'EAI_AGAIN',     // Temporary DNS resolution failure
+  'ENETUNREACH',   // Network is unreachable
+  'EHOSTUNREACH',  // Host is unreachable
+]);
+
+// Maximum delay (ms) the backoff is allowed to reach, regardless of retry count.
+const MAX_BACKOFF_MS = 30000;
+
 /**
  * Base class for AI model interaction handlers.
  * Encapsulates message history, API calling with retries, and robust tool execution.
@@ -18,6 +32,8 @@ export default class BaseModel {
     this.messages = [];
     this.maxTurns = 15; // Safeguard against infinite tool-calling loops
     this.lastRequestTime = 0; // For proactive throttling
+    this._runStartTime = 0;
+    this._runUsage = { prompt: 0, completion: 0, total: 0 };
   }
 
   /**
@@ -36,6 +52,10 @@ export default class BaseModel {
    * @param {string|null} systemPrompt Optional system-level instructions.
    */
   async run(query, systemPrompt = null) {
+    // Reset per-run tracking state
+    this._runStartTime = performance.now();
+    this._runUsage = { prompt: 0, completion: 0, total: 0 };
+
     if (systemPrompt) {
       this.addMessage('system', systemPrompt);
     }
@@ -50,7 +70,23 @@ export default class BaseModel {
         const response = await this._getCompletion();
         ui.stop();
 
-        const message = response.choices[0].message;
+        // Guard against empty/null choices (content filter, provider quirks).
+        const choice = response.choices?.[0];
+        if (!choice?.message) {
+          logger.error("[API Error] Received empty or malformed response (no choices).");
+          return;
+        }
+        const message = choice.message;
+        const finishReason = choice.finish_reason;
+
+        // Surface meaningful finish reasons to the user instead of silent behaviour.
+        if (finishReason === 'content_filter') {
+          logger.secondary("[System]: Response was blocked by the provider's content filter.");
+          return;
+        }
+        if (finishReason === 'length') {
+          logger.secondary("[System]: Response was truncated due to token limits.");
+        }
 
         // Let subclasses handle/format the response (e.g. Gemini thought signatures)
         await this.handleResponse(message);
@@ -64,6 +100,7 @@ export default class BaseModel {
               process.stdout.write("\n");
             }
           }
+          this._printStats();
           return;
         }
 
@@ -71,7 +108,9 @@ export default class BaseModel {
         await this._processToolCalls(message.tool_calls);
 
       } catch (err) {
-        ui.stop();
+        // Use ui.fail() (red dot) instead of ui.stop() (green dot) so the
+        // terminal reflects that the turn ended in error. fail() is a no-op when IDLE.
+        ui.fail();
         // Deep error logging for API failures
         if (err.status) {
           logger.error(`[API Error] Status: ${err.status}`);
@@ -87,6 +126,7 @@ export default class BaseModel {
       }
     }
 
+    this._printStats();
     logger.secondary("[System]: Reached maximum conversation turns. Ending session.");
   }
 
@@ -118,39 +158,44 @@ export default class BaseModel {
 
         // Update last request time on successful response
         this.lastRequestTime = Date.now();
+
+        // Accumulate token usage across all turns (usage may be absent on some providers)
+        const u = response.usage;
+        if (u) {
+          this._runUsage.prompt     += u.prompt_tokens     ?? 0;
+          this._runUsage.completion += u.completion_tokens ?? 0;
+          this._runUsage.total      += u.total_tokens      ?? 0;
+        }
+
         return response;
 
       } catch (err) {
         // Transient HTTP status codes (rate-limit, server errors)
         const isHttpTransient = [429, 500, 502, 503, 504].includes(err.status);
-        // Transient Node.js-level network errors (flaky connections, DNS hiccups)
-        const TRANSIENT_NET_CODES = new Set([
-          'ECONNRESET',    // Connection forcibly closed by the remote side
-          'ETIMEDOUT',     // Connection or operation timed out
-          'ECONNREFUSED',  // Remote host actively refused the connection
-          'EAI_AGAIN',     // Temporary DNS resolution failure
-          'ENETUNREACH',   // Network is unreachable
-          'EHOSTUNREACH',  // Host is unreachable
-        ]);
         const isNetTransient = TRANSIENT_NET_CODES.has(err.code);
         const isTransient = isHttpTransient || isNetTransient;
 
         if (isTransient && retries < maxRetries) {
           retries++;
 
-          let delay = Math.pow(2, retries) * 1000;
+          // Cap exponential delay at MAX_BACKOFF_MS to prevent unbounded wait times.
+          let delay = Math.min(Math.pow(2, retries) * 1000, MAX_BACKOFF_MS);
 
           // 2. Adhere to Retry-After header if present (HTTP errors only)
           const retryAfter = err.headers?.['retry-after'];
           if (retryAfter) {
             const seconds = parseInt(retryAfter);
             if (!isNaN(seconds)) {
-              delay = seconds * 1000;
+              // Clamp to [1s, MAX_BACKOFF_MS] so a zero/negative header cannot bypass throttling
+              // and an absurd value cannot hang the process.
+              delay = Math.min(Math.max(seconds * 1000, 1000), MAX_BACKOFF_MS);
             } else {
               // Handle Date string format
               const retryDate = new Date(retryAfter);
               if (!isNaN(retryDate.getTime())) {
-                delay = Math.max(0, retryDate.getTime() - Date.now());
+                // Clamp — past dates become 1s, far-future dates are capped at MAX_BACKOFF_MS
+                // so the process can never hang indefinitely.
+                delay = Math.min(Math.max(retryDate.getTime() - Date.now(), 1000), MAX_BACKOFF_MS);
               }
             }
           }
@@ -169,6 +214,11 @@ export default class BaseModel {
         throw err;
       }
     }
+
+    // Exhaustion guard — the while loop should always return or throw before
+    // reaching here. If it doesn't (e.g. a future refactor breaks the invariant),
+    // surface an explicit error rather than returning undefined to the caller.
+    throw new Error('_getCompletion: retry loop exhausted without returning a response.');
   }
 
   /**
@@ -253,4 +303,24 @@ export default class BaseModel {
   async handleResponse(message) {
     this.messages.push(message);
   }
+
+  /**
+   * Prints a compact stats line: elapsed time and cumulative token usage.
+   * Only printed on clean exits (final answer or max-turns). Skipped on errors.
+   * Token counts are omitted silently if the provider did not return usage data.
+   * @private
+   */
+  _printStats() {
+    const elapsed = ((performance.now() - this._runStartTime) / 1000).toFixed(2);
+    const { prompt, completion, total } = this._runUsage;
+
+    const timeStr  = `${formatDim('time')} ${formatMain(elapsed + 's')}`;
+
+    // Only append token info when the provider actually returned usage data
+    const tokenStr = total > 0
+      ? ` ${formatDim('·')} ${formatDim('tokens')} ${formatMain(String(total))} ${formatDim(`(${prompt}p/${completion}c)`)}`
+      : '';
+
+    ui.log(timeStr + tokenStr);
+  }
 }

package/src/utils/logger.js

@@ -31,7 +31,7 @@ function hexToAnsi(hex) {
 
 const reset = '\x1b[0m';
 
-const colors = {
+export const colors = {
   main:    hexToAnsi(config.accents.main),
   tool:    hexToAnsi(config.accents.tool),
   data:    hexToAnsi(config.accents.data),

package/src/utils/outputFormatter.js

@@ -1,3 +1,93 @@
+import { colors } from './logger.js';
+
+const reset = '\x1b[0m';
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+function visualLength(str) {
+  if (!str) return 0;
+  const clean = stripAnsi(str);
+  let len = 0;
+  for (let i = 0; i < clean.length; i++) {
+    const code = clean.charCodeAt(i);
+    if ((code >= 0x3000 && code <= 0x9FFF) || (code >= 0xFF00 && code <= 0xFFEF)) {
+      len += 2;
+    } else {
+      len += 1;
+    }
+  }
+  return len;
+}
+
+function applyInlineStyles(str) {
+  if (!str) return '';
+
+  // 1. Inline code: `code` -> tool color (amber) + code + reset foreground color
+  str = str.replace(/`([^`]+)`/g, (match, code) => {
+    return `${colors.tool}${code}\x1b[39m`;
+  });
+
+  // 2. Bold styling: **text** -> bold terminal style + main color (blue) + text + reset
+  str = str.replace(/\*\*([^*]+)\*\*/g, (match, boldText) => {
+    return `\x1b[1m${colors.main}${boldText}\x1b[22m\x1b[39m`;
+  });
+
+  // 3. Italic/dim styling: *text* or _text_ -> dim color (grey) + text + reset foreground color
+  str = str.replace(/\*([^*]+)\*/g, (match, italicText) => {
+    return `${colors.dim}${italicText}\x1b[39m`;
+  });
+  str = str.replace(/_([^_]+)_/g, (match, italicText) => {
+    return `${colors.dim}${italicText}\x1b[39m`;
+  });
+
+  // 4. Link styling: [label](url) -> label (main/blue) + dim url (grey)
+  str = str.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, label, url) => {
+    return `${colors.main}${label}\x1b[39m ${colors.dim}(${url})\x1b[39m`;
+  });
+
+  return str;
+}
+
+function balanceAnsiStyles(wrappedLines) {
+  let activeColor = null;
+
+  return wrappedLines.map(line => {
+    let prefix = '';
+    if (activeColor) prefix += activeColor;
+
+    const ansiRegex = /\x1b\[([0-9;]*)m/g;
+    let match;
+    while ((match = ansiRegex.exec(line)) !== null) {
+      const code = match[1];
+      const parts = code.split(';');
+
+      if (parts.includes('0') || parts.includes('39')) {
+        activeColor = null;
+      }
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === '38') {
+          if (parts[i + 1] === '2' || parts[i + 1] === '5') {
+            activeColor = match[0];
+            break;
+          }
+        } else if (/^[39][0-9]$/.test(part) && part !== '39') {
+          activeColor = match[0];
+          break;
+        }
+      }
+    }
+
+    let suffix = '';
+    if (activeColor) suffix += '\x1b[39m';
+
+    return prefix + line + suffix;
+  });
+}
+
 /**
  * Wraps text to the current terminal width without breaking words unless necessary.
  * Dynamically detects terminal width and preserves whitespace/indentation.
@@ -6,52 +96,82 @@
  * @returns {string} The formatted text.
  */
 export function outputFormatted(text, overrideWidth) {
-  if (!text) return '';
+  if (text === null || text === undefined) return '';
+  // Normalize newlines, strip carriage returns, and expand tabs to preserve column alignment
+  const strText = String(text).replace(/\r/g, '').replace(/\t/g, '    ');
+  
+  let rawWidth = overrideWidth || process.stdout.columns || 80;
+  if (typeof rawWidth !== 'number' || isNaN(rawWidth) || rawWidth < 10) {
+    rawWidth = 80;
+  }
   
-  // Dynamically determine width (fallback to 80 if not detectable)
-  const width = overrideWidth || process.stdout.columns || 80;
+  let width = rawWidth;
+  if (width >= 60) {
+    width = Math.floor(width * 0.80);
+  } else {
+    width = Math.max(10, Math.floor(width * 0.95));
+  }
+  const lines = strText.split('\n');
+  const wrappedLines = [];
   
-  const lines = text.split('\n');
-  const wrappedLines = lines.map(line => {
-    if (line.length <= width) return line;
+  let inCodeBlock = false;
 
-    // Split by whitespace but keep the whitespace as tokens
-    const tokens = line.split(/(\s+)/);
+  // Helper function to wrap a string to a specific width (ANSI and wide-char aware)
+  function wrapString(content, wrapWidth) {
+    const safeWidth = Math.max(5, wrapWidth);
+    if (visualLength(content) <= safeWidth) return [content];
+    
+    const tokens = content.split(/(\s+)/);
     const result = [];
     let currentLine = '';
 
     for (const token of tokens) {
       if (!token) continue;
 
-      // If adding this token exceeds width
-      if ((currentLine + token).length > width) {
-        
-        // If it's a long word (not whitespace) that exceeds the entire width
-        if (token.length > width && !/^\s+$/.test(token)) {
-          // If we have content in currentLine, push it first
+      const tokenLen = visualLength(token);
+      const currentLineLen = visualLength(currentLine);
+
+      if (currentLineLen + tokenLen > safeWidth) {
+        // If it's a long word that exceeds the entire width
+        if (tokenLen > safeWidth && !/^\s+$/.test(token)) {
           if (currentLine) {
             result.push(currentLine.trimEnd());
             currentLine = '';
           }
           
-          // Force-break the long word
           let remainingWord = token;
-          while (remainingWord.length > width) {
-            result.push(remainingWord.substring(0, width));
-            remainingWord = remainingWord.substring(width);
+          while (visualLength(remainingWord) > safeWidth) {
+            let visibleChars = 0;
+            let splitIdx = 0;
+            while (visibleChars < safeWidth && splitIdx < remainingWord.length) {
+              if (remainingWord.startsWith('\x1b[', splitIdx)) {
+                const endEsc = remainingWord.indexOf('m', splitIdx);
+                if (endEsc !== -1) {
+                  splitIdx = endEsc + 1;
+                  continue;
+                }
+              }
+              const code = remainingWord.charCodeAt(splitIdx);
+              const isWide = (code >= 0x3000 && code <= 0x9FFF) || (code >= 0xFF00 && code <= 0xFFEF);
+              if (visibleChars + (isWide ? 2 : 1) > safeWidth) {
+                break;
+              }
+              visibleChars += isWide ? 2 : 1;
+              splitIdx++;
+            }
+            result.push(remainingWord.substring(0, splitIdx));
+            remainingWord = remainingWord.substring(splitIdx);
           }
           currentLine = remainingWord;
         } 
-        // If it's whitespace that causes overflow, just wrap to next line
+        // If it's whitespace that causes overflow
         else if (/^\s+$/.test(token)) {
           if (currentLine) {
             result.push(currentLine.trimEnd());
             currentLine = '';
           }
-          // Do not start a new line with just spaces if it was leading spaces for a wrapped line
-          // (Unless they are the very first spaces on a line, which we handled)
-        }
-        // If it's a normal word that exceeds width, push currentLine and start new with this word
+        } 
+        // Normal word that causes overflow
         else {
           if (currentLine) {
             result.push(currentLine.trimEnd());
@@ -59,14 +179,154 @@ export function outputFormatted(text, overrideWidth) {
           currentLine = token;
         }
       } else {
-        // Just append the token (word or whitespace)
         currentLine += token;
       }
     }
     
     if (currentLine) result.push(currentLine.trimEnd());
-    return result.join('\n');
-  });
+    return result.length > 0 ? result : [''];
+  }
+
+  for (const line of lines) {
+    // Check if the line already contains ANSI escape formatting (e.g., pre-colored command outputs)
+    const hasAnsi = /\x1b\[[0-9;]*[a-zA-Z]/.test(line);
+    if (hasAnsi) {
+      const wrappedSegments = wrapString(line, width);
+      const balancedSegments = balanceAnsiStyles(wrappedSegments);
+      for (const segment of balancedSegments) {
+        wrappedLines.push(segment);
+      }
+      continue;
+    }
+
+    // 1. Detect Horizontal Rules (e.g., ---, ***, ___ )
+    if (line.match(/^(\s*)([-*_])\2\2+(\s*)$/)) {
+      const dividerWidth = Math.min(40, width);
+      const padding = ' '.repeat(Math.max(0, Math.floor((width - dividerWidth) / 2)));
+      wrappedLines.push(`${padding}${colors.dim}${'· '.repeat(dividerWidth / 2)}${reset}`);
+      continue;
+    }
+
+    // 2. Detect code block boundaries
+    if (line.trim().startsWith('```')) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        const lang = line.trim().substring(3) || 'code';
+        const borderLength = Math.max(5, Math.min(30, width - lang.length - 7));
+        wrappedLines.push(`${colors.dim}┌── [${colors.tool}${lang}${colors.dim}] ${'─'.repeat(borderLength)}${reset}`);
+      } else {
+        inCodeBlock = false;
+        const borderLength = Math.max(5, Math.min(30, width - 4));
+        wrappedLines.push(`${colors.dim}└───${'─'.repeat(borderLength)}${reset}`);
+      }
+      continue;
+    }
+
+    // 3. If in code block, preserve line with vertical boundary
+    if (inCodeBlock) {
+      wrappedLines.push(`${colors.dim}│ ${reset}${line}`);
+      continue;
+    }
+
+    // 4. Check for Markdown Headers: # Header
+    const headerMatch = line.match(/^(#+)\s*(.*)/);
+    if (headerMatch) {
+      const level = headerMatch[1].length;
+      const title = headerMatch[2];
+      const symbol = level === 1 ? '◆' : level === 2 ? '◇' : '◈';
+      const wrapWidth = Math.max(10, width - 2); // 2 is symbol + space
+      const wrappedTitle = wrapString(title, wrapWidth);
+      const baseColor = colors.header;
+
+      if (wrappedTitle.length > 0) {
+        const formattedFirst = applyInlineStyles(wrappedTitle[0]).replace(/\x1b\[39m/g, `\x1b[39m${baseColor}`);
+        wrappedLines.push(`${colors.header}${symbol} ${baseColor}${formattedFirst}${reset}`);
+        for (let i = 1; i < wrappedTitle.length; i++) {
+          const formattedSub = applyInlineStyles(wrappedTitle[i]).replace(/\x1b\[39m/g, `\x1b[39m${baseColor}`);
+          wrappedLines.push(`  ${baseColor}${formattedSub}${reset}`);
+        }
+      }
+      continue;
+    }
+
+
+
+    // 5. Check for List Item structure: bullets (- * +) or numbering (e.g., 1. or 1.1.)
+    const listMatch = line.match(/^(\s*)([-*+]\s|\d+(\.\d+)*\.\s)/);
+    if (listMatch) {
+      const prefix = listMatch[0];
+      const content = line.substring(prefix.length);
+      const wrapWidth = Math.max(10, width - prefix.length);
+      const formattedContent = applyInlineStyles(content);
+      const wrappedSegments = wrapString(formattedContent, wrapWidth);
+
+      let formattedPrefix = prefix;
+      const bulletMatch = prefix.match(/^(\s*)([-*+])(\s)/);
+      if (bulletMatch) {
+        const bulletSymbol = bulletMatch[2] === '-' ? '•' : bulletMatch[2] === '*' ? '◦' : '▪';
+        formattedPrefix = `${bulletMatch[1]}${colors.main}${bulletSymbol}${reset}${bulletMatch[3]}`;
+      } else {
+        const numberMatch = prefix.match(/^(\s*)(\d+(\.\d+)*\.)(\s)/);
+        if (numberMatch) {
+          formattedPrefix = `${numberMatch[1]}${colors.main}${numberMatch[2]}${reset}${numberMatch[4]}`;
+        }
+      }
+
+      const balancedSegments = balanceAnsiStyles(wrappedSegments);
+      wrappedLines.push(formattedPrefix + balancedSegments[0]);
+      const hangingIndent = ' '.repeat(prefix.length);
+      for (let i = 1; i < balancedSegments.length; i++) {
+        wrappedLines.push(hangingIndent + balancedSegments[i]);
+      }
+      continue;
+    }
+
+    // 6. Check for Blockquote structure
+    const quoteMatch = line.match(/^(\s*)(>\s?)/);
+    if (quoteMatch) {
+      const prefix = quoteMatch[0];
+      const content = line.substring(prefix.length);
+      const wrapWidth = Math.max(10, width - prefix.length);
+      const baseColor = colors.dim;
+      
+      // Prefix quote content with baseColor and restore it after any inline color resets
+      const formattedContent = `${baseColor}${applyInlineStyles(content).replace(/\x1b\[39m/g, `\x1b[39m${baseColor}`)}${reset}`;
+      const wrappedSegments = wrapString(formattedContent, wrapWidth);
+
+      // Use dim color for the vertical bar to make blockquotes feel integrated and soft
+      const formattedPrefix = prefix.replace(/>\s?/, `${colors.dim}│ ${reset}`);
+      const balancedSegments = balanceAnsiStyles(wrappedSegments);
+
+      for (const segment of balancedSegments) {
+        wrappedLines.push(formattedPrefix + segment);
+      }
+      continue;
+    }
+
+    // 7. Check for Indented paragraph structure
+    const indentMatch = line.match(/^(\s+)/);
+    if (indentMatch) {
+      const prefix = indentMatch[0];
+      const content = line.substring(prefix.length);
+      const wrapWidth = Math.max(10, width - prefix.length);
+      const formattedContent = applyInlineStyles(content);
+      const wrappedSegments = wrapString(formattedContent, wrapWidth);
+      const balancedSegments = balanceAnsiStyles(wrappedSegments);
+
+      for (const segment of balancedSegments) {
+        wrappedLines.push(prefix + segment);
+      }
+      continue;
+    }
+
+    // 8. Fallback: plain text paragraph
+    const formatted = applyInlineStyles(line);
+    const wrappedSegments = wrapString(formatted, width);
+    const balancedSegments = balanceAnsiStyles(wrappedSegments);
+    for (const segment of balancedSegments) {
+      wrappedLines.push(segment);
+    }
+  }
 
   return wrappedLines.join('\n');
 }