@iinm/plain-agent 1.10.2 → 1.10.4

package/src/{cliFormatter.mjs → cli/formatter.mjs}

@@ -1,19 +1,19 @@
 /**
- * @import { Message, MessageContentToolUse, MessageContentToolResult, ProviderTokenUsage } from "./model"
- * @import { CompactContextInput } from "./tools/compactContext"
- * @import { ExecCommandInput } from "./tools/execCommand"
- * @import { PatchBlock, PatchFileInput } from "./tools/patchFile"
- * @import { ReadFileInput } from "./tools/readFile"
- * @import { WriteFileInput } from "./tools/writeFile"
- * @import { TmuxCommandInput } from "./tools/tmuxCommand"
- * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
+ * @import { Message, MessageContentToolUse, MessageContentToolResult, ProviderTokenUsage } from "../model"
+ * @import { CompactContextInput } from "../tools/compactContext"
+ * @import { ExecCommandInput } from "../tools/execCommand"
+ * @import { PatchBlock, PatchFileInput } from "../tools/patchFile"
+ * @import { ReadFileInput } from "../tools/readFile"
+ * @import { WriteFileInput } from "../tools/writeFile"
+ * @import { TmuxCommandInput } from "../tools/tmuxCommand"
+ * @import { SwitchToSubagentInput } from "../tools/switchToSubagent"
  */
 
 import fs from "node:fs/promises";
 import { styleText } from "node:util";
-import { parseBlocks } from "./tools/patchFile.mjs";
-import { diffLines } from "./utils/diffLines.mjs";
-import { noThrow } from "./utils/noThrow.mjs";
+import { parseBlocks } from "../tools/patchFile.mjs";
+import { diffLines } from "../utils/diffLines.mjs";
+import { noThrow } from "../utils/noThrow.mjs";
 
 /** Length above which a single-line arg forces block-form rendering. */
 const ARG_BLOCK_LENGTH_THRESHOLD = 60;
@@ -144,7 +144,7 @@ export async function formatToolUse(toolUse) {
   }
 
   if (toolName === "switch_to_main_agent") {
-    /** @type {Partial<import("./tools/switchToMainAgent").SwitchToMainAgentInput>} */
+    /** @type {Partial<import("../tools/switchToMainAgent").SwitchToMainAgentInput>} */
     const switchToMainAgentInput = input;
     return [
       `tool: ${toolName}`,
@@ -153,7 +153,7 @@ export async function formatToolUse(toolUse) {
   }
 
   if (toolName === "web_search") {
-    /** @type {Partial<import("./tools/webSearch.mjs").WebSearchInput>} */
+    /** @type {Partial<import("../tools/webSearch.mjs").WebSearchInput>} */
     const webSearchInput = input;
     const searchesLine = webSearchInput.searches
       ? webSearchInput.searches.map((s) => s.keywords.join(" ")).join(" | ")
@@ -166,7 +166,7 @@ export async function formatToolUse(toolUse) {
   }
 
   if (toolName === "web_fetch") {
-    /** @type {Partial<import("./tools/webFetch.mjs").WebFetchInput>} */
+    /** @type {Partial<import("../tools/webFetch.mjs").WebFetchInput>} */
     const webFetchInput = input;
     return [
       `tool: ${toolName}`,
@@ -296,7 +296,7 @@ export function formatProviderTokenUsage(usage) {
 
 /**
  * Format cost summary for interactive display
- * @param {import("./costTracker.mjs").CostSummary} summary
+ * @param {import("../costTracker.mjs").CostSummary} summary
  * @returns {string}
  */
 export function formatCostSummary(summary) {
@@ -334,7 +334,7 @@ export function formatCostSummary(summary) {
 
 /**
  * Format cost for batch mode JSON output
- * @param {import("./costTracker.mjs").CostSummary} summary
+ * @param {import("../costTracker.mjs").CostSummary} summary
  */
 export function formatCostForBatch(summary) {
   if (!summary || Object.keys(summary.breakdown).length === 0) {
@@ -428,6 +428,348 @@ export async function printMessage(message) {
     }
   }
 }
+/**
+ * Format markdown table lines with aligned columns.
+ * Input lines may have leading/trailing pipes.
+ * Output always has leading and trailing pipes with padded cells.
+ * When the table would exceed `maxWidth`, long cells are wrapped onto
+ * additional visual lines so the table stays within the terminal width.
+ * @param {string[]} lines - Raw table lines (including alignment row)
+ * @param {number} [maxWidth=Infinity] - Maximum terminal display width
+ * @returns {string} - Formatted table string with aligned columns
+ */
+export function formatMarkdownTable(
+  lines,
+  maxWidth = Number.POSITIVE_INFINITY,
+) {
+  if (lines.length === 0) return "";
+
+  const rows = lines.map(splitTableRow);
+
+  // Calculate max display width for each column (natural width)
+  const colCount = Math.max(...rows.map((r) => r.length));
+  /** @type {number[]} */
+  const naturalWidths = new Array(colCount).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const width = charDisplayWidth(row[i]);
+      if (width > naturalWidths[i]) {
+        naturalWidths[i] = width;
+      }
+    }
+  }
+
+  // Determine column widths that fit within maxWidth
+  const colWidths = fitColumns(naturalWidths, colCount, maxWidth);
+
+  // Check if wrapping is needed (any column was shrunk)
+  const needsWrapping = colWidths.some((w, i) => w < naturalWidths[i]);
+
+  if (!needsWrapping) {
+    // Original path: no wrapping, just pad and join
+    return rows
+      .map((row) => {
+        const fullRow = row.concat(new Array(colCount - row.length).fill(""));
+        const padded = fullRow.map((cell, i) =>
+          padCell(cell, colWidths[i] ?? 0),
+        );
+        return `| ${padded.join(" | ")} |`;
+      })
+      .join("\n");
+  }
+
+  // Wrapped path: wrap cells and render multi-line rows
+  const wrappedRows = rows.map((row) => {
+    const fullRow = row.concat(new Array(colCount - row.length).fill(""));
+    const isSeparator = isSeparatorRow(fullRow);
+    return fullRow.map((cell, i) => {
+      if (isSeparator) {
+        // Regenerate separator dashes to fit the column width (no wrapping)
+        return ["-".repeat(colWidths[i])];
+      }
+      return wrapCell(cell, colWidths[i]);
+    });
+  });
+
+  return wrappedRows
+    .map((wrappedCells) => renderWrappedRow(wrappedCells, colWidths))
+    .join("\n");
+}
+
+/**
+ * Check if a row is a markdown table separator row.
+ * A separator row contains only dashes, colons, and spaces
+ * (e.g., "------", ":----:", "-----:", ":-----").
+ * @param {string[]} cells
+ * @returns {boolean}
+ */
+function isSeparatorRow(cells) {
+  return cells.length > 0 && cells.every((cell) => /^[-: ]+$/.test(cell));
+}
+
+/**
+ * Determine column widths that fit within maxWidth.
+ * If the natural total width fits, returns natural widths unchanged.
+ * Otherwise, shrinks columns proportionally (minimum 3 chars each).
+ * Returns null in any entry if the table cannot fit at all (fallback signal).
+ * @param {number[]} naturalWidths - Natural (max content) width per column
+ * @param {number} colCount - Number of columns
+ * @param {number} maxWidth - Available terminal width
+ * @returns {number[]} - Target width per column
+ */
+function fitColumns(naturalWidths, colCount, maxWidth) {
+  const gutter = 4 + (colCount - 1) * 3; // "| " + " |" + inter-column " | "
+  const available = maxWidth - gutter;
+
+  // If natural widths fit, use them as-is
+  const totalNatural = naturalWidths.reduce((s, w) => s + w, 0);
+  if (totalNatural <= available || maxWidth === Number.POSITIVE_INFINITY) {
+    return naturalWidths;
+  }
+
+  // Shrink: allocate minimum width first, then distribute remainder proportionally
+  const minWidth = 3;
+  const minTotal = minWidth * colCount;
+
+  if (minTotal > available) {
+    // Cannot fit even at minimum — return natural widths (will overflow)
+    return naturalWidths;
+  }
+
+  const result = naturalWidths.map(() => minWidth);
+  const remaining = available - minTotal;
+
+  // Distribute remaining space proportionally to natural widths
+  const naturalTotalAboveMin = naturalWidths.reduce(
+    (s, w) => s + Math.max(0, w - minWidth),
+    0,
+  );
+
+  if (naturalTotalAboveMin > 0) {
+    for (let i = 0; i < colCount; i++) {
+      const aboveMin = Math.max(0, naturalWidths[i] - minWidth);
+      const share = Math.round((aboveMin / naturalTotalAboveMin) * remaining);
+      result[i] = minWidth + share;
+    }
+
+    // Adjust for rounding: distribute leftover pixels to widest columns
+    const currentTotal = result.reduce((s, w) => s + w, 0);
+    let diff = available - currentTotal;
+    // Sort column indices by natural width descending for fair distribution
+    const sortedIndices = naturalWidths
+      .map((w, i) => /** @type {[number, number]} */ ([i, w]))
+      .sort((a, b) => b[1] - a[1])
+      .map(([i]) => i);
+    let idx = 0;
+    while (diff > 0) {
+      result[sortedIndices[idx % colCount]]++;
+      diff--;
+      idx++;
+    }
+    while (diff < 0) {
+      result[sortedIndices[idx % colCount]]--;
+      diff++;
+      idx++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Wrap a cell's content to fit within the given display width.
+ * Respects ANSI escape codes (does not break them) and CJK wide characters.
+ * @param {string} text - Cell content (may contain ANSI codes)
+ * @param {number} width - Maximum display width per line
+ * @returns {string[]} - Array of visual lines for this cell
+ */
+function wrapCell(text, width) {
+  if (width <= 0) return [text];
+  const textWidth = charDisplayWidth(text);
+  if (textWidth <= width) return [text];
+
+  // Build segments: each segment is either an ANSI escape code or a visible character
+  /** @type {{ text: string, displayWidth: number }[]} */
+  const segments = [];
+  let i = 0;
+  while (i < text.length) {
+    // Check for ANSI escape sequence
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape code pattern
+    const ansiMatch = text.slice(i).match(/^\u001b\[[0-9;]*m/);
+    if (ansiMatch) {
+      segments.push({ text: ansiMatch[0], displayWidth: 0 });
+      i += ansiMatch[0].length;
+    } else {
+      const ch = text[i];
+      const code = /** @type {number} */ (ch.codePointAt(0));
+      const isWide = isWideChar(code);
+      segments.push({ text: ch, displayWidth: isWide ? 2 : 1 });
+      i++;
+    }
+  }
+
+  // Group segments into lines
+  /** @type {string[]} */
+  const lines = [];
+  /** @type {string} */
+  let currentLine = "";
+  let currentWidth = 0;
+
+  for (const seg of segments) {
+    if (seg.displayWidth === 0) {
+      // ANSI code: attach to current line without increasing width
+      currentLine += seg.text;
+      continue;
+    }
+
+    if (currentWidth + seg.displayWidth > width) {
+      // This character would overflow — start a new line
+      lines.push(currentLine);
+      currentLine = seg.text;
+      currentWidth = seg.displayWidth;
+    } else {
+      currentLine += seg.text;
+      currentWidth += seg.displayWidth;
+    }
+  }
+
+  if (currentLine.length > 0 || lines.length === 0) {
+    lines.push(currentLine);
+  }
+
+  return lines;
+}
+
+/**
+ * Sorted, merged [start, end] ranges of Unicode code points with
+ * East_Asian_Width property "W" (Wide) or "F" (Fullwidth).
+ *
+ * Generated by: node scripts/fetchEastAsianWideRanges.mjs
+ * Source: https://www.unicode.org/Public/16.0.0/ucd/EastAsianWidth.txt
+ */
+import WIDE_RANGES from "./eastAsianWideRanges.json" with { type: "json" };
+
+/**
+ * Check if a Unicode code point is a wide (double-width) character.
+ * Uses binary search over the sorted WIDE_RANGES for efficiency.
+ * @param {number} code
+ * @returns {boolean}
+ */
+function isWideChar(code) {
+  let lo = 0;
+  let hi = WIDE_RANGES.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >>> 1;
+    const [start, end] = WIDE_RANGES[mid];
+    if (code < start) hi = mid - 1;
+    else if (code > end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+}
+
+/**
+ * Render a wrapped row (where cells may span multiple visual lines).
+ * Each cell's visual lines are padded to the column width, and cells
+ * are aligned horizontally across visual lines.
+ * @param {string[][]} wrappedCells - Array of visual-line arrays per cell
+ * @param {number[]} colWidths - Target display width per column
+ * @returns {string} - Rendered row (may contain embedded newlines)
+ */
+function renderWrappedRow(wrappedCells, colWidths) {
+  const maxLines = Math.max(...wrappedCells.map((c) => c.length));
+  const visualLines = [];
+  for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+    const parts = wrappedCells.map((cell, colIdx) => {
+      const text = cell[lineIdx] ?? "";
+      return padCell(text, colWidths[colIdx]);
+    });
+    visualLines.push(`| ${parts.join(" | ")} |`);
+  }
+  return visualLines.join("\n");
+}
+
+/** @type {RegExp} - ANSI escape code pattern */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape code pattern
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+
+/**
+ * Strip ANSI escape codes for display width calculation.
+ * @param {string} str
+ * @returns {string}
+ */
+function stripAnsiCodes(str) {
+  return str.replace(ANSI_RE, "");
+}
+
+/**
+ * Calculate the terminal display width of a string.
+ * CJK full-width characters and emoji count as 2 columns; ASCII as 1.
+ * ANSI escape codes are stripped before measurement.
+ * @param {string} str
+ * @returns {number}
+ */
+function charDisplayWidth(str) {
+  const plain = stripAnsiCodes(str);
+  let width = 0;
+  for (const ch of plain) {
+    const code = /** @type {number} */ (ch.codePointAt(0));
+    width += isWideChar(code) ? 2 : 1;
+  }
+  return width;
+}
+
+/**
+ * Split a markdown table row into cells.
+ * Removes leading/trailing pipes, splits by `|`.
+ * Respects escaped pipes (`\|`).
+ * @param {string} line
+ * @returns {string[]}
+ */
+function splitTableRow(line) {
+  const trimmed = line.trim();
+  // Remove leading and trailing pipes
+  let inner;
+  if (trimmed.startsWith("|") && trimmed.endsWith("|")) {
+    inner = trimmed.slice(1, -1);
+  } else if (trimmed.startsWith("|")) {
+    inner = trimmed.slice(1);
+  } else if (trimmed.endsWith("|")) {
+    inner = trimmed.slice(0, -1);
+  } else {
+    inner = trimmed;
+  }
+
+  // Split by pipe, respecting escaped pipes
+  /** @type {string[]} */
+  const cells = [];
+  let current = "";
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "\\" && i + 1 < inner.length && inner[i + 1] === "|") {
+      current += "|";
+      i++;
+    } else if (inner[i] === "|") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += inner[i];
+    }
+  }
+  cells.push(current);
+  return cells.map((c) => c.trim());
+}
+
+/**
+ * Pad a cell string with trailing spaces to the given display width.
+ * @param {string} cell - Original cell content (may contain ANSI codes)
+ * @param {number} targetWidth - Target display width
+ * @returns {string}
+ */
+function padCell(cell, targetWidth) {
+  const currentWidth = charDisplayWidth(cell);
+  if (currentWidth >= targetWidth) return cell;
+  return cell + " ".repeat(targetWidth - currentWidth);
+}
 
 /**
  * Render a patch_file `patch` string for terminal display.
@@ -455,7 +797,11 @@ async function renderPatch(filePath, patch) {
   let blocks;
   try {
     blocks = parseBlocks(patch, nonce);
-  } catch {
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(
+      styleText("yellow", `Warning: Patch parsing failed: ${message}`),
+    );
     return fallback;
   }
 
@@ -485,7 +831,7 @@ function renderPatchBlock(block, originalLines, nonce) {
     out.push(
       styleText(
         "cyan",
-        `@@@ ${nonce} ${block.start}:${block.startHash}-${block.end}:${block.endHash}`,
+        `>>> ${nonce} ${block.start}:${block.startHash}-${block.end}:${block.endHash}`,
       ),
     );
     if (originalLines) {
@@ -513,12 +859,12 @@ function renderPatchBlock(block, originalLines, nonce) {
     }
   } else {
     const afterSuffix = block.afterHash ? `:${block.afterHash}` : "";
-    out.push(styleText("cyan", `@@@ ${nonce} ${block.after}${afterSuffix}+`));
+    out.push(styleText("cyan", `>>> ${nonce} ${block.after}${afterSuffix}+`));
     for (const line of block.body) {
       out.push(styleText("green", `+ ${line}`));
     }
   }
-  out.push(styleText("cyan", `@@@ ${nonce}`));
+  out.push(styleText("cyan", `<<< ${nonce}`));
   return out.join("\n");
 }
 
@@ -532,8 +878,8 @@ function highlightPatchPlain(patch) {
   if (!patch) {
     return "";
   }
-  // Patch headers/closes look like "@@@ <nonce> ..." or "@@@ <nonce>".
-  const headerRegex = /^@@@\s+\S+(\s.*)?$/;
+  // Patch open/close markers look like ">>> <nonce> ..." or "<<< <nonce>".
+  const headerRegex = /^(>>>|<<<)\s+\S+(\s.*)?$/;
   return patch
     .split("\n")
     .map((line) => {
@@ -554,7 +900,7 @@ function highlightPatchPlain(patch) {
  * @returns {string | null}
  */
 function extractPatchNonce(patch) {
-  const match = patch.match(/^@@@\s+(\S+)/m);
+  const match = patch.match(/^>>>\s+(\S+)/m);
   return match ? match[1] : null;
 }
 

package/src/{cliInteractive.mjs → cli/interactive.mjs}

@@ -1,25 +1,28 @@
 /**
- * @import { UserEventEmitter, AgentEventEmitter, AgentCommands } from "./agent"
- * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
- * @import { VoiceInputConfig, VoiceSession } from "./voiceInput.mjs"
+ * @import { UserEventEmitter, AgentEventEmitter, AgentCommands } from "../agent"
+ * @import { ClaudeCodePlugin } from "../claudeCodePlugin.mjs"
+ * @import { VoiceInputConfig } from "../voice/input.mjs"
+ * @import { VoiceSession } from "../voice/session.mjs"
  */
 
 import readline from "node:readline";
 import { styleText } from "node:util";
-import { createCommandHandler } from "./cliCommands.mjs";
-import { createCompleter, SLASH_COMMANDS } from "./cliCompleter.mjs";
+import { appendUsageRecord, buildUsageRecord } from "../usageStore.mjs";
+import { createSequentialExecutor } from "../utils/createSequentialExecutor.mjs";
+import { notify } from "../utils/notify.mjs";
+import { startVoiceSession } from "../voice/input.mjs";
+import { parseVoiceToggleKey } from "../voice/toggleKey.mjs";
+import { createCommandHandler } from "./commands.mjs";
+import { createCompleter, SLASH_COMMANDS } from "./completer.mjs";
 import {
   formatCostSummary,
   formatProviderTokenUsage,
   printMessage,
-} from "./cliFormatter.mjs";
-import { createInterruptTransform } from "./cliInterruptTransform.mjs";
-import { createMuteTransform } from "./cliMuteTransform.mjs";
-import { createPasteHandler } from "./cliPasteTransform.mjs";
-import { appendUsageRecord, buildUsageRecord } from "./usageStore.mjs";
-import { createSequentialExecutor } from "./utils/createSequentialExecutor.mjs";
-import { notify } from "./utils/notify.mjs";
-import { parseVoiceToggleKey, startVoiceSession } from "./voiceInput.mjs";
+} from "./formatter.mjs";
+import { createInterruptTransform } from "./interruptTransform.mjs";
+import { createMuteTransform } from "./muteTransform.mjs";
+import { createPasteHandler } from "./pasteTransform.mjs";
+import { createTableDetector } from "./tableDetector.mjs";
 
 const HELP_MESSAGE = [
   "Commands:",
@@ -70,7 +73,7 @@ const HELP_MESSAGE = [
  * Persist the session's cost summary to the usage log.
  * Failures are logged but never thrown so exit is not blocked.
  *
- * @param {import("./costTracker.mjs").CostSummary} summary
+ * @param {import("../costTracker.mjs").CostSummary} summary
  * @param {{ sessionId: string, modelName: string, startTime: Date }} meta
  */
 async function persistUsage(summary, { sessionId, modelName, startTime }) {
@@ -122,6 +125,9 @@ export function startInteractiveSession({
    */
   let voice = null;
 
+  // Create the table buffer instance for this session
+  const tableBuffer = createTableBuffer();
+
   // Parse the voice toggle key once at startup so misconfiguration fails
   // loudly instead of silently falling back.
   const voiceToggle = parseVoiceToggleKey(voiceInput?.toggleKey);
@@ -465,6 +471,8 @@ export function startInteractiveSession({
     if (partialContent.content) {
       if (partialContent.type === "tool_use") {
         process.stdout.write(styleText("gray", partialContent.content));
+      } else if (partialContent.type === "text") {
+        tableBuffer.feed(partialContent.content);
       } else {
         process.stdout.write(partialContent.content);
       }
@@ -520,6 +528,9 @@ export function startInteractiveSession({
   });
 
   agentEventEmitter.on("turnEnd", async () => {
+    // Flush any remaining table buffer content
+    tableBuffer.forceFlush();
+
     const err = notify(notifyCmd);
     if (err) {
       console.error(
@@ -543,3 +554,26 @@ export function startInteractiveSession({
   process.on("exit", cleanup);
   process.on("SIGTERM", cleanup);
 }
+
+/**
+ * Creates a table buffer for detecting and formatting markdown tables
+ * in streaming text output.
+ * Thin shell: delegates pure logic to createTableDetector and handles I/O.
+ */
+function createTableBuffer() {
+  const detector = createTableDetector();
+
+  function feed(/** @type {string} */ chunk) {
+    const { output, warnings } = detector.feed(chunk);
+    for (const s of output) process.stdout.write(s);
+    for (const w of warnings) console.error(styleText("yellow", w));
+  }
+
+  function forceFlush() {
+    const { output, warnings } = detector.forceFlush();
+    for (const s of output) process.stdout.write(s);
+    for (const w of warnings) console.error(styleText("yellow", w));
+  }
+
+  return { feed, forceFlush };
+}