botholomew 0.12.5 → 0.14.0

package/src/tools/file/edit.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
-import { ingestByPath } from "../../context/ingest.ts";
-import { applyPatchesToContextItem } from "../../db/context.ts";
+import {
+  applyPatches,
+  IsDirectoryError,
+  NotFoundError,
+  readContextFile,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const PatchSchema = z.object({
@@ -14,8 +18,7 @@ const PatchSchema = z.object({
 });
 
 const inputSchema = z.object({
-  drive: z.string().describe("Drive name (e.g. 'agent', 'disk')"),
-  path: z.string().describe("Path within the drive (starts with /)"),
+  path: z.string().describe("Project-relative path under context/"),
   patches: z.array(PatchSchema).describe("Patches to apply"),
 });
 
@@ -23,24 +26,46 @@ const outputSchema = z.object({
   applied: z.number(),
   content: z.string(),
   is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
 });
 
 export const contextEditTool = {
   name: "context_edit",
   description:
-    "[[ bash equivalent command: patch ]] Apply git-style patches to a context item. Each patch specifies a line range to replace.",
+    "[[ bash equivalent command: patch ]] Apply line-range patches to a file under context/. Each patch specifies start_line/end_line/content. Edits that traverse a user symlink fail with PathEscapeError — delete the symlink first or copy the content to a real path.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const target = { drive: input.drive, path: input.path };
-    const { item, applied } = await applyPatchesToContextItem(
-      ctx.conn,
-      target,
-      input.patches,
-    );
-
-    await ingestByPath(ctx.conn, target, ctx.config);
-    return { applied, content: item.content ?? "", is_error: false };
+    try {
+      const { applied } = await applyPatches(
+        ctx.projectDir,
+        input.path,
+        input.patches,
+      );
+      const content = await readContextFile(ctx.projectDir, input.path);
+      return { applied, content, is_error: false };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return {
+          applied: 0,
+          content: "",
+          is_error: true,
+          error_type: "not_found",
+          message: `No file at context/${err.path}`,
+        };
+      }
+      if (err instanceof IsDirectoryError) {
+        return {
+          applied: 0,
+          content: "",
+          is_error: true,
+          error_type: "is_directory",
+          message: `context/${err.path} is a directory`,
+        };
+      }
+      throw err;
+    }
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/exists.ts

@@ -1,17 +1,10 @@
 import { z } from "zod";
-import { parseDriveRef } from "../../context/drives.ts";
-import { getContextItem, getContextItemById } from "../../db/context.ts";
-import { isUuid } from "../../db/uuid.ts";
+import { fileExists } from "../../context/store.ts";
+import { PathEscapeError } from "../../fs/sandbox.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  drive: z
-    .string()
-    .optional()
-    .describe("Drive name. Optional when `path` is a UUID or 'drive:/path'."),
-  path: z
-    .string()
-    .describe("Path within the drive (or UUID / drive:/path ref)"),
+  path: z.string().describe("Path under context/"),
 });
 
 const outputSchema = z.object({
@@ -22,26 +15,19 @@ const outputSchema = z.object({
 export const contextExistsTool = {
   name: "context_exists",
   description:
-    "[[ bash equivalent command: test -e ]] Check if a context item exists.",
+    "[[ bash equivalent command: test -e ]] Check whether a path exists under context/.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    if (isUuid(input.path)) {
-      const item = await getContextItemById(ctx.conn, input.path);
-      return { exists: item !== null, is_error: false };
+    try {
+      const exists = await fileExists(ctx.projectDir, input.path);
+      return { exists, is_error: false };
+    } catch (err) {
+      if (err instanceof PathEscapeError) {
+        return { exists: false, is_error: false };
+      }
+      throw err;
     }
-    const parsed = parseDriveRef(input.path);
-    if (parsed) {
-      const item = await getContextItem(ctx.conn, parsed);
-      return { exists: item !== null, is_error: false };
-    }
-    if (!input.drive) return { exists: false, is_error: false };
-    const path = input.path.startsWith("/") ? input.path : `/${input.path}`;
-    const item = await getContextItem(ctx.conn, {
-      drive: input.drive,
-      path,
-    });
-    return { exists: item !== null, is_error: false };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/info.ts

@@ -1,41 +1,21 @@
 import { z } from "zod";
-import { formatDriveRef, parseDriveRef } from "../../context/drives.ts";
-import {
-  findNearbyContextPaths,
-  getContextItem,
-  getContextItemById,
-} from "../../db/context.ts";
-import { isUuid } from "../../db/uuid.ts";
+import { getInfo, readContextFile } from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  drive: z
-    .string()
-    .optional()
-    .describe(
-      "Drive name (e.g. 'disk', 'url', 'agent'). Optional when `path` is a UUID or already in `drive:/...` form.",
-    ),
-  path: z
-    .string()
-    .describe(
-      "Path within the drive (starts with /), or a bare UUID / 'drive:/path' ref.",
-    ),
+  path: z.string().describe("Path under context/"),
 });
 
 const fileSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  description: z.string(),
-  mime_type: z.string(),
+  path: z.string(),
+  is_directory: z.boolean(),
   is_textual: z.boolean(),
+  is_symlink: z.boolean(),
+  mime_type: z.string(),
   size: z.number(),
   lines: z.number(),
-  drive: z.string(),
-  path: z.string(),
-  ref: z.string(),
-  indexed_at: z.string().nullable(),
-  created_at: z.string(),
-  updated_at: z.string(),
+  mtime: z.string(),
+  content_hash: z.string().nullable(),
 });
 
 const outputSchema = z.object({
@@ -49,74 +29,36 @@ const outputSchema = z.object({
 export const contextInfoTool = {
   name: "context_info",
   description:
-    "[[ bash equivalent command: stat ]] Show context item metadata: size, MIME type, line count, etc.",
+    "[[ bash equivalent command: stat ]] Show metadata for a path under context/: size, MIME type, line count, mtime, content hash. `is_symlink` is true when the path is a user-placed symlink.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    let drive = input.drive;
-    let path = input.path;
-    if (isUuid(input.path)) {
-      const byId = await getContextItemById(ctx.conn, input.path);
-      if (byId) {
-        drive = byId.drive;
-        path = byId.path;
-      }
-    } else {
-      const parsed = parseDriveRef(input.path);
-      if (parsed) {
-        drive = parsed.drive;
-        path = parsed.path;
-      }
-    }
-
-    if (!drive) {
-      return {
-        is_error: true,
-        error_type: "missing_drive",
-        message: `Cannot resolve context item: no drive provided and \`${input.path}\` is not a UUID or \`drive:/path\` ref.`,
-        next_action_hint:
-          "Pass `drive` explicitly, or use a `drive:/path` ref. Call context_list_drives to see which drives exist.",
-      };
-    }
-
-    if (!path.startsWith("/")) path = `/${path}`;
-
-    const item = await getContextItem(ctx.conn, { drive, path });
-    if (!item) {
-      const { parent, siblings, walkedUp } = await findNearbyContextPaths(
-        ctx.conn,
-        drive,
-        path,
-      );
-      const hint =
-        siblings.length > 0
-          ? `${walkedUp ? `Parent ${parent} has no direct entries; ` : ""}Nearby items under ${parent}: ${siblings.join(", ")}. Call context_tree({drive:"${drive}",path:"${parent.replace(/^[^:]*:/, "")}"}) to see more.`
-          : `No items found under ${parent}. Call context_list_drives to see which drives exist.`;
+    const info = await getInfo(ctx.projectDir, input.path);
+    if (!info) {
       return {
         is_error: true,
         error_type: "not_found",
-        message: `No context item at ${formatDriveRef({ drive, path })}`,
-        next_action_hint: hint,
+        message: `No path at context/${input.path}`,
+        next_action_hint: "Call context_tree to browse.",
       };
     }
-
-    const content = item.content ?? "";
+    let lines = 0;
+    if (info.is_textual && !info.is_directory) {
+      const content = await readContextFile(ctx.projectDir, input.path);
+      lines = content === "" ? 0 : content.split("\n").length;
+    }
     return {
       file: {
-        id: item.id,
-        title: item.title,
-        description: item.description,
-        mime_type: item.mime_type,
-        is_textual: item.is_textual,
-        size: content.length,
-        lines: content ? content.split("\n").length : 0,
-        drive: item.drive,
-        path: item.path,
-        ref: formatDriveRef(item),
-        indexed_at: item.indexed_at?.toISOString() ?? null,
-        created_at: item.created_at.toISOString(),
-        updated_at: item.updated_at.toISOString(),
+        path: info.path,
+        is_directory: info.is_directory,
+        is_textual: info.is_textual,
+        is_symlink: info.is_symlink,
+        mime_type: info.mime_type,
+        size: info.size,
+        lines,
+        mtime: info.mtime.toISOString(),
+        content_hash: info.content_hash,
       },
       is_error: false,
     };

package/src/tools/file/move.ts

@@ -1,46 +1,61 @@
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
 import {
-  contextPathExists,
-  deleteContextItemByPath,
-  moveContextItem,
-} from "../../db/context.ts";
+  deleteContextPath,
+  fileExists,
+  moveContextPath,
+  NotFoundError,
+  PathConflictError,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  src_drive: z.string().describe("Source drive"),
-  src_path: z.string().describe("Source path within the drive"),
-  dst_drive: z.string().describe("Destination drive"),
-  dst_path: z.string().describe("Destination path within the drive"),
+  src: z.string().describe("Source path under context/"),
+  dst: z.string().describe("Destination path under context/"),
   overwrite: z.boolean().optional().describe("Overwrite if destination exists"),
 });
 
 const outputSchema = z.object({
-  ref: z.string(),
+  src: z.string(),
+  dst: z.string(),
   is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
 });
 
 export const contextMoveTool = {
   name: "context_move",
   description:
-    "[[ bash equivalent command: mv ]] Move or rename a context item (can also relocate between drives).",
+    "[[ bash equivalent command: mv ]] Move or rename a file/directory under context/. Source/destination paths that traverse a user symlink fail with PathEscapeError.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const src = { drive: input.src_drive, path: input.src_path };
-    const dst = { drive: input.dst_drive, path: input.dst_path };
-
-    const dstExists = await contextPathExists(ctx.conn, dst);
-    if (dstExists && !input.overwrite) {
-      throw new Error(`Destination already exists: ${formatDriveRef(dst)}`);
-    }
-    if (dstExists) {
-      await deleteContextItemByPath(ctx.conn, dst);
+    try {
+      if (input.overwrite && (await fileExists(ctx.projectDir, input.dst))) {
+        await deleteContextPath(ctx.projectDir, input.dst, { recursive: true });
+      }
+      await moveContextPath(ctx.projectDir, input.src, input.dst);
+      return { src: input.src, dst: input.dst, is_error: false };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return {
+          src: input.src,
+          dst: input.dst,
+          is_error: true,
+          error_type: "not_found",
+          message: `No file at context/${err.path}`,
+        };
+      }
+      if (err instanceof PathConflictError) {
+        return {
+          src: input.src,
+          dst: input.dst,
+          is_error: true,
+          error_type: "path_conflict",
+          message: `Destination already exists at context/${err.path}; pass overwrite=true to replace.`,
+        };
+      }
+      throw err;
     }
-
-    await moveContextItem(ctx.conn, src, dst);
-
-    return { ref: formatDriveRef(dst), is_error: false };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/read.ts

@@ -1,24 +1,16 @@
 import { z } from "zod";
-import { formatDriveRef, parseDriveRef } from "../../context/drives.ts";
 import {
-  findNearbyContextPaths,
-  getContextItem,
-  getContextItemById,
-} from "../../db/context.ts";
-import { isUuid } from "../../db/uuid.ts";
+  IsDirectoryError,
+  NotFoundError,
+  readContextFile,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  drive: z
-    .string()
-    .optional()
-    .describe(
-      "Drive name (e.g. 'disk', 'url', 'agent', 'google-docs', 'github'). Use context_list_drives to see what's available. Optional when `path` is a UUID or already in `drive:/...` form.",
-    ),
   path: z
     .string()
     .describe(
-      "Path within the drive (starts with /), or a bare UUID / 'drive:/path' ref (in which case `drive` is ignored).",
+      "Project-relative path under context/ (e.g. 'notes/foo.md'). Forward-slashes; never absolute.",
     ),
   offset: z
     .number()
@@ -37,79 +29,39 @@ const outputSchema = z.object({
 
 export const contextReadTool = {
   name: "context_read",
-  description:
-    "[[ bash equivalent command: cat ]] Read a context item's contents.",
+  description: "[[ bash equivalent command: cat ]] Read a file under context/.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    // Accept either (drive, path) or a bare UUID / drive:/path ref in `path`.
-    let drive = input.drive;
-    let path = input.path;
-    if (isUuid(input.path)) {
-      const byId = await getContextItemById(ctx.conn, input.path);
-      if (byId) {
-        drive = byId.drive;
-        path = byId.path;
+    try {
+      let content = await readContextFile(ctx.projectDir, input.path);
+      if (input.offset || input.limit) {
+        const lines = content.split("\n");
+        const start = (input.offset ?? 1) - 1;
+        const end = input.limit ? start + input.limit : lines.length;
+        content = lines.slice(start, end).join("\n");
       }
-    } else {
-      const parsed = parseDriveRef(input.path);
-      if (parsed) {
-        drive = parsed.drive;
-        path = parsed.path;
+      return { content, is_error: false };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return {
+          is_error: true,
+          error_type: "not_found",
+          message: `No file at context/${err.path}`,
+          next_action_hint:
+            "Call context_tree to browse, or context_exists to check first.",
+        };
       }
+      if (err instanceof IsDirectoryError) {
+        return {
+          is_error: true,
+          error_type: "is_directory",
+          message: `context/${err.path} is a directory`,
+          next_action_hint: "Use context_tree to list its contents.",
+        };
+      }
+      throw err;
     }
-
-    if (!drive) {
-      return {
-        is_error: true,
-        error_type: "missing_drive",
-        message: `Cannot resolve context item: no drive provided and \`${input.path}\` is not a UUID or \`drive:/path\` ref.`,
-        next_action_hint:
-          "Pass `drive` explicitly, or use a `drive:/path` ref. Call context_list_drives to see which drives exist.",
-      };
-    }
-
-    if (!path.startsWith("/")) path = `/${path}`;
-
-    const item = await getContextItem(ctx.conn, { drive, path });
-    if (!item) {
-      const { parent, siblings, walkedUp } = await findNearbyContextPaths(
-        ctx.conn,
-        drive,
-        path,
-      );
-      const hint =
-        siblings.length > 0
-          ? `${walkedUp ? `Parent ${parent} has no direct entries; ` : ""}Nearby items under ${parent}: ${siblings.join(", ")}. Call context_tree({drive:"${drive}",path:"${parent.replace(/^[^:]*:/, "")}"}) to see more.`
-          : `No items found under ${parent}. Call context_list_drives to see which drives exist.`;
-      return {
-        is_error: true,
-        error_type: "not_found",
-        message: `No context item at ${formatDriveRef({ drive, path })}`,
-        next_action_hint: hint,
-      };
-    }
-
-    if (item.content == null) {
-      return {
-        is_error: true,
-        error_type: "no_text_content",
-        message: `Context item ${formatDriveRef(item)} has no text content (mime: ${item.mime_type})`,
-        next_action_hint:
-          "Binary items can't be read as text. Call context_info to inspect metadata, or pick a textual sibling.",
-      };
-    }
-
-    let content = item.content;
-
-    if (input.offset || input.limit) {
-      const lines = content.split("\n");
-      const start = (input.offset ?? 1) - 1;
-      const end = input.limit ? start + input.limit : lines.length;
-      content = lines.slice(start, end).join("\n");
-    }
-
-    return { content, is_error: false };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/write.ts

@@ -1,132 +1,55 @@
-import { isText } from "istextorbinary";
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
-import { ingestByPath } from "../../context/ingest.ts";
-import {
-  createContextItemStrict,
-  PathConflictError,
-  upsertContextItem,
-} from "../../db/context.ts";
-import { buildContextTree } from "../dir/tree.ts";
+import { PathConflictError, writeContextFile } from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
-function mimeFromPath(path: string): string {
-  const type = Bun.file(path).type.split(";")[0];
-  return type ?? "application/octet-stream";
-}
-
-function isTextualPath(path: string): boolean {
-  const filename = path.split("/").pop() ?? path;
-  const result = isText(filename);
-  return result !== false;
-}
-
 const inputSchema = z.object({
-  drive: z
+  path: z
     .string()
-    .default("agent")
     .describe(
-      "Drive to write to (defaults to 'agent', which is the agent's scratch drive). Only 'agent' and drives mirroring an external system you can write back to make sense here.",
+      "Project-relative path under context/ (e.g. 'notes/foo.md'). Created if its parent directory does not exist.",
     ),
-  path: z.string().describe("Path within the drive (starts with /)"),
   content: z.string().describe("Text content to write"),
-  content_base64: z
-    .string()
-    .optional()
-    .describe(
-      "Base64-encoded binary content (used instead of content for binary files)",
-    ),
-  title: z
-    .string()
-    .optional()
-    .describe("Title for the file (defaults to filename)"),
-  description: z.string().optional().describe("Description of the file"),
   on_conflict: z
     .enum(["error", "overwrite"])
     .optional()
     .describe(
-      "What to do if a file already exists at this (drive, path). Defaults to 'error'. Pass 'overwrite' to replace.",
+      "What to do if the file already exists. Defaults to 'error'. Pass 'overwrite' to replace.",
     ),
 });
 
 const outputSchema = z.object({
-  id: z.string().nullable(),
-  drive: z.string(),
   path: z.string(),
-  ref: z.string(),
   is_error: z.boolean(),
   error_type: z.string().optional(),
   message: z.string().optional(),
   next_action_hint: z.string().optional(),
-  tree: z
-    .string()
-    .optional()
-    .describe(
-      "Snapshot of the drive's tree after the write so you can see the surrounding files.",
-    ),
 });
 
 export const contextWriteTool = {
   name: "context_write",
   description:
-    "[[ bash equivalent command: tee ]] Write content to a context item. By default writes to drive='agent' (the agent's scratch drive). Fails if the (drive, path) already exists — pass on_conflict='overwrite' to replace.",
+    "[[ bash equivalent command: tee ]] Write text content to a file under context/. Fails if the path already exists unless on_conflict='overwrite'. Writes that traverse a user symlink fail with PathEscapeError — delete the symlink first or write to a real path.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const mimeType = mimeFromPath(input.path);
-    const isTextual = isTextualPath(input.path);
-    const title =
-      input.title ?? input.path.split("/").filter(Boolean).pop() ?? input.path;
-    const onConflict = input.on_conflict ?? "error";
-    const target = { drive: input.drive, path: input.path };
-
     try {
-      const item =
-        onConflict === "overwrite"
-          ? await upsertContextItem(ctx.conn, {
-              title,
-              description: input.description,
-              content: input.content_base64 ?? input.content,
-              drive: target.drive,
-              path: target.path,
-              mimeType,
-              isTextual,
-            })
-          : await createContextItemStrict(ctx.conn, {
-              title,
-              description: input.description,
-              content: input.content_base64 ?? input.content,
-              drive: target.drive,
-              path: target.path,
-              mimeType,
-              isTextual,
-            });
-
-      await ingestByPath(ctx.conn, target, ctx.config);
-      const { tree } = await buildContextTree(ctx.conn, {
-        drive: target.drive,
-      });
-      return {
-        id: item.id,
-        drive: item.drive,
-        path: item.path,
-        ref: formatDriveRef(item),
-        is_error: false,
-        tree,
-      };
+      const entry = await writeContextFile(
+        ctx.projectDir,
+        input.path,
+        input.content,
+        { onConflict: input.on_conflict ?? "error" },
+      );
+      return { path: entry.path, is_error: false };
     } catch (err) {
       if (err instanceof PathConflictError) {
         return {
-          id: null,
-          drive: err.drive,
           path: err.path,
-          ref: formatDriveRef({ drive: err.drive, path: err.path }),
           is_error: true,
           error_type: "path_conflict",
-          message: `A file already exists at ${formatDriveRef({ drive: err.drive, path: err.path })} (id: ${err.existingId}).`,
+          message: `A file already exists at context/${err.path}.`,
           next_action_hint:
-            "Call context_read to inspect the existing file, or retry with on_conflict='overwrite' to replace it.",
+            "Call context_read to inspect, or retry with on_conflict='overwrite'.",
         };
       }
       throw err;