botholomew 0.16.4 → 0.18.0

package/src/db/sql/17-worker_log_path.sql

@@ -1,3 +0,0 @@
--- Per-worker log file path. NULL for foreground / in-process workers that
--- write to stdout instead of a dedicated file.
-ALTER TABLE workers ADD COLUMN log_path TEXT;

package/src/db/sql/18-reset_embeddings_for_local.sql

@@ -1,39 +0,0 @@
--- Switch from OpenAI 1536-dim embeddings to local 384-dim embeddings.
---
--- DuckDB encodes array dimension in the column type, so we rebuild the
--- embeddings table preserving every row's metadata (chunk_content, title,
--- description, context_item_id, chunk_index, created_at). The vectors
--- themselves are NULLed and repopulated by `botholomew context reembed`
--- using the locally-loaded embedding model.
---
--- Idempotency: every destructive step uses IF EXISTS so a partial prior
--- run can be re-attempted cleanly. The FTS index is dropped here but NOT
--- recreated — `migrate()` calls rebuildSearchIndex once after all SQL
--- migrations apply, which avoids a same-migration drop-then-create that
--- DuckDB rejects with "Could not commit creation of dependency, subject
--- 'stopwords' has been deleted".
-
-DROP SCHEMA IF EXISTS fts_main_embeddings CASCADE;
-
-DROP TABLE IF EXISTS embeddings_new;
-
-CREATE TABLE embeddings_new (
-  id TEXT PRIMARY KEY,
-  context_item_id TEXT NOT NULL,
-  chunk_index INTEGER NOT NULL,
-  chunk_content TEXT,
-  title TEXT NOT NULL,
-  description TEXT NOT NULL DEFAULT '',
-  embedding FLOAT[384],
-  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
-  UNIQUE(context_item_id, chunk_index)
-);
-
-INSERT INTO embeddings_new (id, context_item_id, chunk_index, chunk_content, title, description, embedding, created_at)
-SELECT id, context_item_id, chunk_index, chunk_content, title, description, NULL, created_at
-FROM embeddings;
-
-DROP TABLE embeddings;
-ALTER TABLE embeddings_new RENAME TO embeddings;
-
-CHECKPOINT;

package/src/db/sql/19-disk_backed_index.sql

@@ -1,36 +0,0 @@
--- Switch the search index from "tracks DuckDB-backed virtual files" to
--- "tracks real files on disk under context/", and drop every table whose
--- contents now live on the filesystem (tasks, schedules) or that nothing
--- writes to anymore (daemon_state). The remaining DuckDB tables are:
---   workers, threads, interactions, context_index, _migrations
---
--- A new `context_index` table holds one row per (path, chunk_index), with a
--- file-level content hash + mtime so `botholomew context reindex` can detect
--- adds, updates, and removals in one pass.
---
--- Idempotent: every step uses IF EXISTS so a partial prior run is safe to
--- re-attempt. The FTS index over the new chunk_content column is created by
--- migrate() via rebuildSearchIndex() after all migrations apply.
-
-DROP SCHEMA IF EXISTS fts_main_embeddings CASCADE;
-DROP TABLE IF EXISTS embeddings;
-DROP TABLE IF EXISTS context_items;
-DROP TABLE IF EXISTS tasks;
-DROP TABLE IF EXISTS schedules;
-DROP TABLE IF EXISTS daemon_state;
-
-CREATE TABLE IF NOT EXISTS context_index (
-  path TEXT NOT NULL,
-  chunk_index INTEGER NOT NULL,
-  content_hash TEXT NOT NULL,
-  chunk_content TEXT NOT NULL,
-  embedding FLOAT[384],
-  mtime_ms BIGINT NOT NULL,
-  size_bytes BIGINT NOT NULL,
-  indexed_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
-  PRIMARY KEY (path, chunk_index)
-);
-
-CREATE INDEX IF NOT EXISTS idx_context_index_path ON context_index(path);
-
-CHECKPOINT;

package/src/db/sql/2-logging_tables.sql

@@ -1,24 +0,0 @@
-CREATE TABLE threads (
-  id TEXT PRIMARY KEY,
-  type TEXT NOT NULL CHECK(type IN ('daemon_tick', 'chat_session')),
-  task_id TEXT,
-  title TEXT NOT NULL DEFAULT '',
-  started_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
-  ended_at TEXT,
-  metadata TEXT
-);
-
-CREATE TABLE interactions (
-  id TEXT PRIMARY KEY,
-  thread_id TEXT NOT NULL REFERENCES threads(id),
-  sequence INTEGER NOT NULL,
-  role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'tool')),
-  kind TEXT NOT NULL CHECK(kind IN ('message', 'thinking', 'tool_use', 'tool_result', 'context_update', 'status_change')),
-  content TEXT NOT NULL,
-  tool_name TEXT,
-  tool_input TEXT,
-  duration_ms INTEGER,
-  token_count INTEGER,
-  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
-  UNIQUE(thread_id, sequence)
-);

package/src/db/sql/20-drop_db_tables_for_files.sql

@@ -1,19 +0,0 @@
--- Tasks, schedules, threads, interactions, and workers all moved out of
--- DuckDB onto disk:
---   tasks/             markdown files with frontmatter (one per task)
---   schedules/         markdown files with frontmatter (one per schedule)
---   threads/   CSV per conversation (searchable via the index)
---   workers/           JSON pidfile per worker, mtime-checked heartbeats
---
--- The only remaining DuckDB objects after this migration are _migrations,
--- context_index, and the FTS index built over context_index by
--- rebuildSearchIndex(). Idempotent via IF EXISTS.
-
-DROP TABLE IF EXISTS interactions;
-DROP TABLE IF EXISTS threads;
-DROP TABLE IF EXISTS workers;
-
-DROP TABLE IF EXISTS tasks;
-DROP TABLE IF EXISTS schedules;
-
-CHECKPOINT;

package/src/db/sql/3-daemon_state.sql

@@ -1,5 +0,0 @@
-CREATE TABLE daemon_state (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL,
-  updated_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR)
-);

package/src/db/sql/4-unique_context_path.sql

@@ -1 +0,0 @@
-CREATE UNIQUE INDEX IF NOT EXISTS idx_context_items_context_path ON context_items(context_path);

package/src/db/sql/5-reset_embeddings_for_openai.sql

@@ -1 +0,0 @@
-DELETE FROM embeddings

package/src/db/sql/6-vss_index.sql

@@ -1,7 +0,0 @@
--- Historical: this migration used to CREATE an HNSW index on embeddings
--- via the VSS extension. HNSW has since been removed (see migration 12)
--- (see migration 14) and the VSS extension is no longer loaded at
--- connection time, so running `CREATE INDEX ... USING HNSW` here would
--- fail on fresh DBs. Kept as a no-op to preserve migration numbering
--- for existing databases that have already recorded id 6 in _migrations.
-SELECT 1;

package/src/db/sql/7-drop_embeddings_fk.sql

@@ -1,23 +0,0 @@
--- DuckDB implements UPDATE as delete+insert on tables with unique indexes.
--- The foreign key from embeddings → context_items causes every UPDATE to
--- context_items to fail when embeddings exist. Cascading deletes are already
--- handled in application code (deleteContextItem), so the FK is redundant.
---
--- Clear embeddings before DROP to avoid DuckDB WAL replay crash with FK refs.
--- Embeddings are recreated on next `context add` or `context refresh`.
-DELETE FROM embeddings;
-UPDATE context_items SET indexed_at = NULL;
-DROP TABLE embeddings;
-CREATE TABLE embeddings (
-  id TEXT PRIMARY KEY,
-  context_item_id TEXT NOT NULL,
-  chunk_index INTEGER NOT NULL,
-  chunk_content TEXT,
-  title TEXT NOT NULL,
-  description TEXT NOT NULL DEFAULT '',
-  source_path TEXT,
-  embedding FLOAT[1536],
-  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
-  UNIQUE(context_item_id, chunk_index)
-);
-CHECKPOINT;

package/src/db/sql/8-task_output.sql

@@ -1 +0,0 @@
-ALTER TABLE tasks ADD COLUMN output TEXT;

package/src/db/sql/9-source-type.sql

@@ -1 +0,0 @@
-ALTER TABLE context_items ADD COLUMN source_type TEXT DEFAULT 'file';

package/src/tools/context/read-large-result.ts

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import { readLargeResultPage } from "../../worker/large-results.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  id: z.string().describe("The large result ID (e.g. lr_1)"),
-  page: z.number().int().min(1).describe("Page number to read (1-based)"),
-});
-
-const outputSchema = z.object({
-  content: z.string(),
-  page: z.number(),
-  totalPages: z.number(),
-  is_error: z.boolean(),
-});
-
-export const readLargeResultTool = {
-  name: "read_large_result",
-  description:
-    "Read a page from a large tool result that was too big to display inline. Use this to paginate through stored results.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input) => {
-    const result = readLargeResultPage(input.id, input.page);
-    if (!result) {
-      throw new Error(
-        `No result found for id="${input.id}" page=${input.page}. The id may be invalid or the page may be out of range.`,
-      );
-    }
-    return { ...result, is_error: false };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/dir/create.ts

@@ -1,47 +0,0 @@
-import { z } from "zod";
-import { createContextDir, fileExists } from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  path: z.string().describe("Directory path to create under context/"),
-});
-
-const outputSchema = z.object({
-  path: z.string(),
-  created: z.boolean(),
-  is_error: z.boolean(),
-  error_type: z.string().optional(),
-  message: z.string().optional(),
-  next_action_hint: z.string().optional(),
-});
-
-export const contextCreateDirTool = {
-  name: "context_create_dir",
-  description:
-    "[[ bash equivalent command: mkdir -p ]] Create a directory (recursively) under context/. Paths that traverse a user symlink fail with PathEscapeError.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    try {
-      const existed = await fileExists(ctx.projectDir, input.path);
-      await createContextDir(ctx.projectDir, input.path);
-      return { path: input.path, created: !existed, is_error: false };
-    } catch (err) {
-      // mkdir surfaces ENOTDIR when a path component is a file, EACCES on
-      // permission issues, etc. Convert to a structured error so the agent
-      // can pick a different parent or read what's actually there first.
-      const code = (err as NodeJS.ErrnoException).code;
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        path: input.path,
-        created: false,
-        is_error: true,
-        error_type: code === "ENOTDIR" ? "not_a_directory" : "create_failed",
-        message,
-        next_action_hint:
-          "Run context_tree on the parent path to see what's there before retrying.",
-      };
-    }
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/dir/size.ts

@@ -1,77 +0,0 @@
-import { z } from "zod";
-import {
-  dirSizeBytes,
-  NotDirectoryError,
-  NotFoundError,
-} from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-function formatBytes(bytes: number): string {
-  if (bytes === 0) return "0 B";
-  const units = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  const value = bytes / 1024 ** i;
-  return `${value.toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
-}
-
-const inputSchema = z.object({
-  path: z
-    .string()
-    .optional()
-    .default("")
-    .describe("Directory path under context/ (defaults to context root)"),
-});
-
-const outputSchema = z.object({
-  files: z.number(),
-  bytes: z.number(),
-  formatted: z.string(),
-  is_error: z.boolean(),
-  error_type: z.string().optional(),
-  message: z.string().optional(),
-});
-
-export const contextDirSizeTool = {
-  name: "context_dir_size",
-  description:
-    "[[ bash equivalent command: du -s ]] Get the total size of files under a directory in context/.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    try {
-      const { files, bytes } = await dirSizeBytes(
-        ctx.projectDir,
-        input.path ?? "",
-      );
-      return {
-        files,
-        bytes,
-        formatted: formatBytes(bytes),
-        is_error: false,
-      };
-    } catch (err) {
-      if (err instanceof NotFoundError) {
-        return {
-          files: 0,
-          bytes: 0,
-          formatted: formatBytes(0),
-          is_error: true,
-          error_type: "not_found",
-          message: `No directory at context/${err.path}`,
-        };
-      }
-      if (err instanceof NotDirectoryError) {
-        return {
-          files: 0,
-          bytes: 0,
-          formatted: formatBytes(0),
-          is_error: true,
-          error_type: "not_a_directory",
-          message: `context/${err.path} is not a directory`,
-        };
-      }
-      throw err;
-    }
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/dir/tree.ts

@@ -1,124 +0,0 @@
-import { z } from "zod";
-import {
-  buildTree,
-  NotFoundError,
-  type TreeNode,
-} from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const DEFAULT_MAX_DEPTH = 10;
-
-export interface BuildContextTreeResult {
-  tree: string;
-  total_items: number;
-  hint: string;
-}
-
-/**
- * Render a TreeNode as an indented string. Files are listed; directories show
- * children. Depth is enforced inside `buildTree`.
- */
-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;
-}
-
-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({
-  path: z
-    .string()
-    .optional()
-    .default("")
-    .describe(
-      "Directory path under context/ to render (defaults to the context root).",
-    ),
-  max_depth: z
-    .number()
-    .int()
-    .positive()
-    .optional()
-    .default(DEFAULT_MAX_DEPTH)
-    .describe(
-      `Maximum depth of directories to render (defaults to ${DEFAULT_MAX_DEPTH}).`,
-    ),
-});
-
-const outputSchema = z.object({
-  tree: z.string(),
-  total_items: z.number(),
-  is_error: z.boolean(),
-  error_type: z.string().optional(),
-  message: z.string().optional(),
-});
-
-export const contextTreeTool = {
-  name: "context_tree",
-  description:
-    "[[ 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) => {
-    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>;
-
-/**
- * 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,73 +0,0 @@
-import { z } from "zod";
-import {
-  copyContextPath,
-  deleteContextPath,
-  fileExists,
-  IsDirectoryError,
-  NotFoundError,
-  PathConflictError,
-} from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  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({
-  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 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) => {
-    try {
-      if (input.overwrite && (await fileExists(ctx.projectDir, input.dst))) {
-        await deleteContextPath(ctx.projectDir, input.dst, {
-          holderId: ctx.workerId,
-        });
-      }
-      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;
-    }
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

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

@@ -1,54 +0,0 @@
-import { z } from "zod";
-import {
-  IsDirectoryError,
-  NotFoundError,
-  readContextFile,
-} from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  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 file under context/.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    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,83 +0,0 @@
-import { z } from "zod";
-import {
-  deleteContextPath,
-  IsDirectoryError,
-  NotFoundError,
-} from "../../context/store.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  path: z.string().describe("Path under context/ to delete"),
-  recursive: z
-    .boolean()
-    .optional()
-    .describe("Delete a directory and its contents recursively"),
-  force: z
-    .boolean()
-    .optional()
-    .describe("Do not error if the path does not exist"),
-});
-
-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 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) => {
-    try {
-      const result = await deleteContextPath(ctx.projectDir, input.path, {
-        recursive: input.recursive,
-        holderId: ctx.workerId,
-      });
-      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;
-    }
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;