botholomew 0.3.0 → 0.3.2

package/README.md

@@ -0,0 +1,9 @@
+# Botholomew
+
+```
+ {o,o}
+ /)_)
+  " "
+```
+
+An AI agent for knowledge work.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
   },
   "scripts": {
     "dev": "bun run src/cli.ts",
+    "dev:demo": "bun run src/cli.ts chat -p 'learn everything you can about me from the connected MCP services and then save what you'\\''ve learned about me to context'",
     "test": "bun test",
     "build": "bun build --compile --minify --sourcemap --external react-devtools-core ./src/cli.ts --outfile dist/botholomew",
     "lint": "tsc --noEmit && biome check ."
@@ -33,6 +34,7 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "istextorbinary": "^9.5.0",
+    "nanospinner": "^1.2.2",
     "react": "^19.1.0",
     "uuid": "^13.0.0",
     "zod": "^4.3.6"

package/src/chat/agent.ts

@@ -5,6 +5,8 @@ import type {
   ToolUseBlock,
 } from "@anthropic-ai/sdk/resources/messages";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import { fitToContextWindow, getMaxInputTokens } from "../daemon/context.ts";
+import { maybeStoreResult } from "../daemon/large-results.ts";
 import { buildMetaHeader, loadPersistentContext } from "../daemon/prompt.ts";
 import type { DbConnection } from "../db/connection.ts";
 import { logInteraction } from "../db/threads.ts";
@@ -36,6 +38,7 @@ const CHAT_TOOL_NAMES = new Set([
   "mcp_search",
   "mcp_info",
   "mcp_exec",
+  "read_large_result",
 ]);
 
 export function getChatTools() {
@@ -54,7 +57,7 @@ export async function buildChatSystemPrompt(
 
   parts.push("## Instructions");
   parts.push(
-    "You are Botholomew's interactive chat interface. Help the user manage tasks, review results from daemon activity, search context, and answer questions.",
+    "You are Botholomew, an AI agent personified by a wise owl. This is your interactive chat interface. Help the user manage tasks, review results from daemon activity, search context, and answer questions.",
   );
   parts.push(
     "You do NOT execute long-running work directly — enqueue tasks for the daemon instead using create_task.",
@@ -62,6 +65,9 @@ export async function buildChatSystemPrompt(
   parts.push(
     "Use the available tools to look up tasks, threads, schedules, and context when the user asks about them.",
   );
+  parts.push(
+    "When multiple tool calls are independent of each other (i.e., one does not depend on the result of another), call them all in a single response. They will be executed in parallel, which is faster than calling them one at a time.",
+  );
   parts.push(
     "You can update the agent's beliefs and goals files when the user asks you to.",
   );
@@ -73,10 +79,20 @@ export async function buildChatSystemPrompt(
   return parts.join("\n");
 }
 
+export interface ToolEndMeta {
+  largeResult?: { id: string; chars: number; pages: number };
+}
+
 export interface ChatTurnCallbacks {
   onToken: (text: string) => void;
-  onToolStart: (name: string, input: string) => void;
-  onToolEnd: (name: string, output: string) => void;
+  onToolStart: (id: string, name: string, input: string) => void;
+  onToolEnd: (
+    id: string,
+    name: string,
+    output: string,
+    isError: boolean,
+    meta?: ToolEndMeta,
+  ) => void;
 }
 
 /**
@@ -101,11 +117,16 @@ export async function runChatTurn(input: {
   });
 
   const chatTools = getChatTools();
-  const maxTurns = 10;
+  const maxInputTokens = await getMaxInputTokens(
+    config.anthropic_api_key,
+    config.model,
+  );
+  const maxTurns = config.max_turns;
 
-  for (let turn = 0; turn < maxTurns; turn++) {
+  for (let turn = 0; !maxTurns || turn < maxTurns; turn++) {
     const startTime = Date.now();
 
+    fitToContextWindow(messages, systemPrompt, maxInputTokens);
     const stream = client.messages.stream({
       model: config.model,
       max_tokens: 4096,
@@ -116,12 +137,24 @@ export async function runChatTurn(input: {
 
     // Collect the full response
     let assistantText = "";
+    const earlyReportedToolIds = new Set<string>();
 
     stream.on("text", (text) => {
       assistantText += text;
       callbacks.onToken(text);
     });
 
+    stream.on("contentBlock", (block) => {
+      if (block.type === "tool_use") {
+        earlyReportedToolIds.add(block.id);
+        callbacks.onToolStart(
+          block.id,
+          block.name,
+          JSON.stringify(block.input),
+        );
+      }
+    });
+
     const response = await stream.finalMessage();
     const durationMs = Date.now() - startTime;
     const tokenCount =
@@ -152,12 +185,12 @@ export async function runChatTurn(input: {
     // Add assistant response to conversation
     messages.push({ role: "assistant", content: response.content });
 
-    // Execute tool calls
-    const toolResults: ToolResultBlockParam[] = [];
-
+    // Log all tool_use entries and notify UI
     for (const toolUse of toolUseBlocks) {
       const toolInput = JSON.stringify(toolUse.input);
-      callbacks.onToolStart(toolUse.name, toolInput);
+      if (!earlyReportedToolIds.has(toolUse.id)) {
+        callbacks.onToolStart(toolUse.id, toolUse.name, toolInput);
+      }
 
       await logInteraction(conn, threadId, {
         role: "assistant",
@@ -166,25 +199,45 @@ export async function runChatTurn(input: {
         toolName: toolUse.name,
         toolInput,
       });
+    }
 
-      const toolStart = Date.now();
-      const result = await executeChatToolCall(toolUse, toolCtx);
-      const toolDuration = Date.now() - toolStart;
+    // Execute all tools in parallel
+    const execResults = await Promise.all(
+      toolUseBlocks.map(async (toolUse) => {
+        const start = Date.now();
+        const result = await executeChatToolCall(toolUse, toolCtx);
+        const durationMs = Date.now() - start;
+        const stored = maybeStoreResult(toolUse.name, result.output);
+        const meta: ToolEndMeta | undefined = stored.stored
+          ? { largeResult: stored.stored }
+          : undefined;
+        callbacks.onToolEnd(
+          toolUse.id,
+          toolUse.name,
+          result.output,
+          result.isError,
+          meta,
+        );
+        return { toolUse, result, durationMs, stored };
+      }),
+    );
 
+    // Log results and collect tool_result messages
+    const toolResults: ToolResultBlockParam[] = [];
+    for (const { toolUse, result, durationMs, stored } of execResults) {
       await logInteraction(conn, threadId, {
         role: "tool",
         kind: "tool_result",
-        content: result,
+        content: result.output,
         toolName: toolUse.name,
-        durationMs: toolDuration,
+        durationMs,
       });
 
-      callbacks.onToolEnd(toolUse.name, result);
-
       toolResults.push({
         type: "tool_result",
         tool_use_id: toolUse.id,
-        content: result,
+        content: stored.text,
+        is_error: result.isError || undefined,
       });
     }
 
@@ -196,21 +249,32 @@ export async function runChatTurn(input: {
 async function executeChatToolCall(
   toolUse: ToolUseBlock,
   ctx: ToolContext,
-): Promise<string> {
+): Promise<{ output: string; isError: boolean }> {
   const tool = getTool(toolUse.name);
-  if (!tool) return `Unknown tool: ${toolUse.name}`;
+  if (!tool) return { output: `Unknown tool: ${toolUse.name}`, isError: true };
   if (!CHAT_TOOL_NAMES.has(tool.name))
-    return `Tool not available in chat mode: ${tool.name}`;
+    return {
+      output: `Tool not available in chat mode: ${tool.name}`,
+      isError: true,
+    };
 
   const parsed = tool.inputSchema.safeParse(toolUse.input);
   if (!parsed.success) {
-    return `Invalid input: ${JSON.stringify(parsed.error)}`;
+    return {
+      output: `Invalid input: ${JSON.stringify(parsed.error)}`,
+      isError: true,
+    };
   }
 
   try {
     const result = await tool.execute(parsed.data, ctx);
-    return typeof result === "string" ? result : JSON.stringify(result);
+    const isError =
+      typeof result === "object" && result !== null && "is_error" in result
+        ? (result as { is_error: boolean }).is_error
+        : false;
+    const output = typeof result === "string" ? result : JSON.stringify(result);
+    return { output, isError };
   } catch (err) {
-    return `Tool error: ${err}`;
+    return { output: `Tool error: ${err}`, isError: true };
   }
 }

package/src/chat/session.ts

@@ -14,6 +14,7 @@ import {
 } from "../db/threads.ts";
 import { createMcpxClient } from "../mcpx/client.ts";
 import type { ToolContext } from "../tools/tool.ts";
+import { generateThreadTitle } from "../utils/title.ts";
 import {
   buildChatSystemPrompt,
   type ChatTurnCallbacks,
@@ -60,21 +61,23 @@ export async function startChatSession(
     await reopenThread(conn, threadId);
 
     // Rebuild message history from interactions
+    let firstUserMessage: string | undefined;
     for (const interaction of result.interactions) {
       if (interaction.kind !== "message") continue;
       if (interaction.role === "user") {
+        if (!firstUserMessage) firstUserMessage = interaction.content;
         messages.push({ role: "user", content: interaction.content });
       } else if (interaction.role === "assistant") {
         messages.push({ role: "assistant", content: interaction.content });
       }
     }
+
+    // Backfill title for threads that still have the default
+    if (result.thread.title === "New chat" && firstUserMessage) {
+      void generateThreadTitle(config, conn, threadId, firstUserMessage);
+    }
   } else {
-    threadId = await createThread(
-      conn,
-      "chat_session",
-      undefined,
-      "Interactive chat",
-    );
+    threadId = await createThread(conn, "chat_session", undefined, "New chat");
   }
 
   const systemPrompt = await buildChatSystemPrompt(projectDir);
@@ -118,6 +121,16 @@ export async function sendMessage(
 
   session.messages.push({ role: "user", content: userMessage });
 
+  // Auto-generate title after first user message in a new thread
+  if (session.messages.length === 1) {
+    void generateThreadTitle(
+      session.config,
+      session.conn,
+      session.threadId,
+      userMessage,
+    );
+  }
+
   await runChatTurn({
     messages: session.messages,
     systemPrompt: session.systemPrompt,

package/src/cli.ts

@@ -11,6 +11,7 @@ import { registerMcpxCommand } from "./commands/mcpx.ts";
 import { registerPrepareCommand } from "./commands/prepare.ts";
 import { registerScheduleCommand } from "./commands/schedule.ts";
 import { registerTaskCommand } from "./commands/task.ts";
+import { registerThreadCommand } from "./commands/thread.ts";
 import { registerToolCommands } from "./commands/tools.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
 import { maybeCheckForUpdate } from "./update/background.ts";
@@ -33,6 +34,7 @@ program
 registerInitCommand(program);
 registerDaemonCommand(program);
 registerTaskCommand(program);
+registerThreadCommand(program);
 registerScheduleCommand(program);
 registerChatCommand(program);
 registerContextCommand(program);

package/src/commands/chat.ts

@@ -15,7 +15,8 @@ export function registerChatCommand(program: Command) {
         "    /quit, /exit    End the chat session",
     )
     .option("--thread-id <id>", "Resume an existing chat thread")
-    .action(async (opts: { threadId?: string }) => {
+    .option("-p, --prompt <text>", "Start chat with an initial prompt")
+    .action(async (opts: { threadId?: string; prompt?: string }) => {
       const { render } = await import("ink");
       const React = await import("react");
       const { App } = await import("../tui/App.tsx");
@@ -24,11 +25,13 @@ export function registerChatCommand(program: Command) {
         React.createElement(App, {
           projectDir: dir,
           threadId: opts.threadId,
+          initialPrompt: opts.prompt,
         }),
         {
+          exitOnCtrlC: false,
           kittyKeyboard: {
             mode: "enabled",
-            flags: ["disambiguateEscapeCodes", "reportEventTypes"],
+            flags: ["disambiguateEscapeCodes"],
           },
         },
       );

package/src/commands/context.ts

@@ -3,14 +3,19 @@ import { basename, join, resolve } from "node:path";
 import ansis from "ansis";
 import type { Command } from "commander";
 import { isText } from "istextorbinary";
+import { createSpinner } from "nanospinner";
 import { loadConfig } from "../config/loader.ts";
 import { embedSingle, warmupEmbedder } from "../context/embedder.ts";
 import { ingestContextItem } from "../context/ingest.ts";
 import type { DbConnection } from "../db/connection.ts";
 import {
+  type ContextItem,
   createContextItem,
+  deleteContextItemByPath,
+  getContextItemByPath,
   listContextItems,
   listContextItemsByPrefix,
+  updateContextItem,
 } from "../db/context.ts";
 import { hybridSearch, initVectorSearch } from "../db/embeddings.ts";
 import { logger } from "../utils/logger.ts";
@@ -67,43 +72,71 @@ export function registerContextCommand(program: Command) {
     .option("--prefix <prefix>", "virtual path prefix", "/")
     .action((paths: string[], opts) =>
       withDb(program, async (conn, dir) => {
-        const config = await loadConfig(dir);
-        await warmupEmbedder();
-
-        let added = 0;
-        let chunks = 0;
+        // Phase 1: Scan all paths and validate they exist
+        const filesToAdd: { filePath: string; contextPath: string }[] = [];
+        const spinner = createSpinner("Scanning files...").start();
 
         for (const path of paths) {
           const resolvedPath = resolve(path);
-          const info = await stat(resolvedPath);
+          let info: Awaited<ReturnType<typeof stat>>;
+          try {
+            info = await stat(resolvedPath);
+          } catch {
+            spinner.error({ text: `Path not found: ${resolvedPath}` });
+            process.exit(1);
+          }
 
           if (info.isDirectory()) {
             const entries = await walkDirectory(resolvedPath);
             for (const filePath of entries) {
               const relativePath = filePath.slice(resolvedPath.length);
-              const contextPath = join(opts.prefix, relativePath);
-              const count = await addFile(conn, config, filePath, contextPath);
-              if (count >= 0) {
-                added++;
-                chunks += count;
-              }
+              filesToAdd.push({
+                filePath,
+                contextPath: join(opts.prefix, relativePath),
+              });
             }
           } else {
-            const contextPath = join(opts.prefix, basename(resolvedPath));
-            const count = await addFile(
-              conn,
-              config,
-              resolvedPath,
-              contextPath,
-            );
-            if (count >= 0) {
-              added++;
-              chunks += count;
-            }
+            filesToAdd.push({
+              filePath: resolvedPath,
+              contextPath: join(opts.prefix, basename(resolvedPath)),
+            });
+          }
+        }
+
+        spinner.success({
+          text: `Found ${filesToAdd.length} file(s) to add.`,
+        });
+
+        // Phase 2: Warmup embedder
+        const embedSpinner = createSpinner(
+          "Loading embedding model...",
+        ).start();
+        const config = await loadConfig(dir);
+        await warmupEmbedder();
+        embedSpinner.success({ text: "Embedding model loaded." });
+
+        // Phase 3: Process files one-by-one
+        let added = 0;
+        let chunks = 0;
+
+        for (const [i, { filePath, contextPath }] of filesToAdd.entries()) {
+          const fileSpinner = createSpinner(
+            `Processing ${basename(filePath)} (${i + 1}/${filesToAdd.length})...`,
+          ).start();
+          const count = await addFile(conn, config, filePath, contextPath);
+          if (count >= 0) {
+            added++;
+            chunks += count;
+            fileSpinner.success({
+              text: `${contextPath} (${count} chunks)`,
+            });
+          } else {
+            fileSpinner.warn({ text: `${contextPath}: skipped` });
           }
         }
 
         logger.success(`Added ${added} file(s), ${chunks} chunk(s) indexed.`);
+        process.exit(0);
       }),
     );
 
@@ -139,6 +172,19 @@ export function registerContextCommand(program: Command) {
         }
       }),
     );
+  ctx
+    .command("delete <path>")
+    .description("Delete a context item by path")
+    .action((path: string) =>
+      withDb(program, async (conn) => {
+        const deleted = await deleteContextItemByPath(conn, path);
+        if (!deleted) {
+          logger.error(`Context item not found: ${path}`);
+          process.exit(1);
+        }
+        logger.success(`Deleted context item: ${path}`);
+      }),
+    );
 }
 
 async function addFile(
@@ -155,22 +201,32 @@ async function addFile(
 
     const content = textual ? await bunFile.text() : null;
 
-    const item = await createContextItem(conn, {
-      title: filename,
-      content: content ?? undefined,
-      mimeType,
-      sourcePath: filePath,
-      contextPath,
-      isTextual: textual,
-    });
+    const existing = await getContextItemByPath(conn, contextPath);
+    let item: ContextItem;
+
+    if (existing) {
+      const updated = await updateContextItem(conn, existing.id, {
+        title: filename,
+        content: content ?? undefined,
+        mime_type: mimeType,
+      });
+      if (!updated) throw new Error(`Failed to update: ${contextPath}`);
+      item = updated;
+    } else {
+      item = await createContextItem(conn, {
+        title: filename,
+        content: content ?? undefined,
+        mimeType,
+        sourcePath: filePath,
+        contextPath,
+        isTextual: textual,
+      });
+    }
 
     if (textual && content) {
-      const count = await ingestContextItem(conn, item.id, config);
-      console.log(`  + ${contextPath} (${count} chunks)`);
-      return count;
+      return await ingestContextItem(conn, item.id, config);
     }
 
-    console.log(`  + ${contextPath} (binary, not indexed)`);
     return 0;
   } catch (err) {
     logger.warn(`  ! ${contextPath}: ${err}`);