agent-sh 0.15.0 → 0.15.2

package/src/utils/markdown.ts

@@ -0,0 +1,437 @@
+import { visibleLen, truncateAnsiToWidth, padEndToWidth, charWidth } from "./ansi.js";
+import { palette as p } from "./palette.js";
+
+export const MAX_CONTENT_WIDTH = 90;
+
+// CJK line-breaking rules: closing punctuation must not start a line,
+// opening punctuation must not end a line. Both CJK fullwidth and ASCII
+// equivalents are included so mixed text wraps correctly.
+const CJK_NO_LINE_START = new Set([
+  "。", "，", "、", "．", "；", "：", "！", "？",
+  "）", "」", "』", "】", "》", "〉", "〕", "］", "｝",
+  "・", "々", "〜", "～", "ー",
+  ".", ",", ";", ":", "!", "?", ")", "]", "}",
+]);
+
+const CJK_NO_LINE_END = new Set([
+  "（", "「", "『", "【", "《", "〈", "〔", "［", "｛",
+  "(", "[", "{",
+]);
+
+/**
+ * Tokenize a visible-text run into units suitable for wrapping.
+ * Each width-2 character (CJK, fullwidth, emoji) becomes its own token so the
+ * wrapper can break between them; ASCII runs stay together as word tokens.
+ */
+function tokenizeVisible(text: string): string[] {
+  const tokens: string[] = [];
+  let ascii = "";
+  const flush = () => { if (ascii) { tokens.push(ascii); ascii = ""; } };
+  let i = 0;
+  while (i < text.length) {
+    const cp = text.codePointAt(i) ?? 0;
+    const chLen = cp > 0xffff ? 2 : 1;
+    const ch = text.slice(i, i + chLen);
+    if (ch === " ") {
+      flush();
+      let spaces = "";
+      while (i < text.length && text[i] === " ") { spaces += " "; i += 1; }
+      tokens.push(spaces);
+      continue;
+    }
+    if (charWidth(cp) === 2) {
+      flush();
+      tokens.push(ch);
+      i += chLen;
+      continue;
+    }
+    ascii += ch;
+    i += chLen;
+  }
+  flush();
+  return tokens;
+}
+
+/**
+ * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
+ * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ *
+ * Handles CJK text by breaking between wide characters and applying basic
+ * CJK rules (closing punctuation sticks to the previous line; opening
+ * punctuation sticks to the next).
+ */
+export function wrapLine(text: string, maxWidth: number): string[] {
+  if (!(maxWidth > 0)) return [text]; // catches NaN, <=0, undefined
+  if (visibleLen(text) <= maxWidth) return [text];
+
+  const result: string[] = [];
+  const segments = text.match(/(\x1b\[[^m]*m|[^\x1b]+)/g) || [text];
+
+  let lineTokens: string[] = [];
+  let lineWidth = 0;
+  let activeStyles = "";
+  let lastVisibleIdx = -1;
+
+  const commit = () => {
+    result.push(lineTokens.join("") + p.reset);
+    lineTokens = activeStyles ? [activeStyles] : [];
+    lineWidth = 0;
+    lastVisibleIdx = -1;
+  };
+
+  for (const seg of segments) {
+    if (seg.startsWith("\x1b[")) {
+      lineTokens.push(seg);
+      if (seg === p.reset) activeStyles = "";
+      else activeStyles += seg;
+      continue;
+    }
+
+    for (const token of tokenizeVisible(seg)) {
+      const tokenWidth = visibleLen(token);
+      const isSpace = token[0] === " ";
+
+      if (lineWidth + tokenWidth <= maxWidth) {
+        lineTokens.push(token);
+        lineWidth += tokenWidth;
+        if (!isSpace) lastVisibleIdx = lineTokens.length - 1;
+        continue;
+      }
+
+      // Token doesn't fit on the current line.
+      if (isSpace) continue; // spaces at wrap points are dropped
+
+      if (lineWidth === 0) {
+        // Token longer than the entire line — hard-break by char width.
+        let remaining = token;
+        while (remaining.length > 0) {
+          let fitLen = 0, fitWidth = 0;
+          for (const ch of remaining) {
+            const cw = charWidth(ch.codePointAt(0) ?? 0);
+            if (fitWidth + cw > maxWidth) break;
+            fitWidth += cw;
+            fitLen += ch.length;
+          }
+          if (fitLen === 0) fitLen = remaining[0]?.length ?? 1;
+          const chunk = remaining.slice(0, fitLen);
+          remaining = remaining.slice(fitLen);
+          lineTokens.push(chunk);
+          lineWidth += visibleLen(chunk);
+          lastVisibleIdx = lineTokens.length - 1;
+          if (remaining.length > 0) commit();
+        }
+        continue;
+      }
+
+      // Rule (a): closing punctuation must not start a line. Allow up to 2
+      // columns of overflow so the punctuation stays with its phrase.
+      if (CJK_NO_LINE_START.has(token)) {
+        lineTokens.push(token);
+        lineWidth += tokenWidth;
+        commit();
+        continue;
+      }
+
+      // Rule (b): opening punctuation must not end a line. Pull the trailing
+      // opener down to the next line with us.
+      let carried: string[] = [];
+      if (lastVisibleIdx >= 0 && CJK_NO_LINE_END.has(lineTokens[lastVisibleIdx]!)) {
+        carried = lineTokens.splice(lastVisibleIdx);
+        while (lineTokens.length > 0 && /^ +$/.test(lineTokens[lineTokens.length - 1]!)) {
+          lineTokens.pop();
+        }
+      }
+
+      commit();
+      for (const t of carried) {
+        lineTokens.push(t);
+        lineWidth += visibleLen(t);
+      }
+      lineTokens.push(token);
+      lineWidth += tokenWidth;
+      lastVisibleIdx = lineTokens.length - 1;
+    }
+  }
+
+  if (lineWidth > 0) {
+    result.push(lineTokens.join(""));
+  }
+
+  return result;
+}
+
+/**
+ * Streaming markdown renderer that processes chunks of text,
+ * renders complete lines with ANSI formatting, and wraps output
+ * in a bordered box.
+ *
+ * The renderer accumulates lines internally. Call `drainLines()` to
+ * extract them — this is the only way output leaves the renderer.
+ */
+export class MarkdownRenderer {
+  private buffer = "";
+  private contentWidth: number;
+  private firstLine = true;
+  private lastLineBlank = false;
+  private pendingLines: string[] = [];
+  private width: number;
+  private tableRows: string[][] = [];
+
+  constructor(width: number) {
+    this.width = Math.max(10, width);
+    this.contentWidth = Math.min(MAX_CONTENT_WIDTH, this.width - 2);
+  }
+
+  /**
+   * Push a streaming chunk. Complete lines are rendered immediately;
+   * incomplete trailing text stays in the buffer.
+   */
+  push(chunk: string): void {
+    this.buffer += chunk;
+    this.processBuffer();
+  }
+
+  /**
+   * Flush any remaining text in the buffer (called when the response ends).
+   */
+  flush(): void {
+    if (this.buffer.length > 0) {
+      this.processLine(this.buffer);
+      this.buffer = "";
+    }
+    this.flushTable();
+  }
+
+  printTopBorder(): void {
+    this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
+    this.firstLine = true;
+  }
+
+  printBottomBorder(): void {
+    this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
+  }
+
+  /**
+   * Extract and clear all accumulated lines.
+   * This is the only way output leaves the renderer.
+   */
+  drainLines(): string[] {
+    const lines = this.pendingLines;
+    this.pendingLines = [];
+    return lines;
+  }
+
+  private processBuffer(): void {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop()!;
+
+    for (const line of lines) {
+      this.processLine(line);
+    }
+  }
+
+  private processLine(line: string): void {
+    // Table row detection: lines with | separators
+    if (/^\s*\|/.test(line)) {
+      const cells = parseTableRow(line);
+      if (cells) {
+        this.tableRows.push(cells);
+        return;
+      }
+    }
+
+    // Non-table line — flush any buffered table first
+    this.flushTable();
+
+    const rendered = this.renderLine(line);
+    const wrapped = wrapLine(rendered, this.contentWidth);
+    for (const wl of wrapped) {
+      this.writeLine(wl);
+    }
+  }
+
+  private flushTable(): void {
+    if (this.tableRows.length === 0) return;
+
+    const rows = this.tableRows;
+    this.tableRows = [];
+
+    // Filter out separator rows (|---|---|)
+    const sepIdx: number[] = [];
+    const dataRows: string[][] = [];
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i]!.every((c) => /^[-:]+$/.test(c.trim()) || c.trim() === "")) {
+        sepIdx.push(i);
+      } else {
+        dataRows.push(rows[i]!);
+      }
+    }
+
+    if (dataRows.length === 0) return;
+
+    // Normalize column count
+    const numCols = Math.max(...dataRows.map((r) => r.length));
+    for (const row of dataRows) {
+      while (row.length < numCols) row.push("");
+    }
+
+    // Width from rendered cell — raw `**bold**` over-counts by 4 per pair.
+    const colWidths: number[] = new Array(numCols).fill(0);
+    for (const row of dataRows) {
+      for (let c = 0; c < numCols; c++) {
+        colWidths[c] = Math.max(colWidths[c]!, visibleLen(this.renderInline(row[c]!)));
+      }
+    }
+
+    // Tables bypass the prose width cap — borders guide the eye, so wider is fine.
+    const separatorWidth = (numCols - 1) * 3;
+    const tableWidth = Math.max(10, this.width - 2);
+    const availableWidth = tableWidth - separatorWidth;
+    // Shrink the widest column one step at a time until the table fits.
+    // Preserves natural width on narrow columns — proportional scaling
+    // over-truncates when only one column is oversized.
+    let total = colWidths.reduce((a, b) => a + b, 0);
+    while (total > availableWidth && availableWidth > numCols) {
+      let maxIdx = 0;
+      for (let c = 1; c < numCols; c++) {
+        if (colWidths[c]! > colWidths[maxIdx]!) maxIdx = c;
+      }
+      if (colWidths[maxIdx]! <= 1) break;
+      colWidths[maxIdx]!--;
+      total--;
+    }
+
+    // Render rows
+    const hasHeader = sepIdx.includes(1) && dataRows.length > 1;
+
+    // Top border
+    const topBorder = colWidths.map((w) => "─".repeat(w)).join(`─┬─`);
+    this.writeLine(`${p.dim}┌─${topBorder}─┐${p.reset}`);
+
+    for (let i = 0; i < dataRows.length; i++) {
+      const row = dataRows[i]!;
+      const isHeader = hasHeader && i === 0;
+      const cells = row.map((cell, c) => {
+        const w = colWidths[c]!;
+        const rendered = this.renderInline(cell);
+        // Truncation can yield width < w when a CJK double-width char
+        // won't fit the remaining budget — always re-pad to keep cells
+        // aligned with the border grid.
+        const clipped = visibleLen(rendered) > w
+          ? truncateAnsiToWidth(rendered, w)
+          : rendered;
+        const text = padEndToWidth(clipped, w);
+        return isHeader ? `${p.bold}${text}${p.reset}` : text;
+      });
+      this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);
+
+      // Separator after header
+      if (isHeader) {
+        const sep = colWidths.map((w) => "─".repeat(w)).join(`─┼─`);
+        this.writeLine(`${p.dim}├─${sep}─┤${p.reset}`);
+      }
+    }
+
+    // Bottom border
+    const bottomBorder = colWidths.map((w) => "─".repeat(w)).join(`─┴─`);
+    this.writeLine(`${p.dim}└─${bottomBorder}─┘${p.reset}`);
+  }
+
+  private renderLine(line: string): string {
+    if (line.trim() === "") return "";
+
+    // Headings
+    const h1 = line.match(/^# (.+)/);
+    if (h1) return `${p.bold}${p.warning}${h1[1]}${p.reset}`;
+
+    const h2 = line.match(/^## (.+)/);
+    if (h2) return `${p.bold}${p.accent}${h2[1]}${p.reset}`;
+
+    const h3 = line.match(/^### (.+)/);
+    if (h3) return `${p.bold}${h3[1]}${p.reset}`;
+
+    const h4 = line.match(/^#{4,} (.+)/);
+    if (h4) return `${p.bold}${h4[1]}${p.reset}`;
+
+    // Horizontal rule — subtle short separator, not full-width
+    if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
+      return "";
+    }
+
+    // Blockquote
+    const bq = line.match(/^>\s?(.*)/);
+    if (bq) return `${p.muted}│${p.reset} ${p.dim}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
+
+    // Task list (checkbox items) — must come before generic unordered list
+    const task = line.match(/^(\s*)[*\-+]\s+\[([ xX])\]\s+(.*)/);
+    if (task) {
+      const indent = task[1] || "";
+      const checked = task[2] !== " ";
+      const box = checked
+        ? `${p.success}☑${p.reset}`
+        : `${p.dim}☐${p.reset}`;
+      return `${indent}  ${box} ${this.renderInline(task[3] || "")}`;
+    }
+
+    // Unordered list
+    const ul = line.match(/^(\s*)[*\-+]\s+(.*)/);
+    if (ul) {
+      const indent = ul[1] || "";
+      return `${indent}  ${p.accent}*${p.reset} ${this.renderInline(ul[2] || "")}`;
+    }
+
+    // Ordered list
+    const ol = line.match(/^(\s*)(\d+)[.)]\s+(.*)/);
+    if (ol) {
+      const indent = ol[1] || "";
+      return `${indent}  ${p.accent}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
+    }
+
+    return this.renderInline(line);
+  }
+
+  private renderInline(text: string): string {
+    // Links first — later subs inject `\x1b[…m` whose `[` would be eaten here.
+    text = text.replace(
+      /\[([^\]]+)\]\(([^)]+)\)/g,
+      `$1 ${p.muted}${p.underline}($2)${p.reset}`
+    );
+    // Inline code
+    text = text.replace(/`([^`]+)`/g, `${p.accent}$1${p.reset}`);
+    // Bold + italic
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${p.bold}${p.italic}$1${p.reset}`);
+    // Bold
+    text = text.replace(/\*\*(.+?)\*\*/g, `${p.bold}$1${p.reset}`);
+    text = text.replace(/(?<!\w)__(.+?)__(?!\w)/g, `${p.bold}$1${p.reset}`);
+    // Italic
+    text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
+    text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, `${p.italic}$1${p.reset}`);
+    // Strikethrough
+    text = text.replace(/~~(.+?)~~/g, `${p.dim}$1${p.reset}`);
+    return text;
+  }
+
+  /**
+   * Add a single line with a subtle left indent.
+   * The line is accumulated internally — call drainLines() to extract.
+   */
+  writeLine(text: string): void {
+    const isBlank = visibleLen(text) === 0;
+    if (this.firstLine && isBlank) return;
+    // Collapse consecutive blank lines to a single one
+    if (isBlank && this.lastLineBlank) return;
+    this.firstLine = false;
+    this.lastLineBlank = isBlank;
+    this.pendingLines.push(`  ${text}`);
+  }
+}
+
+/** Parse a markdown table row into trimmed cell strings, or null if not a table row. */
+function parseTableRow(line: string): string[] | null {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) return null;
+  // Split on |, drop first and last empty entries
+  const parts = trimmed.split("|");
+  if (parts.length < 3) return null; // need at least |cell|
+  return parts.slice(1, -1).map((c) => c.trim());
+}

package/src/utils/message-utils.ts

@@ -0,0 +1,113 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export function findToolCallIds(
+  messages: any[],
+  toolName: string,
+  argFilter?: Record<string, unknown>,
+): string[] {
+  const ids: string[] = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !msg.tool_calls) continue;
+    for (const tc of msg.tool_calls) {
+      const fn = tc.function ?? tc.fn;
+      if (!fn || fn.name !== toolName) continue;
+      if (argFilter) {
+        let args: Record<string, unknown>;
+        try { args = JSON.parse(fn.arguments); } catch { continue; }
+        const match = Object.entries(argFilter).every(([k, v]) => args[k] === v);
+        if (!match) continue;
+      }
+      ids.push(tc.id);
+    }
+  }
+  return ids;
+}
+
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export function stubToolResults(
+  messages: any[],
+  callIds: Set<string>,
+  stub: string,
+): any[] {
+  return messages.map((msg) => {
+    if (msg.role === "tool" && callIds.has(msg.tool_call_id)) {
+      return { ...msg, content: stub };
+    }
+    return msg;
+  });
+}
+
+/**
+ * Prepend a `<dynamic_context>` block onto the trailing message.
+ *
+ * Wrapping the *trailing* message (rather than inserting at the head) keeps
+ * the [system] + [prior history] prefix byte-stable across turns, so the
+ * provider's prefix cache holds. Caller passes a copy; conversation state
+ * is never mutated.
+ *
+ * No-op when both `dynamicContext` and `toolPrompt` are empty — i.e. no
+ * extension registered any per-turn signal — so a vanilla session sends
+ * exactly `[system, ...history]` with no synthetic envelope.
+ */
+export function wrapTrailingWithDynamicContext(
+  history: any[],
+  dynamicContext: string,
+  toolPrompt?: string,
+): any[] {
+  const ctx = dynamicContext.trim();
+  const tp = (toolPrompt ?? "").trim();
+  if (!ctx && !tp) return history;
+  if (history.length === 0) return history;
+  const last = history[history.length - 1];
+  if (typeof last.content !== "string") return history;
+
+  const blockBody = ctx && tp ? `${ctx}\n${tp}` : ctx || tp;
+  const wrappedContent = `<dynamic_context>\n${blockBody}\n</dynamic_context>\n\n${last.content}`;
+  return [...history.slice(0, -1), { ...last, content: wrappedContent }];
+}
+
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export function dedupeToolResults(
+  messages: any[],
+  toolName: string,
+  argFilter?: Record<string, unknown>,
+  stub = "[superseded by later call]",
+): any[] {
+  const callIds = findToolCallIds(messages, toolName, argFilter);
+  if (callIds.length <= 1) return messages;
+
+  // Keep the last one, stub the rest
+  const staleIds = new Set(callIds.slice(0, -1));
+  return stubToolResults(messages, staleIds, stub);
+}

package/src/utils/package-version.ts

@@ -0,0 +1,12 @@
+/**
+ * The agent-sh package version, read from package.json at load time.
+ * Emitted on `agent:info` so consumers (TUI, remote peers, logs) see a
+ * version that tracks releases instead of a hand-edited constant.
+ */
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+// dist/utils/package-version.js → ../../package.json (project root)
+const pkg = require("../../package.json") as { version?: string };
+
+export const PACKAGE_VERSION: string = pkg.version ?? "0.0.0";

package/src/utils/palette.ts

@@ -0,0 +1,64 @@
+/**
+ * Semantic color palette with a small set of base roles.
+ *
+ * Components use these roles instead of raw ANSI escapes.
+ * Extensions can override via setPalette() for theming.
+ *
+ * Design: ~10 base slots that cover all UI needs. Components
+ * derive specific uses from these (e.g. "diff added" = success,
+ * "tool title" = warning, "user query border" = accent).
+ */
+
+export interface ColorPalette {
+  // ── Semantic foreground roles ─────────────────────────────
+  accent: string;   // primary highlight — user queries, spinner, links
+  success: string;  // positive — diff added, checkmarks
+  warning: string;  // attention — tool titles, agent prompt
+  error: string;    // negative — diff removed, errors
+  muted: string;    // de-emphasized — info, context lines, borders
+
+  // ── True-color backgrounds (diff highlighting) ────────────
+  successBg: string;      // subtle green tint for added lines
+  errorBg: string;        // subtle red tint for removed lines
+  successBgEmph: string;  // stronger green for changed tokens
+  errorBgEmph: string;    // stronger red for changed tokens
+
+  // ── Style modifiers ───────────────────────────────────────
+  bold: string;
+  dim: string;
+  italic: string;
+  underline: string;
+  reset: string;
+}
+
+const defaultPalette: ColorPalette = {
+  accent:  "\x1b[36m",   // cyan
+  success: "\x1b[32m",   // green
+  warning: "\x1b[33m",   // yellow
+  error:   "\x1b[31m",   // red
+  muted:   "\x1b[90m",   // gray
+
+  successBg:     "\x1b[48;2;34;92;43m",
+  errorBg:       "\x1b[48;2;122;41;54m",
+  successBgEmph: "\x1b[48;2;56;166;96m",
+  errorBgEmph:   "\x1b[48;2;179;89;107m",
+
+  bold:      "\x1b[1m",
+  dim:       "\x1b[2m",
+  italic:    "\x1b[3m",
+  underline: "\x1b[4m",
+  reset:     "\x1b[0m",
+};
+
+/** Active palette — import and use directly in components. */
+export const palette: ColorPalette = { ...defaultPalette };
+
+/** Override palette slots. Merges with current values. */
+export function setPalette(overrides: Partial<ColorPalette>): void {
+  Object.assign(palette, overrides);
+}
+
+/** Reset palette to defaults. */
+export function resetPalette(): void {
+  Object.assign(palette, defaultPalette);
+}

package/src/utils/ref-counter.ts

@@ -0,0 +1,9 @@
+/** Simple ref-counted counter. Increment/decrement never goes below zero. */
+export class RefCounter {
+  private count = 0;
+  increment(): void { this.count++; }
+  decrement(): void { this.count = Math.max(0, this.count - 1); }
+  reset(): void { this.count = 0; }
+  get active(): boolean { return this.count > 0; }
+  get value(): number { return this.count; }
+}

package/src/utils/ripgrep-path.ts

@@ -0,0 +1,17 @@
+import * as fs from "node:fs";
+import { rgPath as bundledRgPath } from "@vscode/ripgrep";
+
+/**
+ * Resolve the ripgrep binary path. Prefers the version bundled via
+ * @vscode/ripgrep (downloaded by its postinstall hook). Falls back to plain
+ * "rg" so users with rg on PATH still work even if the postinstall failed
+ * (offline install, blocked egress, etc.).
+ */
+export function resolveRgPath(): string {
+  try {
+    if (bundledRgPath && fs.existsSync(bundledRgPath)) return bundledRgPath;
+  } catch {
+    // fall through
+  }
+  return "rg";
+}