botholomew 0.16.4 → 0.18.0

package/src/tools/membot/edit.ts

@@ -0,0 +1,72 @@
+import { isHelpfulError } from "membot";
+import { z } from "zod";
+import { applyLinePatches, LinePatchSchema } from "../../fs/patches.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  logical_path: z
+    .string()
+    .describe("Logical path of the file to edit (e.g. 'notes/foo.md')."),
+  patches: z
+    .array(LinePatchSchema)
+    .min(1)
+    .describe(
+      "Git-hunk-style edits applied bottom-up. `end_line: 0` inserts; empty `content` deletes.",
+    ),
+  change_note: z
+    .string()
+    .optional()
+    .describe("Free-text note attached to the new version."),
+});
+
+const outputSchema = z.object({
+  is_error: z.boolean(),
+  logical_path: z.string().optional(),
+  version_id: z.string().optional(),
+  size_bytes: z.number().optional(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
+});
+
+export const membotEditTool = {
+  name: "membot_edit",
+  description:
+    "[[ bash equivalent command: patch ]] Apply line-range edits to a stored file: reads the current version, applies bottom-up patches, and writes the result back as a new version. Prefer this over membot_write when you only need to change part of a file — the diff is small and the change_note travels with the new version. To replace the whole body, use membot_write. To delete the file, use membot_delete.",
+  group: "membot",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    try {
+      const current = await ctx.mem.read({ logical_path: input.logical_path });
+      const next = applyLinePatches(current.content ?? "", input.patches);
+      const result = await ctx.mem.write({
+        logical_path: input.logical_path,
+        content: next,
+        change_note: input.change_note,
+      });
+      return {
+        is_error: false,
+        logical_path: result.logical_path,
+        version_id: result.version_id,
+        size_bytes: result.size_bytes,
+      };
+    } catch (err) {
+      if (isHelpfulError(err)) {
+        return {
+          is_error: true,
+          error_type: err.kind,
+          message: err.message,
+          next_action_hint: err.hint,
+        };
+      }
+      return {
+        is_error: true,
+        error_type: "internal_error",
+        message: err instanceof Error ? err.message : String(err),
+        next_action_hint:
+          "Re-read the file with membot_read to confirm current line numbers, then retry.",
+      };
+    }
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/membot/exists.ts

@@ -0,0 +1,54 @@
+import { isHelpfulError } from "membot";
+import { z } from "zod";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  logical_path: z.string().describe("Logical path to check."),
+});
+
+const outputSchema = z.object({
+  is_error: z.boolean(),
+  exists: z.boolean().optional(),
+  logical_path: z.string().optional(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+});
+
+export const membotExistsTool = {
+  name: "membot_exists",
+  description:
+    "[[ bash equivalent command: test -e ]] Check whether a logical_path has a current (non-tombstoned) version in the store. Returns `{ exists: true|false }` — never throws on absence. Use before membot_write when you want to avoid clobbering, or to disambiguate a not_found from a real error.",
+  group: "membot",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    try {
+      await ctx.mem.info({ logical_path: input.logical_path });
+      return {
+        is_error: false,
+        exists: true,
+        logical_path: input.logical_path,
+      };
+    } catch (err) {
+      if (isHelpfulError(err) && err.kind === "not_found") {
+        return {
+          is_error: false,
+          exists: false,
+          logical_path: input.logical_path,
+        };
+      }
+      if (isHelpfulError(err)) {
+        return {
+          is_error: true,
+          error_type: err.kind,
+          message: err.message,
+        };
+      }
+      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/membot/index.ts

@@ -0,0 +1,26 @@
+import { OPERATIONS } from "membot";
+import { type AnyToolDefinition, registerTool } from "../tool.ts";
+import { adaptOperation } from "./adapter.ts";
+import { membotCopyTool } from "./copy.ts";
+import { membotCountLinesTool } from "./count_lines.ts";
+import { membotEditTool } from "./edit.ts";
+import { membotExistsTool } from "./exists.ts";
+import { membotPipeTool } from "./pipe.ts";
+
+/**
+ * Register every membot operation as a Botholomew tool. The 14 verbs that
+ * have a direct membot Operation (add, list, tree, read, search, info,
+ * stats, versions, diff, write, move, delete, refresh, prune) are wired via
+ * `adaptOperation`; the five Botholomew-side wrappers (edit, copy, exists,
+ * count_lines, pipe) bolt on the file-shaped UX our agents already know.
+ */
+export function registerMembotTools(): void {
+  for (const op of OPERATIONS) {
+    registerTool(adaptOperation(op) as unknown as AnyToolDefinition);
+  }
+  registerTool(membotEditTool);
+  registerTool(membotCopyTool);
+  registerTool(membotExistsTool);
+  registerTool(membotCountLinesTool);
+  registerTool(membotPipeTool);
+}

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(