botholomew 0.16.0 → 0.16.3

package/src/tui/restoreMessages.ts

@@ -0,0 +1,106 @@
+import type { Interaction } from "../threads/store.ts";
+import { MAX_INLINE_CHARS, PAGE_SIZE_CHARS } from "../worker/large-results.ts";
+import type { ChatMessage } from "./components/MessageList.tsx";
+import type { ToolCallData } from "./components/ToolCall.tsx";
+
+let nextRestoreId = 0;
+function restoreMsgId(): string {
+  return `restore-msg-${++nextRestoreId}`;
+}
+
+function detectToolError(output: string | undefined): boolean {
+  if (!output) return false;
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed === "object" && parsed?.is_error === true) return true;
+  } catch {
+    /* not JSON */
+  }
+  return false;
+}
+
+/**
+ * Reconstruct `ChatMessage[]` from a thread's interaction log so the TUI can
+ * hydrate chat history (plus the Tools tab) when resuming a session.
+ *
+ * Tools attach to the assistant message that *issued* them, not the next one.
+ * `runChatTurn` logs in the order: assistant text → tool_use(s) → tool_result(s)
+ * → next assistant text, so we track the most recent assistant message and
+ * append tool calls there until a user message resets the cursor.
+ */
+export function restoreMessagesFromInteractions(
+  interactions: Interaction[],
+): ChatMessage[] {
+  const result: ChatMessage[] = [];
+  let currentAssistant: ChatMessage | null = null;
+  let orphanTools: ToolCallData[] = [];
+  let restoredIdx = 0;
+
+  const makeToolCall = (ix: Interaction): ToolCallData => ({
+    id: `restored-${restoredIdx++}`,
+    name: ix.tool_name ?? "unknown",
+    input: ix.tool_input ?? "{}",
+    running: false,
+    timestamp: ix.created_at,
+  });
+
+  for (const ix of interactions) {
+    if (ix.kind === "tool_use") {
+      const tc = makeToolCall(ix);
+      if (currentAssistant) {
+        const list = currentAssistant.toolCalls ?? [];
+        list.push(tc);
+        currentAssistant.toolCalls = list;
+      } else {
+        orphanTools.push(tc);
+      }
+    } else if (ix.kind === "tool_result") {
+      const pool = currentAssistant?.toolCalls ?? orphanTools;
+      const tc = pool.find((t) => t.name === ix.tool_name && !t.output);
+      if (tc) {
+        tc.output = ix.content;
+        tc.isError = detectToolError(ix.content);
+        if (ix.content.length > MAX_INLINE_CHARS) {
+          tc.largeResult = {
+            id: "(restored)",
+            chars: ix.content.length,
+            pages: Math.ceil(ix.content.length / PAGE_SIZE_CHARS),
+          };
+        }
+      }
+    } else if (ix.kind === "message" && ix.role === "user") {
+      result.push({
+        id: restoreMsgId(),
+        role: "user",
+        content: ix.content,
+        timestamp: ix.created_at,
+      });
+      currentAssistant = null;
+    } else if (ix.kind === "message" && ix.role === "assistant") {
+      const msg: ChatMessage = {
+        id: restoreMsgId(),
+        role: "assistant",
+        content: ix.content,
+        timestamp: ix.created_at,
+      };
+      if (orphanTools.length > 0) {
+        msg.toolCalls = [...orphanTools];
+        orphanTools = [];
+      }
+      result.push(msg);
+      currentAssistant = msg;
+    }
+  }
+
+  if (orphanTools.length > 0) {
+    result.push({
+      id: restoreMsgId(),
+      role: "assistant",
+      content: "",
+      timestamp: orphanTools[0]?.timestamp ?? new Date(),
+      toolCalls: [...orphanTools],
+    });
+  }
+
+  return result;
+}

package/src/tui/useTerminalSize.ts

@@ -0,0 +1,26 @@
+import { useStdout } from "ink";
+import { useEffect, useState } from "react";
+
+/**
+ * Track terminal columns + rows. Ink's `useStdout` doesn't re-render on
+ * resize, so panels that compute layout from terminal width (e.g. detail
+ * panes that wrap long lines) need this hook to stay accurate.
+ */
+export function useTerminalSize(): { cols: number; rows: number } {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState(() => ({
+    cols: stdout?.columns ?? 80,
+    rows: stdout?.rows ?? 24,
+  }));
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => {
+      setSize({ cols: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return size;
+}

package/src/tui/wrapDetail.ts

@@ -0,0 +1,15 @@
+import wrapAnsi from "wrap-ansi";
+
+/**
+ * Wrap an ANSI-colored body string to a column width and return one entry
+ * per visual line. Used by the right-pane detail views in every list/detail
+ * panel (Tools, Tasks, Threads, Schedules, Context) so long lines wrap
+ * instead of getting truncated by `<Text wrap="truncate-end">`.
+ *
+ * `wrap-ansi` preserves SGR state across wrap boundaries, so colorized
+ * JSON / markdown stays intact.
+ */
+export function wrapDetailLines(text: string, width: number): string[] {
+  if (width <= 0) return text.split("\n");
+  return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
+}

package/src/worker/fake-llm.ts

@@ -17,6 +17,13 @@ export interface FakeTurn {
   chunkSize?: number;
   /** Delay between chunks in milliseconds. */
   delayMs?: number;
+  /**
+   * Initial wait before the first chunk emits, in milliseconds. Mirrors a
+   * real model's first-token latency — useful for capture fixtures where
+   * back-to-back turns would otherwise complete instantly and look
+   * unrealistic.
+   */
+  preDelayMs?: number;
   /** Optional tool calls to emit after text. */
   toolCalls?: Array<{
     id?: string;
@@ -125,6 +132,12 @@ function buildFinalMessage(
 class FakeMessageStream extends EventEmitter {
   private resolveFinal: (m: Message) => void = () => {};
   private readonly finalPromise: Promise<Message>;
+  // Buffered events for `for await` consumers; populated by `run()` so the
+  // EventEmitter and async-iterator interfaces stay in sync without
+  // double-driving the turn.
+  private readonly events: Array<Record<string, unknown>> = [];
+  private eventsDone = false;
+  private notifyEvent: (() => void) | null = null;
 
   constructor(private readonly turn: FakeTurn) {
     super();
@@ -134,13 +147,27 @@ class FakeMessageStream extends EventEmitter {
     queueMicrotask(() => this.run());
   }
 
+  private pushEvent(ev: Record<string, unknown>): void {
+    this.events.push(ev);
+    this.notifyEvent?.();
+  }
+
   private async run(): Promise<void> {
     const text = this.turn.text ?? this.turn.chunks?.join("") ?? "";
     const chunks =
       this.turn.chunks ?? chunkText(text, this.turn.chunkSize ?? 6);
     const delay = this.turn.delayMs ?? 40;
+    const preDelay = this.turn.preDelayMs ?? 0;
+    if (preDelay > 0) await new Promise((r) => setTimeout(r, preDelay));
     for (const chunk of chunks) {
       this.emit("text", chunk);
+      const ev = {
+        type: "content_block_delta",
+        index: 0,
+        delta: { type: "text_delta", text: chunk },
+      };
+      this.emit("streamEvent", ev);
+      this.pushEvent(ev);
       if (delay > 0) await new Promise((r) => setTimeout(r, delay));
     }
     const final = buildFinalMessage(text, this.turn.toolCalls);
@@ -162,9 +189,37 @@ class FakeMessageStream extends EventEmitter {
         blockIndex++;
       }
     }
+    const stop = { type: "message_stop" };
+    this.emit("streamEvent", stop);
+    this.pushEvent(stop);
+    this.eventsDone = true;
+    this.notifyEvent?.();
     this.resolveFinal(final);
   }
 
+  /**
+   * Async iterator support so `for await (const event of stream)` callers
+   * (e.g. `src/context/markdown-converter.ts`) get the same shape as the
+   * real SDK. Events are sourced from the buffer populated by `run()`, so
+   * the iterator and the EventEmitter interface observe a single timeline.
+   */
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<
+    Record<string, unknown>
+  > {
+    let cursor = 0;
+    while (true) {
+      while (cursor < this.events.length) {
+        const ev = this.events[cursor++];
+        if (ev) yield ev;
+      }
+      if (this.eventsDone) return;
+      await new Promise<void>((resolve) => {
+        this.notifyEvent = resolve;
+      });
+      this.notifyEvent = null;
+    }
+  }
+
   finalMessage(): Promise<Message> {
     return this.finalPromise;
   }
@@ -207,6 +262,11 @@ export function createFakeAnthropicClient(): Anthropic {
           return buildFinalMessage("Chat session");
         }
         const turn = selectTurn(extractLastUserText(params.messages));
+        // Honour preDelayMs so non-streaming callers (e.g. the fetcher
+        // loop in src/context/fetcher.ts) get the same "thinking" pause
+        // a streaming caller would.
+        const preDelay = turn.preDelayMs ?? 0;
+        if (preDelay > 0) await new Promise((r) => setTimeout(r, preDelay));
         return buildFinalMessage(
           turn.text ?? turn.chunks?.join("") ?? "",
           turn.toolCalls,

package/src/worker/fake-mcp.ts

@@ -48,6 +48,56 @@ export function fakeMcpSearch(query: string): FakeMcpSearchResult[] | null {
       },
     ];
   }
+  if (/google.*doc|docs?\.google|gdoc|document/.test(q)) {
+    return [
+      {
+        server: "google-docs",
+        tool: "GetDocumentAsMarkdown",
+        description:
+          "Fetch the contents of a Google Doc by URL or ID and return it as Markdown.",
+        score: 0.96,
+        match_type: "semantic",
+      },
+      {
+        server: "google-docs",
+        tool: "GetDocumentAsHtml",
+        description: "Fetch a Google Doc as raw HTML.",
+        score: 0.71,
+        match_type: "semantic",
+      },
+    ];
+  }
+  if (/github|pull request|\bpr\b|repo|commit/.test(q)) {
+    return [
+      {
+        server: "github",
+        tool: "ListMyPullRequests",
+        description:
+          "List the user's recent pull requests across all repos, with status and last activity.",
+        score: 0.93,
+        match_type: "semantic",
+      },
+      {
+        server: "github",
+        tool: "ListAssignedIssues",
+        description: "List GitHub issues assigned to the user.",
+        score: 0.79,
+        match_type: "semantic",
+      },
+    ];
+  }
+  if (/linear|ticket|issue.*track/.test(q)) {
+    return [
+      {
+        server: "linear",
+        tool: "ListMyIssues",
+        description:
+          "List Linear issues assigned to the user, including status and any blocking notes.",
+        score: 0.95,
+        match_type: "semantic",
+      },
+    ];
+  }
   return null;
 }
 
@@ -70,5 +120,89 @@ export function fakeMcpExec(
       2,
     );
   }
+  if (server === "github" && tool === "ListMyPullRequests") {
+    return JSON.stringify(
+      {
+        pull_requests: [
+          {
+            number: 213,
+            repo: "evantahler/botholomew",
+            title:
+              "TUI: close chat gap, hide chat scrollback on other tabs, wrap detail panes",
+            status: "merged",
+            merged_at: "2026-05-05T18:42:00Z",
+          },
+          {
+            number: 214,
+            repo: "evantahler/botholomew",
+            title: "Make /standup demo call GitHub + Linear before synthesis",
+            status: "open",
+            updated_at: "2026-05-06T09:01:00Z",
+            review_state: "requested_changes",
+          },
+        ],
+      },
+      null,
+      2,
+    );
+  }
+  if (server === "linear" && tool === "ListMyIssues") {
+    return JSON.stringify(
+      {
+        issues: [
+          {
+            id: "ENG-487",
+            title: "Worker reaper sometimes drops heartbeats under load",
+            status: "in_progress",
+            priority: "medium",
+          },
+          {
+            id: "ENG-491",
+            title: "Flaky context-reindex test under Bun 1.4",
+            status: "blocked",
+            priority: "high",
+            note: "Blocked on upstream Bun fix oven-sh/bun#26081",
+          },
+          {
+            id: "ENG-503",
+            title: "Add structured event log for capabilities refresh",
+            status: "todo",
+            priority: "low",
+          },
+        ],
+      },
+      null,
+      2,
+    );
+  }
+  if (server === "google-docs" && tool === "GetDocumentAsMarkdown") {
+    return [
+      "# Botholomew v0.8 launch plan",
+      "",
+      "## Themes",
+      "",
+      "1. Better MCPX ergonomics — fewer steps to wire up a new server.",
+      "2. Chat TUI polish — context indicator, idle-pause, slash menu.",
+      "3. Doc captures — every GIF in the docs is hermetic + regenerable.",
+      "",
+      "## Milestones",
+      "",
+      "- [x] Move tasks/schedules/context onto disk",
+      "- [x] Replace OpenAI embeddings with @huggingface/transformers",
+      "- [ ] Ship `context import` for Google Docs end-to-end",
+      "- [ ] Cut v0.8 release notes",
+      "",
+      "## Open questions",
+      "",
+      "- How do we version skill templates across releases?",
+      "- Should `context refresh` rate-limit per source-domain?",
+      "",
+      "## Stakeholders",
+      "",
+      "- Pascal (design review)",
+      "- Sterling (reliability + oncall sign-off)",
+      "",
+    ].join("\n");
+  }
   return null;
 }