botholomew 0.16.2 → 0.16.3

package/src/tui/hooks/useChatTitlePolling.ts

@@ -0,0 +1,36 @@
+import { type MutableRefObject, useEffect, useState } from "react";
+import type { ChatSession } from "../../chat/session.ts";
+import { getThread } from "../../threads/store.ts";
+
+export function useChatTitlePolling(
+  ready: boolean,
+  sessionRef: MutableRefObject<ChatSession | null>,
+): {
+  chatTitle: string | undefined;
+  setChatTitle: (t: string | undefined) => void;
+} {
+  const [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
+
+  useEffect(() => {
+    if (!ready || !sessionRef.current) return;
+    let mounted = true;
+
+    const refreshTitle = async () => {
+      const session = sessionRef.current;
+      if (!session) return;
+      const result = await getThread(session.projectDir, session.threadId);
+      if (mounted && result?.thread.title) {
+        setChatTitle(result.thread.title);
+      }
+    };
+
+    refreshTitle();
+    const interval = setInterval(refreshTitle, 5000);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [ready, sessionRef]);
+
+  return { chatTitle, setChatTitle };
+}

package/src/tui/hooks/useMessageQueue.ts

@@ -0,0 +1,254 @@
+import {
+  type Dispatch,
+  type MutableRefObject,
+  type SetStateAction,
+  useCallback,
+  useRef,
+  useState,
+} from "react";
+import { type ChatSession, sendMessage } from "../../chat/session.ts";
+import type { ContextUsage } from "../../chat/usage.ts";
+import type { ChatMessage } from "../components/MessageList.tsx";
+import type { ToolCallData } from "../components/ToolCall.tsx";
+import { msgId } from "../messages.ts";
+
+export interface QueueEntry {
+  display: string;
+  content: string;
+}
+
+interface UseMessageQueueParams {
+  sessionRef: MutableRefObject<ChatSession | null>;
+  setMessages: Dispatch<SetStateAction<ChatMessage[]>>;
+  markActivityRef: MutableRefObject<() => void>;
+}
+
+export interface UseMessageQueueResult {
+  queueRef: MutableRefObject<QueueEntry[]>;
+  processingRef: MutableRefObject<boolean>;
+  queuedMessages: string[];
+  selectedQueueIndex: number;
+  setSelectedQueueIndex: Dispatch<SetStateAction<number>>;
+  syncQueue: () => void;
+  processQueue: () => Promise<void>;
+  isLoading: boolean;
+  streamingText: string;
+  activeToolCalls: ToolCallData[];
+  preparingTool: { id: string; name: string } | null;
+  streamStartedAt: Date | null;
+  usage: ContextUsage | null;
+  setUsage: Dispatch<SetStateAction<ContextUsage | null>>;
+  clearStreamingState: () => void;
+}
+
+export function useMessageQueue({
+  sessionRef,
+  setMessages,
+  markActivityRef,
+}: UseMessageQueueParams): UseMessageQueueResult {
+  const queueRef = useRef<QueueEntry[]>([]);
+  const processingRef = useRef(false);
+  const [queuedMessages, setQueuedMessages] = useState<string[]>([]);
+  const [selectedQueueIndex, setSelectedQueueIndex] = useState(0);
+  const [isLoading, setIsLoading] = useState(false);
+  const [streamingText, setStreamingText] = useState("");
+  const [activeToolCalls, setActiveToolCalls] = useState<ToolCallData[]>([]);
+  const [streamStartedAt, setStreamStartedAt] = useState<Date | null>(null);
+  const [preparingTool, setPreparingTool] = useState<{
+    id: string;
+    name: string;
+  } | null>(null);
+  const [usage, setUsage] = useState<ContextUsage | null>(null);
+
+  const syncQueue = useCallback(() => {
+    const snapshot = queueRef.current.map((e) => e.display);
+    setQueuedMessages(snapshot);
+    setSelectedQueueIndex((prev) =>
+      snapshot.length === 0 ? 0 : Math.min(prev, snapshot.length - 1),
+    );
+  }, []);
+
+  const clearStreamingState = useCallback(() => {
+    setStreamingText("");
+    setActiveToolCalls([]);
+    setPreparingTool(null);
+    setStreamStartedAt(null);
+  }, []);
+
+  const processQueue = useCallback(async () => {
+    if (processingRef.current || !sessionRef.current) return;
+    processingRef.current = true;
+
+    while (queueRef.current.length > 0) {
+      const entry = queueRef.current.shift();
+      syncQueue();
+      if (!entry) break;
+      setIsLoading(true);
+      setStreamingText("");
+      setActiveToolCalls([]);
+      setPreparingTool(null);
+      setStreamStartedAt(new Date());
+
+      const userMsg: ChatMessage = {
+        id: msgId(),
+        role: "user",
+        content: entry.display,
+        timestamp: new Date(),
+      };
+      setMessages((prev) => [...prev, userMsg]);
+
+      let pendingToolCalls: ToolCallData[] = [];
+      let currentText = "";
+
+      const finalizeSegment = () => {
+        if (currentText || pendingToolCalls.length > 0) {
+          const assistantMsg: ChatMessage = {
+            id: msgId(),
+            role: "assistant",
+            content: currentText,
+            timestamp: new Date(),
+            toolCalls:
+              pendingToolCalls.length > 0 ? [...pendingToolCalls] : undefined,
+          };
+          setMessages((prev) => [...prev, assistantMsg]);
+          currentText = "";
+          pendingToolCalls = [];
+          setStreamingText("");
+          setActiveToolCalls([]);
+          setStreamStartedAt(new Date());
+        }
+      };
+
+      let lastStreamFlush = 0;
+      try {
+        await sendMessage(sessionRef.current, entry.content, {
+          onToken: (token) => {
+            currentText += token;
+            const now = Date.now();
+            if (now - lastStreamFlush >= 50) {
+              setStreamingText(currentText);
+              lastStreamFlush = now;
+              markActivityRef.current();
+            }
+          },
+          onToolPreparing: (id, name) => {
+            markActivityRef.current();
+            setPreparingTool({ id, name });
+          },
+          onToolStart: (id, name, input) => {
+            markActivityRef.current();
+            if (currentText) {
+              finalizeSegment();
+            }
+            const tc: ToolCallData = {
+              id,
+              name,
+              input,
+              running: true,
+              timestamp: new Date(),
+            };
+            pendingToolCalls = [...pendingToolCalls, tc];
+            setActiveToolCalls(pendingToolCalls);
+            setPreparingTool(null);
+          },
+          onToolEnd: (id, _name, output, isError, meta) => {
+            markActivityRef.current();
+            // Replace the matched entry with a new object so its identity
+            // changes (memoized ToolCall children rely on this); other entries
+            // keep their reference and skip re-render.
+            pendingToolCalls = pendingToolCalls.map((t) =>
+              t.id === id
+                ? {
+                    ...t,
+                    running: false,
+                    output,
+                    isError,
+                    ...(meta?.largeResult
+                      ? { largeResult: meta.largeResult }
+                      : {}),
+                  }
+                : t,
+            );
+            setActiveToolCalls(pendingToolCalls);
+          },
+          onToolNotify: (id, message) => {
+            markActivityRef.current();
+            let touched = false;
+            pendingToolCalls = pendingToolCalls.map((t) => {
+              if (t.id !== id) return t;
+              touched = true;
+              return { ...t, notes: [...(t.notes ?? []), message] };
+            });
+            if (touched) setActiveToolCalls(pendingToolCalls);
+          },
+          onUsage: (info) => {
+            setUsage(info);
+          },
+          takeInjections: () => {
+            // Drain queued messages into the running turn so the agent sees
+            // them on the next LLM call instead of after the whole tool loop.
+            // Finalize the in-flight assistant segment first so the new user
+            // bubbles render in the right order in the chat view.
+            if (queueRef.current.length === 0) return [];
+            if (currentText || pendingToolCalls.length > 0) {
+              finalizeSegment();
+            }
+            const drained = queueRef.current.splice(0);
+            syncQueue();
+            for (const e of drained) {
+              const userMsg: ChatMessage = {
+                id: msgId(),
+                role: "user",
+                content: e.display,
+                timestamp: new Date(),
+              };
+              setMessages((prev) => [...prev, userMsg]);
+            }
+            return drained.map((e) => e.content);
+          },
+        });
+
+        if (sessionRef.current?.aborted) {
+          currentText += currentText
+            ? "\n\n_(steered — response interrupted)_"
+            : "_(steered — no response)_";
+        }
+        finalizeSegment();
+      } catch (err) {
+        const errorMsg: ChatMessage = {
+          id: msgId(),
+          role: "system",
+          content: `Error: ${err}`,
+          timestamp: new Date(),
+        };
+        setMessages((prev) => [...prev, errorMsg]);
+      } finally {
+        setStreamingText("");
+        setActiveToolCalls([]);
+        setPreparingTool(null);
+        setStreamStartedAt(null);
+      }
+    }
+
+    setIsLoading(false);
+    processingRef.current = false;
+  }, [sessionRef, setMessages, markActivityRef, syncQueue]);
+
+  return {
+    queueRef,
+    processingRef,
+    queuedMessages,
+    selectedQueueIndex,
+    setSelectedQueueIndex,
+    syncQueue,
+    processQueue,
+    isLoading,
+    streamingText,
+    activeToolCalls,
+    preparingTool,
+    streamStartedAt,
+    usage,
+    setUsage,
+    clearStreamingState,
+  };
+}

package/src/tui/hooks/useTerminalRows.ts

@@ -0,0 +1,20 @@
+import { useStdout } from "ink";
+import { useEffect, useState } from "react";
+
+// Track the terminal's row count so the dynamic frame stays strictly below
+// fullscreen. Ink 7 wipes scrollback whenever the dynamic frame is overflowing
+// or transitions out of fullscreen — so as long as the rendered output height
+// stays < `rows` on every render, scrollback is preserved.
+export function useTerminalRows(): number {
+  const { stdout } = useStdout();
+  const [rows, setRows] = useState(stdout?.rows ?? 24);
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => setRows(stdout.rows ?? 24);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return rows;
+}

package/src/tui/keys.ts

@@ -0,0 +1,24 @@
+import type { TabId } from "./components/TabBar.tsx";
+
+// Tab routing: Ctrl+<letter> jumps to a tab. Chosen for memorability — first
+// available letter that doesn't collide with other Ctrl bindings (Ctrl+C exit,
+// Ctrl+J/K/X/E queue ops on Chat).
+//
+// Help is bound to Ctrl+G rather than Ctrl+H because most terminals deliver
+// Ctrl+H as ASCII 0x08 (backspace). Bonus: macOS Terminal.app and several
+// other terminals map Ctrl+/ to BEL (0x07), the same byte as Ctrl+G — so this
+// binding also catches the Ctrl+/ keystroke on those terminals "for free".
+// We also accept "/" and "_" as fallbacks for terminals that deliver Ctrl+/
+// as 0x1F or as the literal "/" with ctrl=true (Kitty keyboard protocol).
+export const TAB_BY_CTRL_KEY: Record<string, TabId> = {
+  a: 1, // ch[a]t
+  o: 2, // t[o]ols
+  n: 3, // co[n]text
+  t: 4, // [t]asks
+  e: 5, // thr[e]ads
+  s: 6, // [s]chedules
+  w: 7, // [w]orkers
+  g: 8, // help (also catches Ctrl+/ on terminals that map it to BEL)
+  "/": 8, // help (Kitty keyboard protocol)
+  _: 8, // help (terminals that send Ctrl+/ as 0x1F)
+};

package/src/tui/messages.ts

@@ -0,0 +1,11 @@
+// Conservative line reservation for the bottom chrome — StatusBar (1) +
+// bordered InputBar (3) + multiline hint (1) + TabBar (1) + slack for the
+// SlashCommandPopup or QueuePanel (~4). The chat-tab body's `maxHeight` and
+// the panel boxes' `height` both subtract this from `rows` so the dynamic
+// frame's total output stays strictly below the viewport.
+export const FOOTER_RESERVE = 10;
+
+let nextMsgId = 0;
+export function msgId(): string {
+  return `msg-${++nextMsgId}`;
+}

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;
 }