botholomew 0.5.0 → 0.6.0

package/src/db/schedules.ts

@@ -19,7 +19,7 @@ interface ScheduleRow {
   description: string;
   frequency: string;
   last_run_at: string | null;
-  enabled: number;
+  enabled: boolean;
   created_at: string;
   updated_at: string;
 }
@@ -31,7 +31,7 @@ function rowToSchedule(row: ScheduleRow): Schedule {
     description: row.description,
     frequency: row.frequency,
     last_run_at: row.last_run_at ? new Date(row.last_run_at) : null,
-    enabled: row.enabled === 1,
+    enabled: !!row.enabled,
     created_at: new Date(row.created_at),
     updated_at: new Date(row.updated_at),
   };
@@ -46,18 +46,15 @@ export async function createSchedule(
   },
 ): Promise<Schedule> {
   const id = uuidv7();
-  const row = db
-    .query(
-      `INSERT INTO schedules (id, name, description, frequency)
+  const row = await db.queryGet<ScheduleRow>(
+    `INSERT INTO schedules (id, name, description, frequency)
      VALUES (?1, ?2, ?3, ?4)
      RETURNING *`,
-    )
-    .get(
-      id,
-      params.name,
-      params.description ?? "",
-      params.frequency,
-    ) as ScheduleRow | null;
+    id,
+    params.name,
+    params.description ?? "",
+    params.frequency,
+  );
   if (!row) throw new Error("INSERT did not return a row");
   return rowToSchedule(row);
 }
@@ -66,9 +63,10 @@ export async function getSchedule(
   db: DbConnection,
   id: string,
 ): Promise<Schedule | null> {
-  const row = db
-    .query("SELECT * FROM schedules WHERE id = ?1")
-    .get(id) as ScheduleRow | null;
+  const row = await db.queryGet<ScheduleRow>(
+    "SELECT * FROM schedules WHERE id = ?1",
+    id,
+  );
   return row ? rowToSchedule(row) : null;
 }
 
@@ -83,9 +81,10 @@ export async function listSchedules(
     ],
   ]);
 
-  const rows = db
-    .query(`SELECT * FROM schedules ${where} ORDER BY created_at ASC`)
-    .all(...params) as ScheduleRow[];
+  const rows = await db.queryAll<ScheduleRow>(
+    `SELECT * FROM schedules ${where} ORDER BY created_at ASC`,
+    ...params,
+  );
   return rows.map(rowToSchedule);
 }
 
@@ -110,14 +109,13 @@ export async function updateSchedule(
     return getSchedule(db, id);
   }
 
-  setClauses.push("updated_at = datetime('now')");
+  setClauses.push("updated_at = current_timestamp::VARCHAR");
   params.push(id);
 
-  const row = db
-    .query(
-      `UPDATE schedules SET ${setClauses.join(", ")} WHERE id = ?${params.length} RETURNING *`,
-    )
-    .get(...params) as ScheduleRow | null;
+  const row = await db.queryGet<ScheduleRow>(
+    `UPDATE schedules SET ${setClauses.join(", ")} WHERE id = ?${params.length} RETURNING *`,
+    ...params,
+  );
   return row ? rowToSchedule(row) : null;
 }
 
@@ -125,7 +123,7 @@ export async function deleteSchedule(
   db: DbConnection,
   id: string,
 ): Promise<boolean> {
-  const result = db.query("DELETE FROM schedules WHERE id = ?1").run(id);
+  const result = await db.queryRun("DELETE FROM schedules WHERE id = ?1", id);
   return result.changes > 0;
 }
 
@@ -133,7 +131,8 @@ export async function markScheduleRun(
   db: DbConnection,
   id: string,
 ): Promise<void> {
-  db.query(
-    `UPDATE schedules SET last_run_at = datetime('now'), updated_at = datetime('now') WHERE id = ?1`,
-  ).run(id);
+  await db.queryRun(
+    `UPDATE schedules SET last_run_at = current_timestamp::VARCHAR, updated_at = current_timestamp::VARCHAR WHERE id = ?1`,
+    id,
+  );
 }

package/src/db/schema.ts

@@ -29,20 +29,18 @@ function loadMigrations(): Migration[] {
   });
 }
 
-export function migrate(db: DbConnection): void {
+export async function migrate(db: DbConnection): Promise<void> {
   // Create migrations tracking table
-  db.exec(`
+  await db.exec(`
     CREATE TABLE IF NOT EXISTS _migrations (
       id INTEGER PRIMARY KEY,
       name TEXT NOT NULL,
-      applied_at TEXT DEFAULT (datetime('now'))
+      applied_at TEXT DEFAULT (current_timestamp::VARCHAR)
     )
   `);
 
   // Get already-applied migrations
-  const rows = db.query("SELECT id FROM _migrations").all() as {
-    id: number;
-  }[];
+  const rows = await db.queryAll<{ id: number }>("SELECT id FROM _migrations");
   const applied = new Set(rows.map((row) => row.id));
 
   // Run pending migrations in order
@@ -56,11 +54,13 @@ export function migrate(db: DbConnection): void {
       .filter((s) => s.length > 0);
 
     for (const statement of statements) {
-      db.exec(statement);
+      await db.exec(statement);
     }
 
-    db.exec(
-      `INSERT INTO _migrations (id, name) VALUES (${migration.id}, '${migration.name}')`,
+    await db.queryRun(
+      "INSERT INTO _migrations (id, name) VALUES (?1, ?2)",
+      migration.id,
+      migration.name,
     );
   }
 }

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

@@ -9,8 +9,8 @@ CREATE TABLE tasks (
   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'))
+  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
+  updated_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR)
 );
 
 CREATE TABLE schedules (
@@ -19,9 +19,9 @@ CREATE TABLE schedules (
   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'))
+  enabled BOOLEAN NOT NULL DEFAULT true,
+  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
+  updated_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR)
 );
 
 CREATE TABLE context_items (
@@ -31,12 +31,12 @@ CREATE TABLE context_items (
   content TEXT,
   content_blob BLOB,
   mime_type TEXT NOT NULL DEFAULT 'text/plain',
-  is_textual INTEGER NOT NULL DEFAULT 1,
+  is_textual BOOLEAN NOT NULL DEFAULT true,
   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'))
+  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
+  updated_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR)
 );
 
 CREATE TABLE embeddings (
@@ -47,7 +47,7 @@ CREATE TABLE embeddings (
   title TEXT NOT NULL,
   description TEXT NOT NULL DEFAULT '',
   source_path TEXT,
-  embedding BLOB,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  embedding FLOAT[1536],
+  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
   UNIQUE(context_item_id, chunk_index)
-);
+);

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

@@ -3,7 +3,7 @@ CREATE TABLE threads (
   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')),
+  started_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
   ended_at TEXT,
   metadata TEXT
 );
@@ -19,6 +19,6 @@ CREATE TABLE interactions (
   tool_input TEXT,
   duration_ms INTEGER,
   token_count INTEGER,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  created_at TEXT NOT NULL DEFAULT (current_timestamp::VARCHAR),
   UNIQUE(thread_id, sequence)
-);
+);

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

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

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

@@ -0,0 +1 @@
+CREATE INDEX IF NOT EXISTS idx_embeddings_cosine ON embeddings USING HNSW (embedding) WITH (metric = 'cosine');

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

@@ -0,0 +1,24 @@
+-- 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)
+);
+CREATE INDEX IF NOT EXISTS idx_embeddings_cosine ON embeddings USING HNSW (embedding) WITH (metric = 'cosine');
+CHECKPOINT;

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

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

package/src/db/tasks.ts

@@ -1,5 +1,5 @@
 import type { DbConnection } from "./connection.ts";
-import { buildSetClauses, buildWhereClause } from "./query.ts";
+import { buildSetClauses, buildWhereClause, sanitizeInt } from "./query.ts";
 import { uuidv7 } from "./uuid.ts";
 
 export const TASK_PRIORITIES = ["low", "medium", "high"] as const;
@@ -22,6 +22,7 @@ export interface Task {
   claimed_at: Date | null;
   blocked_by: string[];
   context_ids: string[];
+  output: string | null;
   created_at: Date;
   updated_at: Date;
 }
@@ -37,6 +38,7 @@ interface TaskRow {
   claimed_at: string | null;
   blocked_by: string;
   context_ids: string;
+  output: string | null;
   created_at: string;
   updated_at: string;
 }
@@ -53,6 +55,7 @@ function rowToTask(row: TaskRow): Task {
     claimed_at: row.claimed_at ? new Date(row.claimed_at) : null,
     blocked_by: JSON.parse(row.blocked_by || "[]"),
     context_ids: JSON.parse(row.context_ids || "[]"),
+    output: row.output,
     created_at: new Date(row.created_at),
     updated_at: new Date(row.updated_at),
   };
@@ -74,20 +77,17 @@ export async function createTask(
   const blockedBy = JSON.stringify(blockedByArr);
   const contextIds = JSON.stringify(params.context_ids ?? []);
 
-  const row = db
-    .query(
-      `INSERT INTO tasks (id, name, description, priority, blocked_by, context_ids)
+  const row = await db.queryGet<TaskRow>(
+    `INSERT INTO tasks (id, name, description, priority, blocked_by, context_ids)
      VALUES (?1, ?2, ?3, ?4, ?5, ?6)
      RETURNING *`,
-    )
-    .get(
-      id,
-      params.name,
-      params.description ?? "",
-      params.priority ?? "medium",
-      blockedBy,
-      contextIds,
-    ) as TaskRow | null;
+    id,
+    params.name,
+    params.description ?? "",
+    params.priority ?? "medium",
+    blockedBy,
+    contextIds,
+  );
   if (!row) throw new Error("INSERT did not return a row");
   return rowToTask(row);
 }
@@ -96,9 +96,10 @@ export async function getTask(
   db: DbConnection,
   id: string,
 ): Promise<Task | null> {
-  const row = db
-    .query("SELECT * FROM tasks WHERE id = ?1")
-    .get(id) as TaskRow | null;
+  const row = await db.queryGet<TaskRow>(
+    "SELECT * FROM tasks WHERE id = ?1",
+    id,
+  );
   return row ? rowToTask(row) : null;
 }
 
@@ -114,17 +115,16 @@ export async function listTasks(
     ["status", filters?.status],
     ["priority", filters?.priority],
   ]);
-  const limit = filters?.limit ? `LIMIT ${filters.limit}` : "";
+  const limit = filters?.limit ? `LIMIT ${sanitizeInt(filters.limit)}` : "";
 
-  const rows = db
-    .query(
-      `SELECT * FROM tasks ${where}
+  const rows = await db.queryAll<TaskRow>(
+    `SELECT * FROM tasks ${where}
      ORDER BY
        CASE priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 WHEN 'low' THEN 2 END,
        created_at ASC
      ${limit}`,
-    )
-    .all(...params) as TaskRow[];
+    ...params,
+  );
   return rows.map(rowToTask);
 }
 
@@ -133,12 +133,17 @@ export async function updateTaskStatus(
   id: string,
   status: Task["status"],
   reason?: string,
+  output?: string,
 ): Promise<void> {
-  db.query(
+  await db.queryRun(
     `UPDATE tasks
-     SET status = ?1, waiting_reason = ?2, updated_at = datetime('now')
-     WHERE id = ?3`,
-  ).run(status, reason ?? null, id);
+     SET status = ?1, waiting_reason = ?2, output = ?3, updated_at = current_timestamp::VARCHAR
+     WHERE id = ?4`,
+    status,
+    reason ?? null,
+    output ?? null,
+    id,
+  );
 }
 
 export async function validateBlockedBy(
@@ -206,14 +211,13 @@ export async function updateTask(
     return getTask(db, id);
   }
 
-  setClauses.push("updated_at = datetime('now')");
+  setClauses.push("updated_at = current_timestamp::VARCHAR");
   params.push(id);
 
-  const row = db
-    .query(
-      `UPDATE tasks SET ${setClauses.join(", ")} WHERE id = ?${params.length} RETURNING *`,
-    )
-    .get(...params) as TaskRow | null;
+  const row = await db.queryGet<TaskRow>(
+    `UPDATE tasks SET ${setClauses.join(", ")} WHERE id = ?${params.length} RETURNING *`,
+    ...params,
+  );
   return row ? rowToTask(row) : null;
 }
 
@@ -221,7 +225,7 @@ export async function deleteTask(
   db: DbConnection,
   id: string,
 ): Promise<boolean> {
-  const result = db.query("DELETE FROM tasks WHERE id = ?1").run(id);
+  const result = await db.queryRun("DELETE FROM tasks WHERE id = ?1", id);
   return result.changes > 0;
 }
 
@@ -229,15 +233,14 @@ export async function resetTask(
   db: DbConnection,
   id: string,
 ): Promise<Task | null> {
-  const row = db
-    .query(
-      `UPDATE tasks
+  const row = await db.queryGet<TaskRow>(
+    `UPDATE tasks
      SET status = 'pending', claimed_by = NULL, claimed_at = NULL,
-         waiting_reason = NULL, updated_at = datetime('now')
+         waiting_reason = NULL, output = NULL, updated_at = current_timestamp::VARCHAR
      WHERE id = ?1
      RETURNING *`,
-    )
-    .get(id) as TaskRow | null;
+    id,
+  );
   return row ? rowToTask(row) : null;
 }
 
@@ -245,19 +248,18 @@ export async function resetStaleTasks(
   db: DbConnection,
   timeoutSeconds: number,
 ): Promise<string[]> {
-  const rows = db
-    .query(
-      `UPDATE tasks
+  const rows = await db.queryAll<{ id: string }>(
+    `UPDATE tasks
      SET status = 'pending',
          claimed_by = NULL,
          claimed_at = NULL,
-         updated_at = datetime('now')
+         updated_at = current_timestamp::VARCHAR
      WHERE status = 'in_progress'
        AND claimed_at IS NOT NULL
-       AND claimed_at < datetime('now', '-' || ?1 || ' seconds')
+       AND claimed_at::TIMESTAMP < current_timestamp - to_seconds(CAST(?1 AS BIGINT))
      RETURNING id`,
-    )
-    .all(timeoutSeconds) as { id: string }[];
+    timeoutSeconds,
+  );
   return rows.map((r) => r.id);
 }
 
@@ -266,42 +268,51 @@ export async function claimNextTask(
   claimedBy = "daemon",
 ): Promise<Task | null> {
   // Find highest-priority unblocked pending task
-  const row = db
-    .query(
-      `SELECT * FROM tasks
+  // Use application-level filtering for blocked_by since DuckDB doesn't have json_each
+  const allPending = await db.queryAll<TaskRow>(
+    `SELECT * FROM tasks
      WHERE status = 'pending'
-       AND (
-         blocked_by = '[]'
-         OR blocked_by IS NULL
-         OR NOT EXISTS (
-           SELECT 1 FROM json_each(blocked_by) AS b
-           WHERE b.value NOT IN (SELECT id FROM tasks WHERE status = 'complete')
-         )
-       )
      ORDER BY
        CASE priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 WHEN 'low' THEN 2 END,
-       created_at ASC
-     LIMIT 1`,
-    )
-    .get() as TaskRow | null;
+       created_at ASC`,
+  );
 
-  if (!row) return null;
-  const task = rowToTask(row);
+  for (const row of allPending) {
+    const blockedBy: string[] = JSON.parse(row.blocked_by || "[]");
+    if (blockedBy.length > 0) {
+      // Check if all blockers are complete
+      let allComplete = true;
+      for (const blockerId of blockedBy) {
+        const blocker = await db.queryGet<{ status: string }>(
+          "SELECT status FROM tasks WHERE id = ?1",
+          blockerId,
+        );
+        if (!blocker || blocker.status !== "complete") {
+          allComplete = false;
+          break;
+        }
+      }
+      if (!allComplete) continue;
+    }
 
-  // Claim it
-  db.query(
-    `UPDATE tasks
-     SET status = 'in_progress',
-         claimed_by = ?1,
-         claimed_at = datetime('now'),
-         updated_at = datetime('now')
-     WHERE id = ?2 AND status = 'pending'`,
-  ).run(claimedBy, task.id);
+    // Attempt atomic claim — RETURNING confirms we actually got it
+    const claimed = await db.queryGet<TaskRow>(
+      `UPDATE tasks
+       SET status = 'in_progress',
+           claimed_by = ?1,
+           claimed_at = current_timestamp::VARCHAR,
+           updated_at = current_timestamp::VARCHAR
+       WHERE id = ?2 AND status = 'pending'
+       RETURNING *`,
+      claimedBy,
+      row.id,
+    );
 
-  return {
-    ...task,
-    status: "in_progress",
-    claimed_by: claimedBy,
-    claimed_at: new Date(),
-  };
+    if (claimed) {
+      return rowToTask(claimed);
+    }
+    // Another process claimed it — try next candidate
+  }
+
+  return null;
 }