botholomew 0.7.7 → 0.7.9

package/README.md

@@ -128,6 +128,8 @@ Everything the agent can touch is here. No surprises.
 | `botholomew nuke context\|tasks\|schedules\|threads\|all` | Bulk-erase sections of the database |
 | `botholomew upgrade` | Self-update |
 
+All `list` subcommands support `-l, --limit <n>` and `-o, --offset <n>` for pagination.
+
 ---
 
 ## How it works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Local, autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {

package/src/chat/agent.ts

@@ -4,6 +4,7 @@ import type {
   ToolResultBlockParam,
   ToolUseBlock,
 } from "@anthropic-ai/sdk/resources/messages";
+import type { McpxClient } from "@evantahler/mcpx";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { embedSingle } from "../context/embedder.ts";
 import { fitToContextWindow, getMaxInputTokens } from "../daemon/context.ts";
@@ -13,7 +14,7 @@ import {
   extractKeywords,
   loadPersistentContext,
 } from "../daemon/prompt.ts";
-import type { DbConnection } from "../db/connection.ts";
+import { withDb } from "../db/connection.ts";
 import { hybridSearch } from "../db/embeddings.ts";
 import { logInteraction } from "../db/threads.ts";
 import { registerAllTools } from "../tools/registry.ts";
@@ -60,7 +61,7 @@ export async function buildChatSystemPrompt(
   projectDir: string,
   options?: {
     keywordSource?: string;
-    conn?: DbConnection;
+    dbPath?: string;
     config?: Required<BotholomewConfig>;
   },
 ): Promise<string> {
@@ -74,12 +75,14 @@ export async function buildChatSystemPrompt(
   parts.push(...(await loadPersistentContext(projectDir, taskKeywords)));
 
   // Relevant context from embeddings search
-  const conn = options?.conn;
+  const dbPath = options?.dbPath;
   const config = options?.config;
-  if (conn && config?.openai_api_key && keywordSource) {
+  if (dbPath && config?.openai_api_key && keywordSource) {
     try {
       const queryVec = await embedSingle(keywordSource, config);
-      const results = await hybridSearch(conn, keywordSource, queryVec, 5);
+      const results = await withDb(dbPath, (conn) =>
+        hybridSearch(conn, keywordSource, queryVec, 5),
+      );
 
       if (results.length > 0) {
         parts.push("## Relevant Context");
@@ -160,13 +163,20 @@ export async function runChatTurn(input: {
   messages: MessageParam[];
   projectDir: string;
   config: Required<BotholomewConfig>;
-  conn: DbConnection;
+  dbPath: string;
   threadId: string;
-  toolCtx: ToolContext;
+  mcpxClient: McpxClient | null;
   callbacks: ChatTurnCallbacks;
 }): Promise<void> {
-  const { messages, projectDir, config, conn, threadId, toolCtx, callbacks } =
-    input;
+  const {
+    messages,
+    projectDir,
+    config,
+    dbPath,
+    threadId,
+    mcpxClient,
+    callbacks,
+  } = input;
 
   const client = new Anthropic({
     apiKey: config.anthropic_api_key || undefined,
@@ -190,7 +200,7 @@ export async function runChatTurn(input: {
     const keywordSource = findLastUserText(messages);
     const systemPrompt = await buildChatSystemPrompt(projectDir, {
       keywordSource,
-      conn,
+      dbPath,
       config,
     });
 
@@ -230,13 +240,15 @@ export async function runChatTurn(input: {
 
     // Log assistant text
     if (assistantText) {
-      await logInteraction(conn, threadId, {
-        role: "assistant",
-        kind: "message",
-        content: assistantText,
-        durationMs,
-        tokenCount,
-      });
+      await withDb(dbPath, (conn) =>
+        logInteraction(conn, threadId, {
+          role: "assistant",
+          kind: "message",
+          content: assistantText,
+          durationMs,
+          tokenCount,
+        }),
+      );
     }
 
     // Check for tool calls
@@ -260,20 +272,29 @@ export async function runChatTurn(input: {
         callbacks.onToolStart(toolUse.id, toolUse.name, toolInput);
       }
 
-      await logInteraction(conn, threadId, {
-        role: "assistant",
-        kind: "tool_use",
-        content: `Calling ${toolUse.name}`,
-        toolName: toolUse.name,
-        toolInput,
-      });
+      await withDb(dbPath, (conn) =>
+        logInteraction(conn, threadId, {
+          role: "assistant",
+          kind: "tool_use",
+          content: `Calling ${toolUse.name}`,
+          toolName: toolUse.name,
+          toolInput,
+        }),
+      );
     }
 
-    // Execute all tools in parallel
+    // Execute all tools in parallel. Each tool call opens its own short-lived
+    // connection; parallel calls share the process-local DuckDB instance and
+    // release the file lock as soon as the last one finishes.
     const execResults = await Promise.all(
       toolUseBlocks.map(async (toolUse) => {
         const start = Date.now();
-        const result = await executeChatToolCall(toolUse, toolCtx);
+        const result = await executeChatToolCall(toolUse, {
+          dbPath,
+          projectDir,
+          config,
+          mcpxClient,
+        });
         const durationMs = Date.now() - start;
         const stored = maybeStoreResult(toolUse.name, result.output);
         const meta: ToolEndMeta | undefined = stored.stored
@@ -293,13 +314,15 @@ export async function runChatTurn(input: {
     // 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.output,
-        toolName: toolUse.name,
-        durationMs,
-      });
+      await withDb(dbPath, (conn) =>
+        logInteraction(conn, threadId, {
+          role: "tool",
+          kind: "tool_result",
+          content: result.output,
+          toolName: toolUse.name,
+          durationMs,
+        }),
+      );
 
       toolResults.push({
         type: "tool_result",
@@ -314,9 +337,16 @@ export async function runChatTurn(input: {
   }
 }
 
+interface ChatToolCallCtx {
+  dbPath: string;
+  projectDir: string;
+  config: Required<BotholomewConfig>;
+  mcpxClient: McpxClient | null;
+}
+
 async function executeChatToolCall(
   toolUse: ToolUseBlock,
-  ctx: ToolContext,
+  baseCtx: ChatToolCallCtx,
 ): Promise<{ output: string; isError: boolean }> {
   const tool = getTool(toolUse.name);
   if (!tool) return { output: `Unknown tool: ${toolUse.name}`, isError: true };
@@ -335,7 +365,10 @@ async function executeChatToolCall(
   }
 
   try {
-    const result = await tool.execute(parsed.data, ctx);
+    const result = await withDb(baseCtx.dbPath, (conn) => {
+      const ctx: ToolContext = { ...baseCtx, conn };
+      return tool.execute(parsed.data, ctx);
+    });
     const isError =
       typeof result === "object" && result !== null && "is_error" in result
         ? (result as { is_error: boolean }).is_error

package/src/chat/session.ts

@@ -2,8 +2,7 @@ import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
 import { loadConfig } from "../config/loader.ts";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { getDbPath } from "../constants.ts";
-import type { DbConnection } from "../db/connection.ts";
-import { getConnection } from "../db/connection.ts";
+import { withDb } from "../db/connection.ts";
 import { migrate } from "../db/schema.ts";
 import {
   createThread,
@@ -15,18 +14,18 @@ import {
 import { createMcpxClient } from "../mcpx/client.ts";
 import { loadSkills } from "../skills/loader.ts";
 import type { SkillDefinition } from "../skills/parser.ts";
-import type { ToolContext } from "../tools/tool.ts";
 import { generateThreadTitle } from "../utils/title.ts";
 import { type ChatTurnCallbacks, runChatTurn } from "./agent.ts";
 
 export interface ChatSession {
-  conn: DbConnection;
+  dbPath: string;
   threadId: string;
   projectDir: string;
   config: Required<BotholomewConfig>;
   messages: MessageParam[];
-  toolCtx: ToolContext;
   skills: Map<string, SkillDefinition>;
+  // biome-ignore lint/suspicious/noExplicitAny: mcpx client
+  mcpxClient: any;
   cleanup: () => Promise<void>;
 }
 
@@ -42,21 +41,22 @@ export async function startChatSession(
     );
   }
 
-  const conn = await getConnection(getDbPath(projectDir));
-  await migrate(conn);
+  const dbPath = getDbPath(projectDir);
+  await withDb(dbPath, (conn) => migrate(conn));
 
   let threadId: string;
   const messages: MessageParam[] = [];
 
   if (existingThreadId) {
     // Resume existing thread
-    const result = await getThread(conn, existingThreadId);
+    const result = await withDb(dbPath, (conn) =>
+      getThread(conn, existingThreadId),
+    );
     if (!result) {
-      conn.close();
       throw new Error(`Thread not found: ${existingThreadId}`);
     }
     threadId = existingThreadId;
-    await reopenThread(conn, threadId);
+    await withDb(dbPath, (conn) => reopenThread(conn, threadId));
 
     // Rebuild message history from interactions
     let firstUserMessage: string | undefined;
@@ -72,34 +72,29 @@ export async function startChatSession(
 
     // Backfill title for threads that still have the default
     if (result.thread.title === "New chat" && firstUserMessage) {
-      void generateThreadTitle(config, conn, threadId, firstUserMessage);
+      void generateThreadTitle(config, dbPath, threadId, firstUserMessage);
     }
   } else {
-    threadId = await createThread(conn, "chat_session", undefined, "New chat");
+    threadId = await withDb(dbPath, (conn) =>
+      createThread(conn, "chat_session", undefined, "New chat"),
+    );
   }
 
   const mcpxClient = await createMcpxClient(projectDir);
   const skills = await loadSkills(projectDir);
 
-  const toolCtx: ToolContext = {
-    conn,
-    projectDir,
-    config,
-    mcpxClient,
-  };
-
   const cleanup = async () => {
     await mcpxClient?.close();
   };
 
   return {
-    conn,
+    dbPath,
     threadId,
     projectDir,
     config,
     messages,
-    toolCtx,
     skills,
+    mcpxClient,
     cleanup,
   };
 }
@@ -110,11 +105,13 @@ export async function sendMessage(
   callbacks: ChatTurnCallbacks,
 ): Promise<void> {
   // Log and append user message
-  await logInteraction(session.conn, session.threadId, {
-    role: "user",
-    kind: "message",
-    content: userMessage,
-  });
+  await withDb(session.dbPath, (conn) =>
+    logInteraction(conn, session.threadId, {
+      role: "user",
+      kind: "message",
+      content: userMessage,
+    }),
+  );
 
   session.messages.push({ role: "user", content: userMessage });
 
@@ -122,7 +119,7 @@ export async function sendMessage(
   if (session.messages.length === 1) {
     void generateThreadTitle(
       session.config,
-      session.conn,
+      session.dbPath,
       session.threadId,
       userMessage,
     );
@@ -132,15 +129,14 @@ export async function sendMessage(
     messages: session.messages,
     projectDir: session.projectDir,
     config: session.config,
-    conn: session.conn,
+    dbPath: session.dbPath,
     threadId: session.threadId,
-    toolCtx: session.toolCtx,
+    mcpxClient: session.mcpxClient,
     callbacks,
   });
 }
 
 export async function endChatSession(session: ChatSession): Promise<void> {
-  await endThread(session.conn, session.threadId);
+  await withDb(session.dbPath, (conn) => endThread(conn, session.threadId));
   await session.cleanup();
-  session.conn.close();
 }