botholomew 0.16.3 → 0.17.0

package/src/tools/{context → membot}/pipe.ts

@@ -1,10 +1,10 @@
+import { isHelpfulError } from "membot";
 import { z } from "zod";
-import { PathConflictError, writeContextFile } from "../../context/store.ts";
 import { getTool, type ToolDefinition } from "../tool.ts";
 
 const PREVIEW_CHARS = 200;
 const ERROR_MESSAGE_CAP = 2000;
-const TOOL_NAME = "pipe_to_context";
+const TOOL_NAME = "membot_pipe";
 
 function truncate(s: string, cap: number): string {
   if (s.length <= cap) return s;
@@ -15,29 +15,28 @@ const inputSchema = z.object({
   tool_name: z
     .string()
     .describe(
-      "Name of the tool to dispatch. Its full output is piped into a file under context/; you (the LLM) will only see the storage acknowledgment, never the raw bytes.",
+      "Name of the tool to dispatch. Its full output is captured and written to membot under `logical_path`; you (the LLM) only see the storage acknowledgment, never the raw bytes.",
     ),
   tool_input: z
     .record(z.string(), z.unknown())
     .describe(
       "Arguments to pass to the inner tool (same shape as a normal call).",
     ),
-  path: z
+  logical_path: z
     .string()
     .describe(
-      "Project-relative path under context/ to write the captured output to (e.g. 'gdoc/quarterly-plan.md').",
+      "Destination logical_path under which to store the captured output (e.g. 'gdoc/quarterly-plan.md'). Creates a new version on every call.",
     ),
-  on_conflict: z
-    .enum(["error", "overwrite"])
+  change_note: z
+    .string()
     .optional()
-    .describe(
-      "What to do if a file already exists at this path. Defaults to 'error'. Pass 'overwrite' to replace.",
-    ),
+    .describe("Free-text note attached to the new version."),
 });
 
 const outputSchema = z.object({
   is_error: z.boolean(),
-  path: z.string().optional(),
+  logical_path: z.string().optional(),
+  version_id: z.string().optional(),
   bytes_written: z.number().optional(),
   preview: z
     .string()
@@ -52,18 +51,19 @@ const outputSchema = z.object({
       "forbidden_tool",
       "invalid_input",
       "inner_tool_error",
-      "path_conflict",
+      "write_failed",
+      "internal_error",
     ])
     .optional(),
   message: z.string().optional(),
   next_action_hint: z.string().optional(),
 });
 
-export const pipeToContextTool = {
+export const membotPipeTool = {
   name: TOOL_NAME,
   description:
-    "[[ bash equivalent command: cmd > file ]] Run another tool and pipe its full output directly into a file under context/, without the result flowing through the conversation. Use this when you need a large tool output (Google Docs via mcp_exec, web fetches, search dumps) saved for later inspection but you do NOT need to read the bytes yourself. You'll only see the storage ack (path, size, short preview).",
-  group: "context",
+    "[[ bash equivalent command: cmd > file ]] Run another tool and pipe its full output directly into a membot logical_path, without the result flowing through the conversation. Use this when you need a large tool output (Google Docs via mcp_exec, web fetches, search dumps) captured for later inspection but you do NOT need to read the bytes yourself. You'll only see the storage ack (logical_path, version_id, short preview).",
+  group: "membot",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
@@ -82,9 +82,9 @@ export const pipeToContextTool = {
       return {
         is_error: true,
         error_type: "forbidden_tool",
-        message: `Tool "${inner.name}" cannot be piped (terminal tools and pipe_to_context itself are not allowed).`,
+        message: `Tool "${inner.name}" cannot be piped (terminal tools and ${TOOL_NAME} itself are not allowed).`,
         next_action_hint:
-          "Pipe a non-terminal tool (search, mcp_exec, etc.) instead.",
+          "Pipe a non-terminal tool (mcp_exec, membot_read, etc.) instead.",
       };
     }
 
@@ -143,30 +143,32 @@ export const pipeToContextTool = {
     }
 
     try {
-      const entry = await writeContextFile(
-        ctx.projectDir,
-        input.path,
-        innerOutput,
-        { onConflict: input.on_conflict ?? "error" },
-      );
+      const written = await ctx.mem.write({
+        logical_path: input.logical_path,
+        content: innerOutput,
+        change_note: input.change_note,
+      });
       return {
         is_error: false,
-        path: entry.path,
-        bytes_written: innerOutput.length,
+        logical_path: written.logical_path,
+        version_id: written.version_id,
+        bytes_written: written.size_bytes,
         preview: innerOutput.slice(0, PREVIEW_CHARS),
       };
     } catch (err) {
-      if (err instanceof PathConflictError) {
+      if (isHelpfulError(err)) {
         return {
           is_error: true,
-          error_type: "path_conflict",
-          path: err.path,
-          message: `A file already exists at context/${err.path}. The inner tool ran but its output was discarded.`,
-          next_action_hint:
-            "Retry with on_conflict='overwrite' to replace, or pick a different path.",
+          error_type: "write_failed",
+          message: `Inner tool ran, but write to ${input.logical_path} failed: ${err.message}`,
+          next_action_hint: err.hint,
         };
       }
-      throw err;
+      return {
+        is_error: true,
+        error_type: "internal_error",
+        message: err instanceof Error ? err.message : String(err),
+      };
     }
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/registry.ts

@@ -1,27 +1,12 @@
 // Capabilities tools
 import { capabilitiesRefreshTool } from "./capabilities/refresh.ts";
-// Context tools
-import { pipeToContextTool } from "./context/pipe.ts";
-import { readLargeResultTool } from "./context/read-large-result.ts";
-// Context — directory operations
-import { contextCreateDirTool } from "./dir/create.ts";
-import { contextDirSizeTool } from "./dir/size.ts";
-import { contextTreeTool } from "./dir/tree.ts";
-// Context — file operations
-import { contextCopyTool } from "./file/copy.ts";
-import { contextCountLinesTool } from "./file/count-lines.ts";
-import { contextDeleteTool } from "./file/delete.ts";
-import { contextEditTool } from "./file/edit.ts";
-import { contextExistsTool } from "./file/exists.ts";
-import { contextInfoTool } from "./file/info.ts";
-import { contextMoveTool } from "./file/move.ts";
-import { contextReadTool } from "./file/read.ts";
-import { contextWriteTool } from "./file/write.ts";
 // MCP tools
 import { mcpExecTool } from "./mcp/exec.ts";
 import { mcpInfoTool } from "./mcp/info.ts";
 import { mcpListToolsTool } from "./mcp/list-tools.ts";
 import { mcpSearchTool } from "./mcp/search.ts";
+// Membot tools (knowledge store)
+import { registerMembotTools } from "./membot/index.ts";
 // Prompt tools
 import { promptCreateTool } from "./prompt/create.ts";
 import { promptDeleteTool } from "./prompt/delete.ts";
@@ -32,8 +17,6 @@ import { promptReadTool } from "./prompt/read.ts";
 import { createScheduleTool } from "./schedule/create.ts";
 import { scheduleEditTool } from "./schedule/edit.ts";
 import { listSchedulesTool } from "./schedule/list.ts";
-// Search tools
-import { searchTool } from "./search/index.ts";
 // Skill tools
 import { skillDeleteTool } from "./skill/delete.ts";
 import { skillEditTool } from "./skill/edit.ts";
@@ -73,26 +56,15 @@ export function registerAllTools(): void {
   registerTool(listTasksTool);
   registerTool(viewTaskTool);
 
-  // Context (file/dir + self-reflection)
-  registerTool(contextCreateDirTool);
-  registerTool(contextTreeTool);
-  registerTool(contextDirSizeTool);
-  registerTool(contextReadTool);
-  registerTool(contextWriteTool);
-  registerTool(contextEditTool);
-  registerTool(contextDeleteTool);
-  registerTool(contextCopyTool);
-  registerTool(contextMoveTool);
-  registerTool(contextInfoTool);
-  registerTool(contextExistsTool);
-  registerTool(contextCountLinesTool);
+  // Knowledge store (membot) — add/read/write/edit/search/versions/refresh etc.
+  registerMembotTools();
+
+  // Prompts
   registerTool(promptListTool);
   registerTool(promptReadTool);
   registerTool(promptCreateTool);
   registerTool(promptEditTool);
   registerTool(promptDeleteTool);
-  registerTool(readLargeResultTool);
-  registerTool(pipeToContextTool);
 
   // Capabilities
   registerTool(capabilitiesRefreshTool);
@@ -102,9 +74,6 @@ export function registerAllTools(): void {
   registerTool(scheduleEditTool);
   registerTool(listSchedulesTool);
 
-  // Search
-  registerTool(searchTool);
-
   // Skill
   registerTool(skillListTool);
   registerTool(skillReadTool);

package/src/tools/tool.ts

@@ -1,19 +1,17 @@
 import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import type { McpxClient } from "@evantahler/mcpx";
+import type { MembotClient } from "membot";
 import { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
-import type { DbConnection } from "../db/connection.ts";
 
 export interface ToolContext {
   /**
-   * Short-lived DB connection scoped to this tool call. Safe for single-query
-   * tools. Do NOT hold it across slow work (network, embedding, long loops) —
-   * the instance-level file lock stays held until every connection closes.
-   * For long-running tools, use `dbPath` with `withDb` per logical operation.
+   * Per-process membot client. Backs every `membot_*` tool. Membot manages
+   * its own DuckDB connection lifecycle internally (lazy claim, release
+   * between operations), so tools just call `ctx.mem.<op>(...)` directly —
+   * no per-call open/close needed.
    */
-  conn: DbConnection;
-  /** Path to the DuckDB file. Use with `withDb` for long-running tools. */
-  dbPath: string;
+  mem: MembotClient;
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;

package/src/tui/App.tsx

@@ -186,18 +186,17 @@ function AppInner({
     setUsage,
   });
 
-  const sessionDbPath = sessionRef.current?.dbPath;
+  const sessionReady = sessionRef.current != null;
   const inputBarHeader = useMemo(
     () =>
-      sessionDbPath ? (
+      sessionReady ? (
         <StatusBar
           projectDir={projectDir}
-          dbPath={sessionDbPath}
           chatTitle={chatTitle}
           onWorkerStatusChange={setWorkerRunning}
         />
       ) : null,
-    [projectDir, sessionDbPath, chatTitle],
+    [projectDir, sessionReady, chatTitle],
   );
 
   const allToolCalls = useMemo(