botholomew 0.12.5 → 0.14.0

package/src/tools/dir/tree.ts

@@ -1,237 +1,56 @@
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
-import type { DbConnection } from "../../db/connection.ts";
 import {
-  countContextItemsByPrefix,
-  listContextItemsByPrefix,
-  listDriveSummaries,
-} from "../../db/context.ts";
+  buildTree,
+  NotFoundError,
+  type TreeNode,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const DEFAULT_MAX_DEPTH = 10;
-const DEFAULT_ITEMS_PER_DIR = 15;
-const HARD_FETCH_CAP = 1000;
-
-export interface BuildContextTreeOptions {
-  drive?: string;
-  path?: string;
-  maxDepth?: number;
-  itemsPerDir?: number;
-}
 
 export interface BuildContextTreeResult {
   tree: string;
   total_items: number;
-  truncated_dirs: Array<{ path: string; shown: number; total: number }>;
   hint: string;
 }
 
-interface DirNode {
-  name: string;
-  fullPath: string;
-  isDir: true;
-  children: TreeEntry[];
-}
-
-interface FileNode {
-  name: string;
-  fullPath: string;
-  isDir: false;
-}
-
-type TreeEntry = DirNode | FileNode;
-
 /**
- * Build a markdown tree for a single drive, or — when no drive is given — a
- * top-level summary listing every drive with its item count.
+ * Render a TreeNode as an indented string. Files are listed; directories show
+ * children. Depth is enforced inside `buildTree`.
  */
-export async function buildContextTree(
-  conn: DbConnection,
-  options: BuildContextTreeOptions = {},
-): Promise<BuildContextTreeResult> {
-  if (!options.drive) {
-    const summaries = await listDriveSummaries(conn);
-    if (summaries.length === 0) {
-      return {
-        tree: "(no drives — context is empty)",
-        total_items: 0,
-        truncated_dirs: [],
-        hint: "No context has been ingested yet. Use `context add` from the CLI to ingest files or URLs.",
-      };
-    }
-    const lines = [
-      "Drives:",
-      ...summaries.map(
-        (s) =>
-          `  ${s.drive}:/  (${s.count} ${s.count === 1 ? "item" : "items"})`,
-      ),
-    ];
-    const total = summaries.reduce((sum, s) => sum + s.count, 0);
-    return {
-      tree: lines.join("\n"),
-      total_items: total,
-      truncated_dirs: [],
-      hint: `Call context_tree with drive="<name>" to drill into a drive.`,
-    };
-  }
-
-  const drive = options.drive;
-  const path = options.path ?? "/";
-  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const itemsPerDir = options.itemsPerDir ?? DEFAULT_ITEMS_PER_DIR;
-  const normalizedPath = path.endsWith("/") ? path : `${path}/`;
-  const rootLabel = formatDriveRef({ drive, path });
-
-  const totalItems = await countContextItemsByPrefix(conn, drive, path, {
-    recursive: true,
-  });
-
-  if (totalItems === 0) {
-    return {
-      tree: `${rootLabel}\n  (empty)`,
-      total_items: 0,
-      truncated_dirs: [],
-      hint: "Directory is empty.",
-    };
-  }
-
-  const items = await listContextItemsByPrefix(conn, drive, path, {
-    recursive: true,
-    limit: HARD_FETCH_CAP,
-  });
-
-  const root: DirNode = {
-    name: rootLabel,
-    fullPath: path,
-    isDir: true,
-    children: [],
-  };
-  const dirIndex = new Map<string, DirNode>();
-  dirIndex.set(stripTrailingSlash(path), root);
-
-  for (const item of items) {
-    const relative = item.path.slice(normalizedPath.length);
-    if (relative.length === 0) continue;
-    const parts = relative.split("/").filter((p) => p.length > 0);
-    const isExplicitDir = item.mime_type === "inode/directory";
-
-    let parentDir = root;
-    let currentRel = "";
-    for (let i = 0; i < parts.length; i++) {
-      const segment = parts[i];
-      if (!segment) continue;
-      currentRel = currentRel ? `${currentRel}/${segment}` : segment;
-      const fullPath = `${normalizedPath}${currentRel}`;
-      const isLeaf = i === parts.length - 1;
-      const isDirHere = !isLeaf || isExplicitDir;
-
-      if (isDirHere) {
-        const key = stripTrailingSlash(fullPath);
-        let dir = dirIndex.get(key);
-        if (!dir) {
-          dir = {
-            name: segment,
-            fullPath,
-            isDir: true,
-            children: [],
-          };
-          dirIndex.set(key, dir);
-          parentDir.children.push(dir);
-        }
-        parentDir = dir;
-      } else {
-        parentDir.children.push({
-          name: segment,
-          fullPath,
-          isDir: false,
-        });
-      }
-    }
-  }
-
-  for (const dir of dirIndex.values()) {
-    dir.children.sort((a, b) => {
-      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
-      return a.name.localeCompare(b.name);
+function renderTree(node: TreeNode, prefix = "", isLast = true): string[] {
+  const lines: string[] = [];
+  const connector = prefix === "" ? "" : isLast ? "└── " : "├── ";
+  const base = node.is_directory ? `${node.name}/` : node.name;
+  const label = node.is_symlink ? `${base} -> (symlink)` : base;
+  lines.push(`${prefix}${connector}${label}`);
+  if (node.is_directory && node.children) {
+    const childPrefix =
+      prefix + (prefix === "" ? "" : isLast ? "    " : "│   ");
+    const children = node.children;
+    children.forEach((c, i) => {
+      const last = i === children.length - 1;
+      lines.push(...renderTree(c, childPrefix, last));
     });
   }
+  return lines;
+}
 
-  const truncatedDirs: Array<{
-    path: string;
-    shown: number;
-    total: number;
-  }> = [];
-  const depthLimitedDirs: string[] = [];
-
-  const lines: string[] = [rootLabel];
-
-  const render = (dir: DirNode, indent: string, currentDepth: number): void => {
-    const children = dir.children;
-    const total = children.length;
-    const shown = Math.min(total, itemsPerDir);
-    const visible = children.slice(0, shown);
-    const overflow = total - shown;
-
-    if (overflow > 0) {
-      truncatedDirs.push({
-        path: stripTrailingSlash(dir.fullPath),
-        shown,
-        total,
-      });
-    }
-
-    for (let i = 0; i < visible.length; i++) {
-      const child = visible[i];
-      if (!child) continue;
-      const isLastVisible = i === visible.length - 1 && overflow === 0;
-      const connector = isLastVisible ? "└── " : "├── ";
-      const childIndent = isLastVisible ? "    " : "│   ";
-
-      if (child.isDir) {
-        const atDepthLimit = currentDepth + 1 >= maxDepth;
-        if (atDepthLimit && child.children.length > 0) {
-          depthLimitedDirs.push(stripTrailingSlash(child.fullPath));
-          const subCount = countDescendants(child);
-          lines.push(
-            `${indent}${connector}${child.name}/ (${subCount} ${
-              subCount === 1 ? "item" : "items"
-            }, drill in)`,
-          );
-        } else {
-          lines.push(`${indent}${connector}${child.name}/`);
-          render(child, indent + childIndent, currentDepth + 1);
-        }
-      } else {
-        lines.push(`${indent}${connector}${child.name}`);
-      }
-    }
-
-    if (overflow > 0) {
-      lines.push(`${indent}└── ... (+${overflow} more)`);
-    }
-  };
-
-  render(root, "", 0);
-
-  return {
-    tree: lines.join("\n"),
-    total_items: totalItems,
-    truncated_dirs: truncatedDirs,
-    hint: buildHint({ truncatedDirs, depthLimitedDirs, totalItems, drive }),
-  };
+function countItems(node: TreeNode): number {
+  if (!node.is_directory) return 1;
+  let total = 0;
+  for (const c of node.children ?? []) total += countItems(c);
+  return total;
 }
 
 const inputSchema = z.object({
-  drive: z
+  path: z
     .string()
     .optional()
+    .default("")
     .describe(
-      "Drive to explore (e.g. 'disk', 'agent'). Omit to list every drive with its item count — useful as a first call.",
+      "Directory path under context/ to render (defaults to the context root).",
     ),
-  path: z
-    .string()
-    .optional()
-    .describe("Root path for the tree within the drive (defaults to /)"),
   max_depth: z
     .number()
     .int()
@@ -239,91 +58,67 @@ const inputSchema = z.object({
     .optional()
     .default(DEFAULT_MAX_DEPTH)
     .describe(
-      `Maximum depth of directories to render (defaults to ${DEFAULT_MAX_DEPTH}). Use a deeper path to drill in.`,
-    ),
-  items_per_dir: z
-    .number()
-    .int()
-    .positive()
-    .optional()
-    .default(DEFAULT_ITEMS_PER_DIR)
-    .describe(
-      `Maximum entries shown per directory (defaults to ${DEFAULT_ITEMS_PER_DIR}). Overflow shown as "(+N more)".`,
+      `Maximum depth of directories to render (defaults to ${DEFAULT_MAX_DEPTH}).`,
     ),
 });
 
-const TruncatedDirSchema = z.object({
-  path: z.string(),
-  shown: z.number(),
-  total: z.number(),
-});
-
 const outputSchema = z.object({
   tree: z.string(),
-  is_error: z.boolean(),
   total_items: z.number(),
-  truncated_dirs: z.array(TruncatedDirSchema),
-  hint: z.string(),
+  is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
 });
 
 export const contextTreeTool = {
   name: "context_tree",
   description:
-    "[[ bash equivalent command: tree ]] Explore your context with a bird's-eye view. Call with no `drive` to list every drive; call with a drive (and optional path) to render a tree of that drive. Returns a markdown-style tree; tune max_depth and items_per_dir to bound output.",
+    "[[ bash equivalent command: tree ]] Render the file tree under context/ (or a sub-directory). Symlinks are followed for listing and indexing; entries that are symlinks are tagged ' -> (symlink)' in the output.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const result = await buildContextTree(ctx.conn, {
-      drive: input.drive,
-      path: input.path,
-      maxDepth: input.max_depth,
-      itemsPerDir: input.items_per_dir,
-    });
-    return { ...result, is_error: false };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;
-
-function stripTrailingSlash(p: string): string {
-  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
-}
-
-function countDescendants(dir: DirNode): number {
-  let count = 0;
-  for (const child of dir.children) {
-    count += 1;
-    if (child.isDir) count += countDescendants(child);
-  }
-  return count;
-}
-
-function buildHint(args: {
-  truncatedDirs: Array<{ path: string; shown: number; total: number }>;
-  depthLimitedDirs: string[];
-  totalItems: number;
-  drive: string;
-}): string {
-  const { truncatedDirs, depthLimitedDirs, drive } = args;
-  const parts: string[] = [];
-
-  if (truncatedDirs.length > 0) {
-    const first = truncatedDirs[0];
-    if (first) {
-      parts.push(
-        `${truncatedDirs.length} ${truncatedDirs.length === 1 ? "directory was" : "directories were"} capped by items_per_dir; raise items_per_dir or call context_tree with drive="${drive}", path="${first.path}".`,
-      );
-    }
-  }
-
-  if (depthLimitedDirs.length > 0) {
-    const first = depthLimitedDirs[0];
-    if (first) {
-      parts.push(
-        `${depthLimitedDirs.length} ${depthLimitedDirs.length === 1 ? "directory was" : "directories were"} not expanded due to max_depth; raise max_depth or call context_tree with drive="${drive}", path="${first}".`,
+    try {
+      const node = await buildTree(
+        ctx.projectDir,
+        input.path ?? "",
+        input.max_depth,
       );
+      return {
+        tree: renderTree(node).join("\n"),
+        total_items: countItems(node),
+        is_error: false,
+      };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return {
+          tree: "",
+          total_items: 0,
+          is_error: true,
+          error_type: "not_found",
+          message: `No path at context/${err.path}`,
+        };
+      }
+      throw err;
     }
-  }
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;
 
-  if (parts.length === 0) return "Tree is complete.";
-  return parts.join(" ");
+/**
+ * Convenience for callers that want a string tree from outside the tool layer.
+ */
+export async function buildContextTree(
+  projectDir: string,
+  opts: { path?: string; maxDepth?: number } = {},
+): Promise<BuildContextTreeResult> {
+  const node = await buildTree(
+    projectDir,
+    opts.path ?? "",
+    opts.maxDepth ?? DEFAULT_MAX_DEPTH,
+  );
+  return {
+    tree: renderTree(node).join("\n"),
+    total_items: countItems(node),
+    hint: "",
+  };
 }

package/src/tools/file/copy.ts

@@ -1,45 +1,71 @@
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
 import {
-  contextPathExists,
-  copyContextItem,
-  deleteContextItemByPath,
-} from "../../db/context.ts";
+  copyContextPath,
+  deleteContextPath,
+  fileExists,
+  IsDirectoryError,
+  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({
-  id: z.string(),
-  ref: z.string(),
+  src: z.string(),
+  dst: z.string(),
   is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
 });
 
 export const contextCopyTool = {
   name: "context_copy",
-  description: "[[ bash equivalent command: cp ]] Copy a context item.",
+  description:
+    "[[ bash equivalent command: cp ]] Copy a file under context/ to a new path. 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);
+      }
+      await copyContextPath(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.`,
+        };
+      }
+      if (err instanceof IsDirectoryError) {
+        return {
+          src: input.src,
+          dst: input.dst,
+          is_error: true,
+          error_type: "is_directory",
+          message: `Source is a directory: context/${err.path}. Copy is file-only.`,
+        };
+      }
+      throw err;
     }
-
-    const item = await copyContextItem(ctx.conn, src, dst);
-    return { id: item.id, ref: formatDriveRef(item), is_error: false };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/count-lines.ts

@@ -1,30 +1,54 @@
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
-import { resolveContextItemOrThrow } from "../../db/context.ts";
+import {
+  IsDirectoryError,
+  NotFoundError,
+  readContextFile,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  drive: z.string().describe("Drive name (e.g. 'disk', 'agent')"),
-  path: z.string().describe("Path within the drive"),
+  path: z.string().describe("Path under context/"),
 });
 
 const outputSchema = z.object({
   lines: z.number(),
   is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
 });
 
 export const contextCountLinesTool = {
   name: "context_count_lines",
   description:
-    "[[ bash equivalent command: wc -l ]] Count the number of lines in a text context item.",
+    "[[ bash equivalent command: wc -l ]] Count the number of lines in a text file under context/.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const ref = formatDriveRef({ drive: input.drive, path: input.path });
-    const item = await resolveContextItemOrThrow(ctx.conn, ref);
-    if (item.content == null) throw new Error(`No text content: ${ref}`);
-
-    return { lines: item.content.split("\n").length, is_error: false };
+    try {
+      const content = await readContextFile(ctx.projectDir, input.path);
+      return {
+        lines: content === "" ? 0 : content.split("\n").length,
+        is_error: false,
+      };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return {
+          lines: 0,
+          is_error: true,
+          error_type: "not_found",
+          message: `No file at context/${err.path}`,
+        };
+      }
+      if (err instanceof IsDirectoryError) {
+        return {
+          lines: 0,
+          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/delete.ts

@@ -1,18 +1,17 @@
 import { z } from "zod";
-import { formatDriveRef } from "../../context/drives.ts";
 import {
-  deleteContextItemByPath,
-  deleteContextItemsByPrefix,
-} from "../../db/context.ts";
+  deleteContextPath,
+  IsDirectoryError,
+  NotFoundError,
+} from "../../context/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  drive: z.string().describe("Drive name"),
-  path: z.string().describe("Path to delete within the drive"),
+  path: z.string().describe("Path under context/ to delete"),
   recursive: z
     .boolean()
     .optional()
-    .describe("Delete all items under this path prefix"),
+    .describe("Delete a directory and its contents recursively"),
   force: z
     .boolean()
     .optional()
@@ -21,32 +20,63 @@ const inputSchema = z.object({
 
 const outputSchema = z.object({
   deleted: z.number(),
+  was_directory: z.boolean(),
+  was_symlink: z.boolean(),
   is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
 });
 
 export const contextDeleteTool = {
   name: "context_delete",
   description:
-    "[[ bash equivalent command: rm -r ]] Delete a context item or directory.",
+    "[[ bash equivalent command: rm -r ]] Delete a file or (with recursive=true) a directory under context/. Symlinks are unlinked without touching their target — `recursive` is not required for a symlinked directory.",
   group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const target = { drive: input.drive, path: input.path };
-    if (input.recursive) {
-      const count = await deleteContextItemsByPrefix(
-        ctx.conn,
-        target.drive,
-        target.path,
-      );
-      const exact = await deleteContextItemByPath(ctx.conn, target);
-      return { deleted: count + (exact ? 1 : 0), is_error: false };
+    try {
+      const result = await deleteContextPath(ctx.projectDir, input.path, {
+        recursive: input.recursive,
+      });
+      return {
+        deleted: result.removed,
+        was_directory: result.was_directory,
+        was_symlink: result.was_symlink,
+        is_error: false,
+      };
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        if (input.force) {
+          return {
+            deleted: 0,
+            was_directory: false,
+            was_symlink: false,
+            is_error: false,
+          };
+        }
+        return {
+          deleted: 0,
+          was_directory: false,
+          was_symlink: false,
+          is_error: true,
+          error_type: "not_found",
+          message: `No file at context/${err.path}`,
+        };
+      }
+      if (err instanceof IsDirectoryError) {
+        return {
+          deleted: 0,
+          was_directory: true,
+          was_symlink: false,
+          is_error: true,
+          error_type: "is_directory",
+          message: `context/${err.path} is a directory`,
+          next_action_hint: "Pass recursive=true to delete a directory tree.",
+        };
+      }
+      throw err;
     }
-
-    const deleted = await deleteContextItemByPath(ctx.conn, target);
-    if (!deleted && !input.force) {
-      throw new Error(`Not found: ${formatDriveRef(target)}`);
-    }
-    return { deleted: deleted ? 1 : 0, is_error: false };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;