agent.libx.js 0.93.37 → 0.93.39

package/README.md

@@ -117,7 +117,7 @@ agentx --resume <id> "…"    # resume a specific session
 - **Any provider** — set `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` / `GOOGLE_API_KEY` / `GROQ_API_KEY`; choose with `-m provider/model`.
 - **@-file mentions & headless JSON** — reference files inline in a prompt with `@path` (e.g. `explain @src/Agent.ts`); script with `-p --output-format json` to get one machine-readable result object on stdout (activity stays on stderr).
 - **Tab-completion** — `Tab` completes `/<command>` names and `@<path>` file/dir references (descends subdirs, dotfiles hidden unless typed) straight from the working tree.
-- **Duplex mode** — `agentx --duplex` runs the full standard REPL (slash commands, sessions, postures, rewind, MCP) with the dual-model engine driving turns: a fast voice model (`--voice-model`, default haiku) answers every line instantly and delegates real work to background workers built with the same wiring as a normal run (fs mode, permissions, MCP); worker activity shows as dim chrome and results are re-voiced when ready.
+- **Duplex mode** — `agentx --duplex` runs the full standard REPL (slash commands, sessions, postures, rewind, MCP) with the three-tier engine driving turns: a fast voice model (`--voice-model`, default `groq/openai/gpt-oss-120b`) answers every line instantly and delegates real work to background workers built with the same wiring as a normal run (fs mode, permissions, MCP); worker activity shows as dim chrome and results are re-voiced when ready. Switch any tier live with `/model` (opens a reflex/act/think picker), or the `/voice-model` · `/think-model` shortcuts.
 - **MCP servers** — declare `mcpServers: { name: { command, args } | { url } }` in config and they're auto-mounted at startup (in parallel, with an optional `mountTimeoutMs` deadline so one slow/dead server never blocks the rest): the client does the JSON-RPC handshake (stdio or HTTP) + `tools/list`, and the discovered tools appear as `mcp__<name>__<tool>` in `/tools` (inspect with `/mcp`). A bad server is logged and skipped, never blocking the agent. For large tool sets, **deferred mode** (`makeMcpToolSearch` / `mountMcpDeferred`) exposes just two bounded tools (`ToolSearch` + `McpCall`) instead of N defs — dodging the provider tool-cap and improving selection accuracy. **`mountMcpCatalog`** goes further: a cached, hash-keyed catalog + lazy connect means a turn that uses no MCP tool opens **zero** connections, and one that uses a tool connects exactly that server — latency scales with tools-used, not servers-configured. A down server is **negative-cached** (`failureCooldownMs`) so it never re-floors a later turn at the deadline. For zero turn-path latency even on a cold process, call **`warmMcpCatalog`** at boot + on a timer (off-turn discovery) and mount with **`{ discover: 'cache-only' }`** — the turn then never synchronously connects: it serves the warmed catalog and discovers any miss in the background.
 
 ## 🧬 It improves itself

package/dist/cli.js

@@ -7907,21 +7907,40 @@ function readPlainLine() {
 }
 
 // cli/markdown.ts
+var vis = (s) => needsBidi(s) ? bidiLine(s).visual : s;
+function displayText(s) {
+  return s.replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/(?<![\w*])[*_]([^*_\s][^*_]*?)[*_](?![\w*])/g, "$1");
+}
 function mdInline(line, p) {
-  return line.replace(
-    /(`[^`]+`)|(\*\*[^*]+\*\*)/g,
-    (_m, code, bold2) => code ? p.cyan(code.slice(1, -1)) : p.bold(bold2.slice(2, -2))
-  );
+  const re = /(`[^`]+`)|(\[[^\]]+\]\([^)]+\))|(\*\*[^*]+\*\*)|(~~[^~]+~~)|((?<![\w*])[*_][^*_\s][^*_]*?[*_](?![\w*]))/g;
+  return line.replace(re, (_m, code, link2, bold2, strike2, italic2) => {
+    if (code) return p.cyan(code.slice(1, -1));
+    if (link2) {
+      const m = /^\[([^\]]+)\]\(([^)]+)\)$/.exec(link2);
+      return p.link ? p.link(m[1], m[2]) : p.cyan(m[1]);
+    }
+    if (bold2) return p.bold(bold2.slice(2, -2));
+    if (strike2) return (p.strike ?? ((s) => s))(strike2.slice(2, -2));
+    return (p.italic ?? ((s) => s))(italic2.slice(1, -1));
+  });
 }
-function renderMdLine(line, inFence, p) {
+function renderMdLine(line, inFence, p, cols = 80) {
   if (/^\s*```/.test(line)) return { out: p.dim(line), inFence: !inFence };
   if (inFence) return { out: p.cyan(line), inFence };
+  if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) return { out: p.dim("\u2500".repeat(cols)), inFence };
   const h = line.match(/^(#{1,6})\s+(.*)$/);
-  if (h) return { out: p.bold(h[2]), inFence };
-  return { out: mdInline(line, p), inFence };
+  if (h) return { out: p.bold(vis(h[2])), inFence };
+  const q2 = line.match(/^(\s*)>\s?(.*)$/);
+  if (q2) return { out: q2[1] + p.dim("\u258E ") + p.dim(mdInline(vis(q2[2]), p)), inFence };
+  const b = line.match(/^(\s*)[-*+]\s+(.*)$/);
+  if (b) return { out: b[1] + p.cyan("\u2022") + " " + mdInline(vis(b[2]), p), inFence };
+  return { out: mdInline(vis(line), p), inFence };
+}
+function isTableRow(line) {
+  return /^\s*\|.*\|\s*$/.test(line);
 }
 var MarkdownStream = class {
-  // physical rows the in-progress line occupied last draw (for the next clear)
+  // contiguous GFM table rows held until the block ends, then aligned
   constructor(p, cols = 80) {
     this.p = p;
     this.cols = cols;
@@ -7932,12 +7951,38 @@ var MarkdownStream = class {
   // the current (uncommitted) logical line's text
   inFence = false;
   lineRows = 0;
+  // physical rows the in-progress line occupied last draw (for the next clear)
+  tableBuf = [];
   /** Update the wrap width (terminal resized). Recompute how many physical rows the in-progress line now spans
    *  so the next feed()'s clear-math matches the new width (the terminal reflows the drawn text on resize too). */
   resize(cols) {
     this.cols = Math.max(1, cols);
     if (this.buf) this.lineRows = Math.max(1, Math.ceil(this.buf.length / this.cols));
   }
+  /** Render the held table block as aligned columns and reset the buffer. If the block lacks a `|---|`
+   *  separator row it isn't a real table — emit the rows verbatim (rendered as normal lines) instead. */
+  flushTable() {
+    const rows = this.tableBuf;
+    this.tableBuf = [];
+    const sepIdx = rows.findIndex((r, i) => i > 0 && r.includes("-") && /^\s*\|[\s:|-]+\|\s*$/.test(r));
+    if (sepIdx < 0) return rows.map((r) => renderMdLine(r, false, this.p, this.cols).out + "\r\n").join("");
+    const cells = (r) => r.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim());
+    const data = rows.filter((_, i) => i !== sepIdx).map(cells);
+    const ncol = Math.max(...data.map((r) => r.length));
+    const widths = Array.from({ length: ncol }, (_, i) => Math.max(...data.map((r) => displayText(r[i] ?? "").length)));
+    const out = [];
+    data.forEach((row, ri) => {
+      const header = ri === 0;
+      const line = "  " + widths.map((w, ci) => {
+        const c = row[ci] ?? "";
+        const styled = header ? this.p.bold(displayText(vis(c))) : mdInline(vis(c), this.p);
+        return styled + " ".repeat(Math.max(0, w - displayText(c).length));
+      }).join("   ").replace(/\s+$/, "");
+      out.push(line);
+      if (header) out.push("  " + this.p.dim("\u2500".repeat(widths.reduce((a, b) => a + b, 0) + 3 * (ncol - 1))));
+    });
+    return out.map((l) => l + "\r\n").join("");
+  }
   feed(text) {
     this.buf += text;
     let out = "";
@@ -7948,25 +7993,31 @@ var MarkdownStream = class {
     while ((nl = this.buf.indexOf("\n")) >= 0) {
       const line = this.buf.slice(0, nl);
       this.buf = this.buf.slice(nl + 1);
-      const r = renderMdLine(line, this.inFence, this.p);
+      if (!this.inFence && isTableRow(line)) {
+        this.tableBuf.push(line);
+        continue;
+      }
+      if (this.tableBuf.length) out += this.flushTable();
+      const r = renderMdLine(line, this.inFence, this.p, this.cols);
       this.inFence = r.inFence;
       out += r.out + "\r\n";
     }
     if (this.buf) {
-      out += renderMdLine(this.buf, this.inFence, this.p).out;
+      out += renderMdLine(this.buf, this.inFence, this.p, this.cols).out;
       this.lineRows = Math.max(1, Math.ceil(this.buf.length / Math.max(1, this.cols)));
     }
     return out;
   }
-  /** Commit the in-progress line as-is (already on screen) and reset for the next turn. */
+  /** Commit the in-progress line as-is (already on screen), emit any buffered table, and reset for next turn. */
   flush() {
+    const out = this.tableBuf.length ? this.flushTable() : "";
     this.buf = "";
     this.inFence = false;
     this.lineRows = 0;
-    return "";
+    return out;
   }
   pending() {
-    return this.buf.length > 0;
+    return this.buf.length > 0 || this.tableBuf.length > 0;
   }
 };
 
@@ -7981,6 +8032,9 @@ var green = C("32");
 var red = C("31");
 var bold = C("1");
 var yellow = C("33");
+var italic = C("3");
+var strike = C("9");
+var link = (text, url) => useColor ? `\x1B]8;;${url}\x1B\\${cyan(text)}\x1B]8;;\x1B\\` : `${text} (${url})`;
 var err = (s) => process.stderr.write(s);
 var log17 = forComponent("cli");
 var VERSION = (() => {
@@ -8206,7 +8260,7 @@ function apiKeysFromEnv() {
 function makeHost(format = "text", opts) {
   const streamJson = format === "stream-json";
   const cleanStdout = format === "json";
-  const md = format === "text" && useColor && opts?.stream ? new MarkdownStream({ bold, dim, cyan }, process.stdout.columns ?? 80) : null;
+  const md = format === "text" && useColor && opts?.stream ? new MarkdownStream({ bold, dim, cyan, italic, strike, link }, process.stdout.columns ?? 80) : null;
   if (md) process.on("SIGWINCH", () => md.resize(process.stdout.columns ?? 80));
   const flushText = () => {
     if (md && md.pending()) process.stdout.write(md.flush());