botholomew 0.1.0

package/src/tools/dir/tree.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { listContextItemsByPrefix } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const DEFAULT_MAX_ITEMS = 200;
+
+const inputSchema = z.object({
+  path: z
+    .string()
+    .optional()
+    .describe("Root path for the tree (defaults to /)"),
+  max_items: z
+    .number()
+    .optional()
+    .default(DEFAULT_MAX_ITEMS)
+    .describe(
+      `Maximum number of items to include (defaults to ${DEFAULT_MAX_ITEMS})`,
+    ),
+});
+
+const outputSchema = z.object({
+  tree: z.string(),
+});
+
+export const dirTreeTool = {
+  name: "dir_tree",
+  description:
+    "Render a directory as a markdown-style tree in the virtual filesystem.",
+  group: "dir",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const path = input.path ?? "/";
+    const maxItems = input.max_items ?? DEFAULT_MAX_ITEMS;
+    const items = await listContextItemsByPrefix(ctx.conn, path, {
+      recursive: true,
+      limit: maxItems,
+    });
+
+    if (items.length === 0) {
+      return { tree: `${path}\n  (empty)` };
+    }
+
+    const normalizedPath = path.endsWith("/") ? path : `${path}/`;
+
+    // Build tree structure
+    const lines: string[] = [path];
+
+    // Collect all paths and sort
+    const paths = items.map((i) => i.context_path).sort();
+
+    // Collect all directory prefixes
+    const dirSet = new Set<string>();
+    for (const p of paths) {
+      const relative = p.slice(normalizedPath.length);
+      const parts = relative.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        dirSet.add(parts.slice(0, i).join("/"));
+      }
+    }
+
+    // Merge dirs and files, sort
+    const allEntries = [
+      ...Array.from(dirSet).map((d) => ({ path: d, isDir: true })),
+      ...paths.map((p) => ({
+        path: p.slice(normalizedPath.length),
+        isDir: false,
+      })),
+    ].sort((a, b) => a.path.localeCompare(b.path));
+
+    for (let i = 0; i < allEntries.length; i++) {
+      const entry = allEntries[i];
+      if (!entry) continue;
+      const depth = entry.path.split("/").length - 1;
+      const isLast =
+        i === allEntries.length - 1 ||
+        (allEntries[i + 1]?.path.split("/").length ?? 0) - 1 <= depth;
+      const prefix = isLast ? "└── " : "├── ";
+      const indent = "│   ".repeat(depth);
+      const name = entry.path.split("/").pop() ?? "";
+      const suffix = entry.isDir ? "/" : "";
+      lines.push(`${indent}${prefix}${name}${suffix}`);
+    }
+
+    if (items.length >= maxItems) {
+      lines.push(`... (truncated at ${maxItems} items)`);
+    }
+
+    return { tree: lines.join("\n") };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/copy.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { contextPathExists, copyContextItem } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  src: z.string().describe("Source file path"),
+  dst: z.string().describe("Destination file path"),
+  overwrite: z.boolean().optional().describe("Overwrite if destination exists"),
+});
+
+const outputSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+});
+
+export const fileCopyTool = {
+  name: "file_copy",
+  description: "Copy a file in the virtual filesystem.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    if (!input.overwrite && (await contextPathExists(ctx.conn, input.dst))) {
+      throw new Error(`Destination already exists: ${input.dst}`);
+    }
+
+    const item = await copyContextItem(ctx.conn, input.src, input.dst);
+    return { id: item.id, path: item.context_path };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { getContextItemByPath } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("File path"),
+});
+
+const outputSchema = z.object({
+  lines: z.number(),
+});
+
+export const fileCountLinesTool = {
+  name: "file_count_lines",
+  description: "Count the number of lines in a text file.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const item = await getContextItemByPath(ctx.conn, input.path);
+    if (!item) throw new Error(`Not found: ${input.path}`);
+    if (item.content == null) throw new Error(`No text content: ${input.path}`);
+
+    return { lines: item.content.split("\n").length };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/delete.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import {
+  deleteContextItemByPath,
+  deleteContextItemsByPrefix,
+} from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("Path to delete"),
+  recursive: z
+    .boolean()
+    .optional()
+    .describe("Delete all items under this path prefix"),
+  force: z
+    .boolean()
+    .optional()
+    .describe("Do not error if the path does not exist"),
+});
+
+const outputSchema = z.object({
+  deleted: z.number(),
+});
+
+export const fileDeleteTool = {
+  name: "file_delete",
+  description: "Delete a file or directory from the virtual filesystem.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    if (input.recursive) {
+      const count = await deleteContextItemsByPrefix(ctx.conn, input.path);
+      const exact = await deleteContextItemByPath(ctx.conn, input.path);
+      return { deleted: count + (exact ? 1 : 0) };
+    }
+
+    const deleted = await deleteContextItemByPath(ctx.conn, input.path);
+    if (!deleted && !input.force) {
+      throw new Error(`Not found: ${input.path}`);
+    }
+    return { deleted: deleted ? 1 : 0 };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/edit.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { applyPatchesToContextItem } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const PatchSchema = z.object({
+  start_line: z.number().describe("1-based inclusive start line"),
+  end_line: z
+    .number()
+    .describe("1-based inclusive end line (0 to insert without replacing)"),
+  content: z
+    .string()
+    .describe("Replacement text (empty string to delete lines)"),
+});
+
+const inputSchema = z.object({
+  path: z.string().describe("File path to edit"),
+  patches: z.array(PatchSchema).describe("Patches to apply"),
+});
+
+const outputSchema = z.object({
+  applied: z.number(),
+  content: z.string(),
+});
+
+export const fileEditTool = {
+  name: "file_edit",
+  description:
+    "Apply git-style patches to a file. Each patch specifies a line range to replace.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const { item, applied } = await applyPatchesToContextItem(
+      ctx.conn,
+      input.path,
+      input.patches,
+    );
+    return { applied, content: item.content ?? "" };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/exists.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { contextPathExists } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("File path to check"),
+});
+
+const outputSchema = z.object({
+  exists: z.boolean(),
+});
+
+export const fileExistsTool = {
+  name: "file_exists",
+  description: "Check if a file exists in the virtual filesystem.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const exists = await contextPathExists(ctx.conn, input.path);
+    return { exists };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/info.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { getContextItemByPath } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("File path"),
+});
+
+const outputSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  mime_type: z.string(),
+  is_textual: z.boolean(),
+  size: z.number(),
+  lines: z.number(),
+  source_path: z.string().nullable(),
+  context_path: z.string(),
+  indexed_at: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string(),
+});
+
+export const fileInfoTool = {
+  name: "file_info",
+  description: "Show file metadata (size, MIME type, line count, etc.).",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const item = await getContextItemByPath(ctx.conn, input.path);
+    if (!item) throw new Error(`Not found: ${input.path}`);
+
+    const content = item.content ?? "";
+    return {
+      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,
+      source_path: item.source_path,
+      context_path: item.context_path,
+      indexed_at: item.indexed_at?.toISOString() ?? null,
+      created_at: item.created_at.toISOString(),
+      updated_at: item.updated_at.toISOString(),
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/move.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { contextPathExists, moveContextItem } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  src: z.string().describe("Source file path"),
+  dst: z.string().describe("Destination file path"),
+  overwrite: z.boolean().optional().describe("Overwrite if destination exists"),
+});
+
+const outputSchema = z.object({
+  path: z.string(),
+});
+
+export const fileMoveTool = {
+  name: "file_move",
+  description: "Move or rename a file in the virtual filesystem.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    if (!input.overwrite && (await contextPathExists(ctx.conn, input.dst))) {
+      throw new Error(`Destination already exists: ${input.dst}`);
+    }
+
+    await moveContextItem(ctx.conn, input.src, input.dst);
+    return { path: input.dst };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/read.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { getContextItemByPath } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("File path to read"),
+  offset: z
+    .number()
+    .optional()
+    .describe("Line number to start reading from (1-based)"),
+  limit: z.number().optional().describe("Maximum number of lines to return"),
+});
+
+const outputSchema = z.object({
+  content: z.string(),
+});
+
+export const fileReadTool = {
+  name: "file_read",
+  description: "Read a file's contents from the virtual filesystem.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const item = await getContextItemByPath(ctx.conn, input.path);
+    if (!item) throw new Error(`Not found: ${input.path}`);
+    if (item.content == null) throw new Error(`No text content: ${input.path}`);
+
+    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 };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/file/write.ts

@@ -0,0 +1,90 @@
+import { isText } from "istextorbinary";
+import { z } from "zod";
+import {
+  createContextItem,
+  getContextItemByPath,
+  updateContextItem,
+  updateContextItemContent,
+} from "../../db/context.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);
+  // isText returns null if it can't determine from filename alone — default to true
+  return result !== false;
+}
+
+const inputSchema = z.object({
+  path: z.string().describe("File path to write"),
+  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"),
+});
+
+const outputSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+});
+
+export const fileWriteTool = {
+  name: "file_write",
+  description:
+    "Write content to a file in the virtual filesystem. Creates the file if it doesn't exist, or overwrites if it does.",
+  group: "file",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const mimeType = mimeFromPath(input.path);
+    const isTextual = isTextualPath(input.path);
+    const existing = await getContextItemByPath(ctx.conn, input.path);
+
+    if (existing) {
+      if (input.content_base64) {
+        // Binary update — store as content for now (DB blob support can be added later)
+        await updateContextItemContent(
+          ctx.conn,
+          input.path,
+          input.content_base64,
+        );
+      } else {
+        await updateContextItemContent(ctx.conn, input.path, input.content);
+      }
+      if (input.title || input.description) {
+        await updateContextItem(ctx.conn, existing.id, {
+          title: input.title,
+          description: input.description,
+        });
+      }
+      return { id: existing.id, path: input.path };
+    }
+
+    const title =
+      input.title ?? input.path.split("/").filter(Boolean).pop() ?? input.path;
+
+    const item = await createContextItem(ctx.conn, {
+      title,
+      description: input.description,
+      content: input.content_base64 ?? input.content,
+      contextPath: input.path,
+      mimeType,
+      isTextual,
+    });
+
+    return { id: item.id, path: item.context_path };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/registry.ts

@@ -0,0 +1,53 @@
+// Directory tools
+import { dirCreateTool } from "./dir/create.ts";
+import { dirListTool } from "./dir/list.ts";
+import { dirSizeTool } from "./dir/size.ts";
+import { dirTreeTool } from "./dir/tree.ts";
+import { fileCopyTool } from "./file/copy.ts";
+import { fileCountLinesTool } from "./file/count-lines.ts";
+import { fileDeleteTool } from "./file/delete.ts";
+import { fileEditTool } from "./file/edit.ts";
+import { fileExistsTool } from "./file/exists.ts";
+import { fileInfoTool } from "./file/info.ts";
+import { fileMoveTool } from "./file/move.ts";
+// File tools
+import { fileReadTool } from "./file/read.ts";
+import { fileWriteTool } from "./file/write.ts";
+// Search tools
+import { searchGrepTool } from "./search/grep.ts";
+import { searchSemanticTool } from "./search/semantic.ts";
+// Task tools
+import { completeTaskTool } from "./task/complete.ts";
+import { createTaskTool } from "./task/create.ts";
+import { failTaskTool } from "./task/fail.ts";
+import { waitTaskTool } from "./task/wait.ts";
+import { registerTool } from "./tool.ts";
+
+export function registerAllTools(): void {
+  // Task
+  registerTool(completeTaskTool);
+  registerTool(failTaskTool);
+  registerTool(waitTaskTool);
+  registerTool(createTaskTool);
+
+  // Directory
+  registerTool(dirCreateTool);
+  registerTool(dirListTool);
+  registerTool(dirTreeTool);
+  registerTool(dirSizeTool);
+
+  // File
+  registerTool(fileReadTool);
+  registerTool(fileWriteTool);
+  registerTool(fileEditTool);
+  registerTool(fileDeleteTool);
+  registerTool(fileCopyTool);
+  registerTool(fileMoveTool);
+  registerTool(fileInfoTool);
+  registerTool(fileExistsTool);
+  registerTool(fileCountLinesTool);
+
+  // Search
+  registerTool(searchGrepTool);
+  registerTool(searchSemanticTool);
+}

package/src/tools/search/grep.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { listContextItemsByPrefix } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const GrepMatchSchema = z.object({
+  path: z.string(),
+  line: z.number(),
+  content: z.string(),
+  context_lines: z.array(z.string()),
+});
+
+const inputSchema = z.object({
+  pattern: z.string().describe("Regex pattern to search for"),
+  path: z
+    .string()
+    .optional()
+    .describe("Directory to search in (defaults to /)"),
+  glob: z
+    .string()
+    .optional()
+    .describe("Only search files matching this glob pattern"),
+  ignore_case: z.boolean().optional().describe("Case-insensitive search"),
+  context: z
+    .number()
+    .optional()
+    .describe("Number of context lines before and after each match"),
+  max_results: z
+    .number()
+    .optional()
+    .describe("Maximum number of matches to return"),
+});
+
+const outputSchema = z.object({
+  matches: z.array(GrepMatchSchema),
+});
+
+export const searchGrepTool = {
+  name: "search_grep",
+  description:
+    "Search file contents by regex pattern in the virtual filesystem.",
+  group: "search",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const searchPath = input.path ?? "/";
+    const items = await listContextItemsByPrefix(ctx.conn, searchPath, {
+      recursive: true,
+    });
+
+    const flags = input.ignore_case ? "gi" : "g";
+    const regex = new RegExp(input.pattern, flags);
+    const globRegex = input.glob ? globToRegex(input.glob) : null;
+    const contextLines = input.context ?? 0;
+    const maxResults = input.max_results ?? 100;
+
+    const matches: z.infer<typeof GrepMatchSchema>[] = [];
+
+    for (const item of items) {
+      if (item.content == null) continue;
+
+      if (globRegex) {
+        const filename = item.context_path.split("/").pop() ?? "";
+        if (!globRegex.test(filename)) continue;
+      }
+
+      const lines = item.content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        regex.lastIndex = 0;
+        const line = lines[i];
+        if (line !== undefined && regex.test(line)) {
+          const start = Math.max(0, i - contextLines);
+          const end = Math.min(lines.length, i + contextLines + 1);
+          matches.push({
+            path: item.context_path,
+            line: i + 1,
+            content: line,
+            context_lines: lines.slice(start, end),
+          });
+          if (matches.length >= maxResults) return { matches };
+        }
+      }
+    }
+
+    return { matches };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;
+
+function globToRegex(glob: string): RegExp {
+  const escaped = glob
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}

package/src/tools/search/semantic.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  query: z.string().describe("Natural language search query"),
+  top_k: z
+    .number()
+    .optional()
+    .default(10)
+    .describe("Maximum number of results to return (defaults to 10)"),
+  threshold: z
+    .number()
+    .optional()
+    .describe("Minimum similarity score (0-1) to include in results"),
+});
+
+const outputSchema = z.object({
+  results: z.array(
+    z.object({
+      path: z.string(),
+      title: z.string(),
+      score: z.number(),
+      snippet: z.string(),
+    }),
+  ),
+});
+
+export const searchSemanticTool = {
+  name: "search_semantic",
+  description:
+    "Semantic search over indexed files using vector embeddings. Finds conceptually related content, not just keyword matches.",
+  group: "search",
+  inputSchema,
+  outputSchema,
+  execute: async () => {
+    throw new Error(
+      "Semantic search is not yet available — requires the embeddings pipeline (M2)",
+    );
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/task/complete.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  summary: z.string().describe("Summary of work done"),
+});
+
+const outputSchema = z.object({
+  message: z.string(),
+});
+
+export const completeTaskTool = {
+  name: "complete_task",
+  description:
+    "Mark the current task as complete with a summary of what was accomplished.",
+  group: "task",
+  terminal: true,
+  inputSchema,
+  outputSchema,
+  execute: async (input) => ({
+    message: `Task completed: ${input.summary}`,
+  }),
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;