botholomew 0.18.6 → 0.18.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.18.6",
+  "version": "0.18.7",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.95.2",
-    "@evantahler/mcpx": "0.21.7",
+    "@evantahler/mcpx": "0.21.8",
     "ansis": "^4.3.0",
     "commander": "^14.0.0",
     "gray-matter": "^4.0.3",
@@ -36,7 +36,7 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "istextorbinary": "^9.5.0",
-    "membot": "^0.15.0",
+    "membot": "^0.15.4",
     "nanospinner": "^1.2.2",
     "react": "^19.2.6",
     "uuid": "^14.0.0",

package/src/tools/membot/adapter.ts

@@ -34,13 +34,14 @@ type MembotMethodName =
   | "move"
   | "remove"
   | "refresh"
-  | "prune";
+  | "prune"
+  | "sources";
 
 /**
- * Map an Operation's exposed name (`membot_add`, `membot_delete`, …) to the
- * `MembotClient` method that actually runs it. The two diverge in a couple
- * of spots — `membot_delete` calls `client.remove`, `membot_move` calls
- * `client.move` — so we keep the routing explicit rather than guessing.
+ * Map an Operation's exposed name (`membot_add`, `membot_remove`, …) to the
+ * `MembotClient` method that actually runs it. Mostly 1:1 with the op name
+ * minus the `membot_` prefix; kept explicit so a renamed/added op fails
+ * loudly at registration instead of silently misrouting.
  */
 const METHOD_BY_OP_NAME: Record<string, MembotMethodName> = {
   membot_add: "add",
@@ -54,9 +55,10 @@ const METHOD_BY_OP_NAME: Record<string, MembotMethodName> = {
   membot_diff: "diff",
   membot_write: "write",
   membot_move: "move",
-  membot_delete: "remove",
+  membot_remove: "remove",
   membot_refresh: "refresh",
   membot_prune: "prune",
+  membot_sources: "sources",
 };
 
 /**

package/src/tools/membot/edit.ts

@@ -32,7 +32,7 @@ const outputSchema = z.object({
 export const membotEditTool = {
   name: "membot_edit",
   description:
-    "[[ bash equivalent command: patch ]] Apply line-range edits to a stored file: reads the current version, applies bottom-up patches, and writes the result back as a new version. Prefer this over membot_write when you only need to change part of a file — the diff is small and the change_note travels with the new version. To replace the whole body, use membot_write. To delete the file, use membot_delete.",
+    "[[ bash equivalent command: patch ]] Apply line-range edits to a stored file: reads the current version, applies bottom-up patches, and writes the result back as a new version. Prefer this over membot_write when you only need to change part of a file — the diff is small and the change_note travels with the new version. To replace the whole body, use membot_write. To delete the file, use membot_remove.",
   group: "membot",
   inputSchema,
   outputSchema,

package/src/tui/components/ContextPanel.tsx

@@ -240,7 +240,7 @@ export const ContextPanel = memo(function ContextPanel({
         ? `🔍 match (score=${selectedRow.hit.score.toFixed(3)}, chunk #${selectedRow.hit.chunk_index})\n${selectedRow.hit.snippet}\n\n---\n\n`
         : "";
     const body = isMarkdownPath(fileContent.logical_path)
-      ? renderMarkdown(fileContent.content)
+      ? renderMarkdown(fileContent.content, detailWidth)
       : fileContent.content;
     return wrapDetailLines(snippetHeader + body, detailWidth);
   }, [selectedRow, fileContent, detailWidth]);

package/src/tui/markdown.ts

@@ -1,6 +1,49 @@
-export function renderMarkdown(text: string): string {
+import { extractTableBlocks, renderTable } from "./markdownTables.ts";
+
+/**
+ * Render markdown to ANSI for a TUI detail pane. When `width` is provided,
+ * GFM tables are pulled out and rendered ourselves at that width before
+ * handing the rest off to `Bun.markdown.ansi` — Bun's renderer ignores any
+ * width hint and emits tables at their natural width, which `wrap-ansi` then
+ * shreds mid-cell.
+ */
+export function renderMarkdown(text: string, width?: number): string {
   if (!text) return "";
-  return Bun.markdown.ansi(text).trimEnd();
+  if (width === undefined || width <= 0) {
+    return Bun.markdown.ansi(text).trimEnd();
+  }
+
+  const blocks = extractTableBlocks(text);
+  if (blocks.length === 0) {
+    return Bun.markdown.ansi(text).trimEnd();
+  }
+
+  const lines = text.split("\n");
+  const rendered: string[] = blocks.map((b) =>
+    renderTable(b.rows, b.aligns, width),
+  );
+  // Bun.markdown.ansi mangles NUL bytes (→ U+FFFD), so use a plain alphanumeric
+  // sentinel that survives the markdown pass intact. Wrap each block's
+  // line-range with a single sentinel line, then splice the pre-rendered
+  // table back in after Bun finishes styling the rest of the document.
+  const sentinel = (i: number) => `BHTBLSENTINEL${i}BHTBLEND`;
+  const out = lines.slice();
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const b = blocks[i];
+    if (!b) continue;
+    out.splice(b.start, b.end - b.start + 1, sentinel(i));
+  }
+  const piped = Bun.markdown.ansi(out.join("\n")).trimEnd();
+  let stitched = piped;
+  for (let i = 0; i < blocks.length; i++) {
+    // Bun wraps each paragraph with a trailing reset (`\x1b[0m`). Strip any
+    // SGR escapes that hug the sentinel so the table doesn't inherit them.
+    const re = new RegExp(
+      `(?:\\x1b\\[[0-9;]*m)*${sentinel(i)}(?:\\x1b\\[[0-9;]*m)*`,
+    );
+    stitched = stitched.replace(re, rendered[i] ?? "");
+  }
+  return stitched;
 }
 
 export function isMarkdownPath(path: string): boolean {

package/src/tui/markdownTables.ts

@@ -0,0 +1,288 @@
+/**
+ * GFM table extraction + width-aware ANSI rendering.
+ *
+ * `Bun.markdown.ansi` renders tables at their natural width and ignores the
+ * caller's column budget, so wide tables get hard-wrapped mid-cell by
+ * `wrap-ansi` in the detail pane. We pre-extract table blocks, render them
+ * ourselves at a width that fits, and let `Bun.markdown.ansi` handle the rest.
+ */
+
+export type Align = "left" | "center" | "right";
+
+export interface TableBlock {
+  /** First line index (inclusive) of the table in the original text. */
+  start: number;
+  /** Last line index (inclusive). */
+  end: number;
+  /** First row is the header. */
+  rows: string[][];
+  aligns: Align[];
+}
+
+const DIM_ON = "\x1b[2m";
+const BOLD_ON = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+const SEPARATOR_CELL_RE = /^\s*:?-{1,}:?\s*$/;
+const FENCE_RE = /^\s{0,3}(```|~~~)/;
+
+export function extractTableBlocks(text: string): TableBlock[] {
+  const lines = text.split("\n");
+  const blocks: TableBlock[] = [];
+  let inFence = false;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (FENCE_RE.test(line)) {
+      inFence = !inFence;
+      i++;
+      continue;
+    }
+    if (inFence || !looksLikePipeRow(line)) {
+      i++;
+      continue;
+    }
+    const sep = lines[i + 1] ?? "";
+    if (!looksLikePipeRow(sep)) {
+      i++;
+      continue;
+    }
+    const sepCells = splitRow(sep);
+    if (!sepCells.every((c) => SEPARATOR_CELL_RE.test(c))) {
+      i++;
+      continue;
+    }
+    const header = splitRow(line);
+    const colCount = Math.max(header.length, sepCells.length);
+    const aligns: Align[] = sepCells.slice(0, colCount).map(parseAlignCell);
+    while (aligns.length < colCount) aligns.push("left");
+
+    const rows: string[][] = [normalizeRow(header, colCount)];
+    let j = i + 2;
+    while (j < lines.length) {
+      const body = lines[j] ?? "";
+      if (!looksLikePipeRow(body)) break;
+      // A new separator (consecutive tables) terminates this one.
+      if (splitRow(body).every((c) => SEPARATOR_CELL_RE.test(c))) break;
+      rows.push(normalizeRow(splitRow(body), colCount));
+      j++;
+    }
+
+    blocks.push({ start: i, end: j - 1, rows, aligns });
+    i = j;
+  }
+  return blocks;
+}
+
+export function renderTable(
+  rows: string[][],
+  aligns: Align[],
+  width: number,
+): string {
+  if (rows.length === 0) return "";
+  const colCount = rows[0]?.length ?? 0;
+  if (colCount === 0) return "";
+
+  const plain = rows.map((r) => r.map(stripInlineMarkdown));
+
+  // Per-column natural width (max visible width across all cells).
+  const naturalWidths: number[] = [];
+  for (let c = 0; c < colCount; c++) {
+    let w = 1;
+    for (const row of plain) {
+      const cell = row[c] ?? "";
+      if (visibleWidth(cell) > w) w = visibleWidth(cell);
+    }
+    naturalWidths.push(w);
+  }
+
+  // Overhead: leading "│ " + trailing " │" + " │ " between cols.
+  const borderOverhead = colCount * 3 + 1;
+  const naturalTotal =
+    naturalWidths.reduce((a, b) => a + b, 0) + borderOverhead;
+
+  let colWidths: number[];
+  if (naturalTotal <= width || width <= 0) {
+    colWidths = naturalWidths;
+  } else {
+    colWidths = shrinkColumns(naturalWidths, width - borderOverhead);
+  }
+
+  const lines: string[] = [];
+  lines.push(borderLine("┌", "┬", "┐", colWidths));
+  for (let r = 0; r < plain.length; r++) {
+    const cells = plain[r] ?? [];
+    const isHeader = r === 0;
+    lines.push(dataLine(cells, aligns, colWidths, isHeader));
+    if (isHeader) {
+      lines.push(borderLine("├", "┼", "┤", colWidths));
+    }
+  }
+  lines.push(borderLine("└", "┴", "┘", colWidths));
+  return lines.join("\n");
+}
+
+function looksLikePipeRow(line: string): boolean {
+  // A GFM table row contains at least one unescaped pipe and (after trimming
+  // surrounding whitespace + optional pipes) is non-empty.
+  const stripped = line.trim();
+  if (stripped === "") return false;
+  if (!stripped.includes("|")) return false;
+  return true;
+}
+
+function splitRow(line: string): string[] {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells: string[] = [];
+  let buf = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "\\" && s[i + 1] === "|") {
+      buf += "|";
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      cells.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  cells.push(buf.trim());
+  return cells;
+}
+
+function parseAlignCell(cell: string): Align {
+  const c = cell.trim();
+  const left = c.startsWith(":");
+  const right = c.endsWith(":");
+  if (left && right) return "center";
+  if (right) return "right";
+  return "left";
+}
+
+function normalizeRow(cells: string[], colCount: number): string[] {
+  const out = cells.slice(0, colCount);
+  while (out.length < colCount) out.push("");
+  return out;
+}
+
+function shrinkColumns(natural: number[], budget: number): number[] {
+  const MIN = 3;
+  const n = natural.length;
+  if (budget < n * MIN) {
+    // Not enough room even for ellipsis everywhere — give each column MIN
+    // and let the caller deal with overflow. (Detail pane minimum is much
+    // wider than this in practice.)
+    return new Array(n).fill(MIN);
+  }
+  const total = natural.reduce((a, b) => a + b, 0) || 1;
+  const raw = natural.map((w) => (w * budget) / total);
+  const floored = raw.map((v) => Math.max(MIN, Math.floor(v)));
+  let used = floored.reduce((a, b) => a + b, 0);
+  // Distribute the remainder to columns with the largest fractional part.
+  const remainders = raw
+    .map((v, i) => ({ i, frac: v - Math.floor(v) }))
+    .sort((a, b) => b.frac - a.frac);
+  let k = 0;
+  while (used < budget && k < remainders.length * 4) {
+    const idx = remainders[k % remainders.length]?.i ?? 0;
+    floored[idx] = (floored[idx] ?? MIN) + 1;
+    used++;
+    k++;
+  }
+  // If we overshot due to MIN clamping, trim from the widest column(s).
+  while (used > budget) {
+    let widest = 0;
+    for (let i = 1; i < n; i++) {
+      if ((floored[i] ?? 0) > (floored[widest] ?? 0)) widest = i;
+    }
+    if ((floored[widest] ?? 0) <= MIN) break;
+    floored[widest] = (floored[widest] ?? 0) - 1;
+    used--;
+  }
+  return floored;
+}
+
+function borderLine(
+  left: string,
+  mid: string,
+  right: string,
+  widths: number[],
+): string {
+  const segs = widths.map((w) => "─".repeat(w + 2));
+  return DIM_ON + left + segs.join(mid) + right + RESET;
+}
+
+function dataLine(
+  cells: string[],
+  aligns: Align[],
+  widths: number[],
+  bold: boolean,
+): string {
+  const parts: string[] = [];
+  parts.push(`${DIM_ON}│${RESET}`);
+  for (let i = 0; i < widths.length; i++) {
+    const w = widths[i] ?? 0;
+    const align = aligns[i] ?? "left";
+    const raw = cells[i] ?? "";
+    const fitted = padCell(raw, w, align);
+    const styled = bold ? `${BOLD_ON}${fitted}${RESET}` : fitted;
+    parts.push(` ${styled} `);
+    parts.push(`${DIM_ON}│${RESET}`);
+  }
+  return parts.join("");
+}
+
+function padCell(text: string, width: number, align: Align): string {
+  const truncated = truncateToWidth(text, width);
+  const pad = width - visibleWidth(truncated);
+  if (pad <= 0) return truncated;
+  if (align === "right") return " ".repeat(pad) + truncated;
+  if (align === "center") {
+    const l = Math.floor(pad / 2);
+    const r = pad - l;
+    return " ".repeat(l) + truncated + " ".repeat(r);
+  }
+  return truncated + " ".repeat(pad);
+}
+
+function truncateToWidth(text: string, width: number): string {
+  if (width <= 0) return "";
+  if (visibleWidth(text) <= width) return text;
+  if (width === 1) return "…";
+  const chars = Array.from(text);
+  let out = "";
+  let used = 0;
+  for (const ch of chars) {
+    if (used + 1 > width - 1) break;
+    out += ch;
+    used++;
+  }
+  return `${out}…`;
+}
+
+function visibleWidth(text: string): number {
+  // Cell text has no ANSI (we strip markdown markers before measuring), so
+  // codepoint count is sufficient. East-Asian double-width chars would be
+  // undercounted; out of scope for v1.
+  return Array.from(text).length;
+}
+
+function stripInlineMarkdown(text: string): string {
+  // Strip a small set of inline markers so cell width measurement matches what
+  // the user sees. Order matters: longer markers first.
+  let s = text;
+  s = s.replace(/`([^`]+)`/g, "$1");
+  s = s.replace(/\*\*([^*]+)\*\*/g, "$1");
+  s = s.replace(/__([^_]+)__/g, "$1");
+  s = s.replace(/~~([^~]+)~~/g, "$1");
+  s = s.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1$2");
+  s = s.replace(/(^|[^_])_([^_\n]+)_/g, "$1$2");
+  // Collapse \| escapes that survived splitRow.
+  s = s.replace(/\\\|/g, "|");
+  return s;
+}