botholomew 0.1.0

package/src/db/connection.ts

@@ -0,0 +1,32 @@
+import { Database } from "bun:sqlite";
+
+export type DbConnection = Database;
+
+export function getConnection(dbPath: string): Database {
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  return db;
+}
+
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries = 5,
+): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isBusy =
+        err instanceof Error &&
+        (err.message.includes("SQLITE_BUSY") ||
+          err.message.includes("database is locked"));
+      if (!isBusy || attempt === maxRetries - 1) throw err;
+      // exponential backoff: 100ms, 200ms, 400ms, 800ms, 1600ms
+      await Bun.sleep(100 * 2 ** attempt);
+    }
+  }
+  throw lastError;
+}

package/src/db/context.ts

@@ -0,0 +1,415 @@
+import type { DbConnection } from "./connection.ts";
+import { uuidv7 } from "./uuid.ts";
+
+export interface ContextItem {
+  id: string;
+  title: string;
+  description: string;
+  content: string | null;
+  mime_type: string;
+  is_textual: boolean;
+  source_path: string | null;
+  context_path: string;
+  indexed_at: Date | null;
+  created_at: Date;
+  updated_at: Date;
+}
+
+export interface Patch {
+  start_line: number;
+  end_line: number;
+  content: string;
+}
+
+interface ContextItemRow {
+  id: string;
+  title: string;
+  description: string;
+  content: string | null;
+  content_blob: unknown;
+  mime_type: string;
+  is_textual: number;
+  source_path: string | null;
+  context_path: string;
+  indexed_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToContextItem(row: ContextItemRow): ContextItem {
+  return {
+    id: row.id,
+    title: row.title,
+    description: row.description,
+    content: row.content,
+    mime_type: row.mime_type,
+    is_textual: row.is_textual === 1,
+    source_path: row.source_path,
+    context_path: row.context_path,
+    indexed_at: row.indexed_at ? new Date(row.indexed_at) : null,
+    created_at: new Date(row.created_at),
+    updated_at: new Date(row.updated_at),
+  };
+}
+
+// --- Basic CRUD ---
+
+export async function createContextItem(
+  db: DbConnection,
+  params: {
+    title: string;
+    content?: string;
+    mimeType?: string;
+    sourcePath?: string;
+    contextPath: string;
+    description?: string;
+    isTextual?: boolean;
+  },
+): Promise<ContextItem> {
+  const id = uuidv7();
+  const row = db
+    .query(
+      `INSERT INTO context_items (id, title, description, content, mime_type, is_textual, source_path, context_path)
+     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+     RETURNING *`,
+    )
+    .get(
+      id,
+      params.title,
+      params.description ?? "",
+      params.content ?? null,
+      params.mimeType ?? "text/plain",
+      params.isTextual !== false ? 1 : 0,
+      params.sourcePath ?? null,
+      params.contextPath,
+    ) as ContextItemRow | null;
+  if (!row) throw new Error("INSERT did not return a row");
+  return rowToContextItem(row);
+}
+
+export async function getContextItem(
+  db: DbConnection,
+  id: string,
+): Promise<ContextItem | null> {
+  const row = db
+    .query("SELECT * FROM context_items WHERE id = ?1")
+    .get(id) as ContextItemRow | null;
+  return row ? rowToContextItem(row) : null;
+}
+
+export async function getContextItemByPath(
+  db: DbConnection,
+  contextPath: string,
+): Promise<ContextItem | null> {
+  const row = db
+    .query("SELECT * FROM context_items WHERE context_path = ?1")
+    .get(contextPath) as ContextItemRow | null;
+  return row ? rowToContextItem(row) : null;
+}
+
+export async function listContextItems(
+  db: DbConnection,
+  filters?: {
+    contextPath?: string;
+    mimeType?: string;
+    limit?: number;
+  },
+): Promise<ContextItem[]> {
+  const conditions: string[] = [];
+  const params: (string | null)[] = [];
+
+  if (filters?.contextPath) {
+    params.push(filters.contextPath);
+    conditions.push(`context_path = ?${params.length}`);
+  }
+  if (filters?.mimeType) {
+    params.push(filters.mimeType);
+    conditions.push(`mime_type = ?${params.length}`);
+  }
+
+  const where =
+    conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters?.limit ? `LIMIT ${filters.limit}` : "";
+
+  const rows = db
+    .query(
+      `SELECT * FROM context_items ${where} ORDER BY context_path ASC ${limit}`,
+    )
+    .all(...params) as ContextItemRow[];
+  return rows.map(rowToContextItem);
+}
+
+export async function listContextItemsByPrefix(
+  db: DbConnection,
+  prefix: string,
+  opts?: { recursive?: boolean; limit?: number },
+): Promise<ContextItem[]> {
+  const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+
+  const limit = opts?.limit ? `LIMIT ${opts.limit}` : "";
+
+  let rows: ContextItemRow[];
+  if (opts?.recursive) {
+    rows = db
+      .query(
+        `SELECT * FROM context_items
+       WHERE context_path LIKE ?1
+       ORDER BY context_path ASC ${limit}`,
+      )
+      .all(`${normalizedPrefix}%`) as ContextItemRow[];
+  } else {
+    // Only immediate children: match prefix but no further slashes
+    rows = db
+      .query(
+        `SELECT * FROM context_items
+       WHERE context_path LIKE ?1
+         AND context_path NOT LIKE ?2
+       ORDER BY context_path ASC ${limit}`,
+      )
+      .all(
+        `${normalizedPrefix}%`,
+        `${normalizedPrefix}%/%`,
+      ) as ContextItemRow[];
+  }
+
+  return rows.map(rowToContextItem);
+}
+
+export async function contextPathExists(
+  db: DbConnection,
+  contextPath: string,
+): Promise<boolean> {
+  const row = db
+    .query(
+      "SELECT 1 AS found FROM context_items WHERE context_path = ?1 LIMIT 1",
+    )
+    .get(contextPath);
+  return row != null;
+}
+
+export async function getDistinctDirectories(
+  db: DbConnection,
+  prefix?: string,
+): Promise<string[]> {
+  const normalizedPrefix = prefix
+    ? prefix.endsWith("/")
+      ? prefix
+      : `${prefix}/`
+    : "/";
+
+  // Extract the first path segment after the prefix
+  const rows = db
+    .query(
+      `SELECT DISTINCT
+        ?1 || CASE
+          WHEN instr(substr(context_path, length(?1) + 1), '/') > 0
+          THEN substr(substr(context_path, length(?1) + 1), 1, instr(substr(context_path, length(?1) + 1), '/') - 1)
+          ELSE substr(context_path, length(?1) + 1)
+        END AS dir
+      FROM context_items
+      WHERE context_path LIKE ?2
+      ORDER BY dir ASC`,
+    )
+    .all(normalizedPrefix, `${normalizedPrefix}%/%`) as { dir: string }[];
+
+  return rows.map((row) => row.dir);
+}
+
+// --- Mutations ---
+
+export async function updateContextItem(
+  db: DbConnection,
+  id: string,
+  updates: Partial<
+    Pick<ContextItem, "title" | "description" | "content" | "mime_type">
+  >,
+): Promise<ContextItem | null> {
+  const setClauses: string[] = ["updated_at = datetime('now')"];
+  const params: (string | null)[] = [];
+
+  if (updates.title !== undefined) {
+    params.push(updates.title);
+    setClauses.push(`title = ?${params.length}`);
+  }
+  if (updates.description !== undefined) {
+    params.push(updates.description);
+    setClauses.push(`description = ?${params.length}`);
+  }
+  if (updates.content !== undefined) {
+    params.push(updates.content);
+    setClauses.push(`content = ?${params.length}`);
+  }
+  if (updates.mime_type !== undefined) {
+    params.push(updates.mime_type);
+    setClauses.push(`mime_type = ?${params.length}`);
+  }
+
+  params.push(id);
+  const row = db
+    .query(
+      `UPDATE context_items
+     SET ${setClauses.join(", ")}
+     WHERE id = ?${params.length}
+     RETURNING *`,
+    )
+    .get(...params) as ContextItemRow | null;
+  return row ? rowToContextItem(row) : null;
+}
+
+export async function updateContextItemContent(
+  db: DbConnection,
+  contextPath: string,
+  content: string,
+): Promise<ContextItem | null> {
+  const row = db
+    .query(
+      `UPDATE context_items
+     SET content = ?1, updated_at = datetime('now')
+     WHERE context_path = ?2
+     RETURNING *`,
+    )
+    .get(content, contextPath) as ContextItemRow | null;
+  return row ? rowToContextItem(row) : null;
+}
+
+export async function applyPatchesToContextItem(
+  db: DbConnection,
+  contextPath: string,
+  patches: Patch[],
+): Promise<{ item: ContextItem; applied: number }> {
+  const item = await getContextItemByPath(db, contextPath);
+  if (!item) throw new Error(`Not found: ${contextPath}`);
+  if (item.content == null) throw new Error(`No text content: ${contextPath}`);
+
+  const lines = item.content.split("\n");
+
+  // Sort patches by start_line descending so we apply bottom-up
+  const sorted = [...patches].sort((a, b) => b.start_line - a.start_line);
+
+  for (const patch of sorted) {
+    if (patch.end_line === 0) {
+      // Insert at start_line without replacing
+      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
+      lines.splice(patch.start_line - 1, 0, ...insertLines);
+    } else {
+      // Replace lines [start_line, end_line] inclusive (1-based)
+      const deleteCount = patch.end_line - patch.start_line + 1;
+      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
+      lines.splice(patch.start_line - 1, deleteCount, ...insertLines);
+    }
+  }
+
+  const newContent = lines.join("\n");
+  const updated = await updateContextItemContent(db, contextPath, newContent);
+  if (!updated) throw new Error(`Failed to update: ${contextPath}`);
+  return { item: updated, applied: patches.length };
+}
+
+export async function copyContextItem(
+  db: DbConnection,
+  srcPath: string,
+  dstPath: string,
+): Promise<ContextItem> {
+  const src = await getContextItemByPath(db, srcPath);
+  if (!src) throw new Error(`Not found: ${srcPath}`);
+
+  return createContextItem(db, {
+    title: src.title,
+    description: src.description,
+    content: src.content ?? undefined,
+    mimeType: src.mime_type,
+    sourcePath: src.source_path ?? undefined,
+    contextPath: dstPath,
+    isTextual: src.is_textual,
+  });
+}
+
+export async function moveContextItem(
+  db: DbConnection,
+  oldPath: string,
+  newPath: string,
+): Promise<void> {
+  const row = db
+    .query(
+      `UPDATE context_items
+     SET context_path = ?1, updated_at = datetime('now')
+     WHERE context_path = ?2
+     RETURNING id`,
+    )
+    .get(newPath, oldPath);
+  if (!row) {
+    throw new Error(`Not found: ${oldPath}`);
+  }
+}
+
+// --- Deletion ---
+
+export async function deleteContextItem(
+  db: DbConnection,
+  id: string,
+): Promise<boolean> {
+  // Delete embeddings first (foreign key)
+  db.query("DELETE FROM embeddings WHERE context_item_id = ?1").run(id);
+  const row = db
+    .query("DELETE FROM context_items WHERE id = ?1 RETURNING id")
+    .get(id);
+  return row != null;
+}
+
+export async function deleteContextItemByPath(
+  db: DbConnection,
+  contextPath: string,
+): Promise<boolean> {
+  // Get ID first so we can cascade embeddings
+  const item = await getContextItemByPath(db, contextPath);
+  if (!item) return false;
+  return deleteContextItem(db, item.id);
+}
+
+export async function deleteContextItemsByPrefix(
+  db: DbConnection,
+  prefix: string,
+): Promise<number> {
+  const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+
+  // Delete embeddings for all matching items
+  db.query(
+    `DELETE FROM embeddings
+     WHERE context_item_id IN (
+       SELECT id FROM context_items
+       WHERE context_path LIKE ?1
+     )`,
+  ).run(`${normalizedPrefix}%`);
+
+  const rows = db
+    .query(
+      `DELETE FROM context_items
+     WHERE context_path LIKE ?1
+     RETURNING id`,
+    )
+    .all(`${normalizedPrefix}%`);
+  return rows.length;
+}
+
+// --- Search ---
+
+export async function searchContextByKeyword(
+  db: DbConnection,
+  query: string,
+  limit = 20,
+): Promise<ContextItem[]> {
+  const pattern = `%${query}%`;
+  const rows = db
+    .query(
+      `SELECT * FROM context_items
+     WHERE content IS NOT NULL
+       AND (
+         content LIKE ?1 COLLATE NOCASE
+         OR title LIKE ?1 COLLATE NOCASE
+       )
+     ORDER BY updated_at DESC
+     LIMIT ?2`,
+    )
+    .all(pattern, limit) as ContextItemRow[];
+  return rows.map(rowToContextItem);
+}

package/src/db/embeddings.ts

@@ -0,0 +1,22 @@
+import type { DbConnection } from "./connection.ts";
+
+export interface Embedding {
+  id: string;
+  context_item_id: string;
+  chunk_index: number;
+  chunk_content: string | null;
+  title: string;
+  description: string;
+  source_path: string | null;
+  embedding: number[];
+  created_at: Date;
+}
+
+// Stub — full implementation in a later milestone
+export async function searchEmbeddings(
+  _db: DbConnection,
+  _query: number[],
+  _limit?: number,
+): Promise<Embedding[]> {
+  return [];
+}

package/src/db/schedules.ts

@@ -0,0 +1,17 @@
+import type { DbConnection } from "./connection.ts";
+
+export interface Schedule {
+  id: string;
+  name: string;
+  description: string;
+  frequency: string;
+  last_run_at: Date | null;
+  enabled: boolean;
+  created_at: Date;
+  updated_at: Date;
+}
+
+// Stub — full implementation in a later milestone
+export async function listSchedules(_db: DbConnection): Promise<Schedule[]> {
+  return [];
+}

package/src/db/schema.ts

@@ -0,0 +1,66 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { DbConnection } from "./connection.ts";
+
+interface Migration {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+const sqlDir = join(import.meta.dir, "sql");
+
+function loadMigrations(): Migration[] {
+  const files = readdirSync(sqlDir)
+    .filter((f) => f.endsWith(".sql"))
+    .sort();
+
+  return files.map((file) => {
+    const match = file.match(/^(\d+)-(.+)\.sql$/);
+    if (!match) throw new Error(`Invalid migration filename: ${file}`);
+    const id = match[1];
+    const name = match[2];
+    if (!id || !name) throw new Error(`Invalid migration filename: ${file}`);
+    return {
+      id: parseInt(id, 10),
+      name,
+      sql: readFileSync(join(sqlDir, file), "utf-8"),
+    };
+  });
+}
+
+export function migrate(db: DbConnection): void {
+  // Create migrations tracking table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  // Get already-applied migrations
+  const rows = db.query("SELECT id FROM _migrations").all() as {
+    id: number;
+  }[];
+  const applied = new Set(rows.map((row) => row.id));
+
+  // Run pending migrations in order
+  for (const migration of loadMigrations()) {
+    if (applied.has(migration.id)) continue;
+
+    // Split on semicolons and run each statement individually
+    const statements = migration.sql
+      .split(";")
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+
+    for (const statement of statements) {
+      db.exec(statement);
+    }
+
+    db.exec(
+      `INSERT INTO _migrations (id, name) VALUES (${migration.id}, '${migration.name}')`,
+    );
+  }
+}

package/src/db/sql/1-core_tables.sql

@@ -0,0 +1,53 @@
+CREATE TABLE tasks (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high')),
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'failed', 'complete', 'waiting')),
+  waiting_reason TEXT,
+  claimed_by TEXT,
+  claimed_at TEXT,
+  blocked_by TEXT NOT NULL DEFAULT '[]',
+  context_ids TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE schedules (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  frequency TEXT NOT NULL,
+  last_run_at TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE context_items (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  content TEXT,
+  content_blob BLOB,
+  mime_type TEXT NOT NULL DEFAULT 'text/plain',
+  is_textual INTEGER NOT NULL DEFAULT 1,
+  source_path TEXT,
+  context_path TEXT NOT NULL,
+  indexed_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE embeddings (
+  id TEXT PRIMARY KEY,
+  context_item_id TEXT NOT NULL REFERENCES context_items(id),
+  chunk_index INTEGER NOT NULL,
+  chunk_content TEXT,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  source_path TEXT,
+  embedding TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(context_item_id, chunk_index)
+);

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

@@ -0,0 +1,24 @@
+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 (datetime('now')),
+  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 (datetime('now')),
+  UNIQUE(thread_id, sequence)
+);

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

@@ -0,0 +1,5 @@
+CREATE TABLE daemon_state (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);