botholomew 0.12.3 → 0.13.0

package/src/db/threads.ts

@@ -1,276 +0,0 @@
-import type { DbConnection } from "./connection.ts";
-import { buildWhereClause, sanitizeInt } from "./query.ts";
-import { uuidv7 } from "./uuid.ts";
-
-export interface Thread {
-  id: string;
-  type: "worker_tick" | "chat_session";
-  task_id: string | null;
-  title: string;
-  started_at: Date;
-  ended_at: Date | null;
-  metadata: string | null;
-}
-
-export interface Interaction {
-  id: string;
-  thread_id: string;
-  sequence: number;
-  role: "user" | "assistant" | "system" | "tool";
-  kind:
-    | "message"
-    | "thinking"
-    | "tool_use"
-    | "tool_result"
-    | "context_update"
-    | "status_change";
-  content: string;
-  tool_name: string | null;
-  tool_input: string | null;
-  duration_ms: number | null;
-  token_count: number | null;
-  created_at: Date;
-}
-
-interface ThreadRow {
-  id: string;
-  type: string;
-  task_id: string | null;
-  title: string;
-  started_at: string;
-  ended_at: string | null;
-  metadata: string | null;
-}
-
-interface InteractionRow {
-  id: string;
-  thread_id: string;
-  sequence: number;
-  role: string;
-  kind: string;
-  content: string;
-  tool_name: string | null;
-  tool_input: string | null;
-  duration_ms: number | null;
-  token_count: number | null;
-  created_at: string;
-}
-
-function rowToThread(row: ThreadRow): Thread {
-  return {
-    id: row.id,
-    type: row.type as Thread["type"],
-    task_id: row.task_id,
-    title: row.title,
-    started_at: new Date(row.started_at),
-    ended_at: row.ended_at ? new Date(row.ended_at) : null,
-    metadata: row.metadata,
-  };
-}
-
-function rowToInteraction(row: InteractionRow): Interaction {
-  return {
-    id: row.id,
-    thread_id: row.thread_id,
-    sequence: row.sequence,
-    role: row.role as Interaction["role"],
-    kind: row.kind as Interaction["kind"],
-    content: row.content,
-    tool_name: row.tool_name,
-    tool_input: row.tool_input,
-    duration_ms: row.duration_ms,
-    token_count: row.token_count,
-    created_at: new Date(row.created_at),
-  };
-}
-
-export async function createThread(
-  db: DbConnection,
-  type: Thread["type"],
-  taskId?: string,
-  title?: string,
-): Promise<string> {
-  const id = uuidv7();
-  await db.queryRun(
-    `INSERT INTO threads (id, type, task_id, title)
-     VALUES (?1, ?2, ?3, ?4)`,
-    id,
-    type,
-    taskId ?? null,
-    title ?? "",
-  );
-  return id;
-}
-
-export async function logInteraction(
-  db: DbConnection,
-  threadId: string,
-  params: {
-    role: Interaction["role"];
-    kind: Interaction["kind"];
-    content: string;
-    toolName?: string;
-    toolInput?: string;
-    durationMs?: number;
-    tokenCount?: number;
-  },
-): Promise<string> {
-  // Get next sequence number
-  const seqRow = await db.queryGet<{ next_seq: number }>(
-    "SELECT COALESCE(MAX(sequence), 0) + 1 AS next_seq FROM interactions WHERE thread_id = ?1",
-    threadId,
-  );
-  const sequence = seqRow?.next_seq ?? 1;
-
-  const id = uuidv7();
-  await db.queryRun(
-    `INSERT INTO interactions (id, thread_id, sequence, role, kind, content, tool_name, tool_input, duration_ms, token_count)
-     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)`,
-    id,
-    threadId,
-    sequence,
-    params.role,
-    params.kind,
-    params.content,
-    params.toolName ?? null,
-    params.toolInput ?? null,
-    params.durationMs ?? null,
-    params.tokenCount ?? null,
-  );
-  return id;
-}
-
-export async function endThread(
-  db: DbConnection,
-  threadId: string,
-): Promise<void> {
-  await db.queryRun(
-    "UPDATE threads SET ended_at = current_timestamp::VARCHAR WHERE id = ?1",
-    threadId,
-  );
-}
-
-export async function reopenThread(
-  db: DbConnection,
-  threadId: string,
-): Promise<void> {
-  await db.queryRun(
-    "UPDATE threads SET ended_at = NULL WHERE id = ?1",
-    threadId,
-  );
-}
-
-export async function updateThreadTitle(
-  db: DbConnection,
-  threadId: string,
-  title: string,
-): Promise<void> {
-  await db.queryRun(
-    "UPDATE threads SET title = ?2 WHERE id = ?1",
-    threadId,
-    title,
-  );
-}
-
-export async function getThread(
-  db: DbConnection,
-  threadId: string,
-): Promise<{ thread: Thread; interactions: Interaction[] } | null> {
-  const threadRow = await db.queryGet<ThreadRow>(
-    "SELECT * FROM threads WHERE id = ?1",
-    threadId,
-  );
-  if (!threadRow) return null;
-
-  const interactionRows = await db.queryAll<InteractionRow>(
-    "SELECT * FROM interactions WHERE thread_id = ?1 ORDER BY sequence ASC",
-    threadId,
-  );
-
-  return {
-    thread: rowToThread(threadRow),
-    interactions: interactionRows.map(rowToInteraction),
-  };
-}
-
-export async function deleteThread(
-  db: DbConnection,
-  threadId: string,
-): Promise<boolean> {
-  await db.queryRun("DELETE FROM interactions WHERE thread_id = ?1", threadId);
-  const result = await db.queryRun(
-    "DELETE FROM threads WHERE id = ?1",
-    threadId,
-  );
-  return result.changes > 0;
-}
-
-export async function deleteAllThreads(
-  db: DbConnection,
-): Promise<{ threads: number; interactions: number }> {
-  const interactions = await db.queryRun("DELETE FROM interactions");
-  const threads = await db.queryRun("DELETE FROM threads");
-  return {
-    threads: threads.changes,
-    interactions: interactions.changes,
-  };
-}
-
-export async function getInteractionsAfter(
-  db: DbConnection,
-  threadId: string,
-  afterSequence: number,
-): Promise<Interaction[]> {
-  const rows = await db.queryAll<InteractionRow>(
-    `SELECT * FROM interactions WHERE thread_id = ?1 AND sequence > ?2 ORDER BY sequence ASC`,
-    threadId,
-    afterSequence,
-  );
-  return rows.map(rowToInteraction);
-}
-
-export async function getActiveThread(
-  db: DbConnection,
-): Promise<Thread | null> {
-  const row = await db.queryGet<ThreadRow>(
-    `SELECT * FROM threads WHERE ended_at IS NULL ORDER BY started_at DESC LIMIT 1`,
-  );
-  return row ? rowToThread(row) : null;
-}
-
-export async function isThreadEnded(
-  db: DbConnection,
-  threadId: string,
-): Promise<boolean> {
-  const row = await db.queryGet<{ ended_at: string | null }>(
-    `SELECT ended_at FROM threads WHERE id = ?1`,
-    threadId,
-  );
-  if (!row) return true;
-  return row.ended_at !== null;
-}
-
-export async function listThreads(
-  db: DbConnection,
-  filters?: {
-    type?: Thread["type"];
-    taskId?: string;
-    limit?: number;
-    offset?: number;
-  },
-): Promise<Thread[]> {
-  const { where, params } = buildWhereClause([
-    ["type", filters?.type],
-    ["task_id", filters?.taskId],
-  ]);
-  const limit = filters?.limit ? `LIMIT ${sanitizeInt(filters.limit)}` : "";
-  const offset = filters?.offset ? `OFFSET ${sanitizeInt(filters.offset)}` : "";
-
-  const rows = await db.queryAll<ThreadRow>(
-    `SELECT * FROM threads ${where}
-     ORDER BY started_at DESC, id DESC
-     ${limit} ${offset}`,
-    ...params,
-  );
-  return rows.map(rowToThread);
-}

package/src/db/workers.ts

@@ -1,212 +0,0 @@
-import type { DbConnection } from "./connection.ts";
-import { buildWhereClause, sanitizeInt } from "./query.ts";
-
-export const WORKER_MODES = ["persist", "once"] as const;
-export const WORKER_STATUSES = ["running", "stopped", "dead"] as const;
-
-export interface Worker {
-  id: string;
-  pid: number;
-  hostname: string;
-  mode: (typeof WORKER_MODES)[number];
-  task_id: string | null;
-  status: (typeof WORKER_STATUSES)[number];
-  started_at: Date;
-  last_heartbeat_at: Date;
-  stopped_at: Date | null;
-  log_path: string | null;
-}
-
-interface WorkerRow {
-  id: string;
-  pid: number;
-  hostname: string;
-  mode: string;
-  task_id: string | null;
-  status: string;
-  started_at: string;
-  last_heartbeat_at: string;
-  stopped_at: string | null;
-  log_path: string | null;
-}
-
-function rowToWorker(row: WorkerRow): Worker {
-  return {
-    id: row.id,
-    pid: row.pid,
-    hostname: row.hostname,
-    mode: row.mode as Worker["mode"],
-    task_id: row.task_id,
-    status: row.status as Worker["status"],
-    started_at: new Date(row.started_at),
-    last_heartbeat_at: new Date(row.last_heartbeat_at),
-    stopped_at: row.stopped_at ? new Date(row.stopped_at) : null,
-    log_path: row.log_path,
-  };
-}
-
-export async function registerWorker(
-  db: DbConnection,
-  params: {
-    id: string;
-    pid: number;
-    hostname: string;
-    mode: Worker["mode"];
-    taskId?: string | null;
-    logPath?: string | null;
-  },
-): Promise<Worker> {
-  const row = await db.queryGet<WorkerRow>(
-    `INSERT INTO workers (id, pid, hostname, mode, task_id, status, log_path)
-     VALUES (?1, ?2, ?3, ?4, ?5, 'running', ?6)
-     RETURNING *`,
-    params.id,
-    params.pid,
-    params.hostname,
-    params.mode,
-    params.taskId ?? null,
-    params.logPath ?? null,
-  );
-  if (!row) throw new Error("INSERT did not return a row");
-  return rowToWorker(row);
-}
-
-export async function heartbeat(db: DbConnection, id: string): Promise<void> {
-  await db.queryRun(
-    `UPDATE workers
-     SET last_heartbeat_at = current_timestamp::VARCHAR
-     WHERE id = ?1 AND status = 'running'`,
-    id,
-  );
-}
-
-export async function markWorkerStopped(
-  db: DbConnection,
-  id: string,
-): Promise<void> {
-  await db.queryRun(
-    `UPDATE workers
-     SET status = 'stopped',
-         stopped_at = current_timestamp::VARCHAR
-     WHERE id = ?1 AND status = 'running'`,
-    id,
-  );
-}
-
-export async function markWorkerDead(
-  db: DbConnection,
-  id: string,
-): Promise<void> {
-  await db.queryRun(
-    `UPDATE workers
-     SET status = 'dead',
-         stopped_at = current_timestamp::VARCHAR
-     WHERE id = ?1 AND status = 'running'`,
-    id,
-  );
-}
-
-/**
- * Find running workers whose heartbeat is older than `staleAfterSeconds`,
- * mark them dead, and release any tasks/schedule claims they held back
- * to the pool. Returns the ids of reaped workers.
- */
-export async function reapDeadWorkers(
-  db: DbConnection,
-  staleAfterSeconds: number,
-): Promise<string[]> {
-  const stale = await db.queryAll<{ id: string }>(
-    `UPDATE workers
-     SET status = 'dead',
-         stopped_at = current_timestamp::VARCHAR
-     WHERE status = 'running'
-       AND last_heartbeat_at::TIMESTAMP
-           < current_timestamp - to_seconds(CAST(?1 AS BIGINT))
-     RETURNING id`,
-    staleAfterSeconds,
-  );
-  const reapedIds = stale.map((r) => r.id);
-  if (reapedIds.length === 0) return reapedIds;
-
-  for (const reapedId of reapedIds) {
-    await db.queryRun(
-      `UPDATE tasks
-       SET status = 'pending',
-           claimed_by = NULL,
-           claimed_at = NULL,
-           updated_at = current_timestamp::VARCHAR
-       WHERE claimed_by = ?1 AND status = 'in_progress'`,
-      reapedId,
-    );
-    await db.queryRun(
-      `UPDATE schedules
-       SET claimed_by = NULL,
-           claimed_at = NULL
-       WHERE claimed_by = ?1`,
-      reapedId,
-    );
-  }
-  return reapedIds;
-}
-
-/**
- * Delete cleanly-stopped workers (status='stopped') whose `stopped_at` is
- * older than `afterSeconds`. Dead workers are intentionally left alone —
- * they're forensic evidence that something crashed.
- * Returns the ids that were pruned.
- */
-export async function pruneStoppedWorkers(
-  db: DbConnection,
-  afterSeconds: number,
-): Promise<string[]> {
-  const rows = await db.queryAll<{ id: string }>(
-    `DELETE FROM workers
-     WHERE status = 'stopped'
-       AND stopped_at IS NOT NULL
-       AND stopped_at::TIMESTAMP
-           < current_timestamp - to_seconds(CAST(?1 AS BIGINT))
-     RETURNING id`,
-    afterSeconds,
-  );
-  return rows.map((r) => r.id);
-}
-
-export async function listWorkers(
-  db: DbConnection,
-  filters?: {
-    status?: Worker["status"];
-    limit?: number;
-    offset?: number;
-  },
-): Promise<Worker[]> {
-  const { where, params } = buildWhereClause([["status", filters?.status]]);
-  const limit = filters?.limit ? `LIMIT ${sanitizeInt(filters.limit)}` : "";
-  const offset = filters?.offset ? `OFFSET ${sanitizeInt(filters.offset)}` : "";
-
-  const rows = await db.queryAll<WorkerRow>(
-    `SELECT * FROM workers ${where}
-     ORDER BY started_at DESC, id DESC
-     ${limit} ${offset}`,
-    ...params,
-  );
-  return rows.map(rowToWorker);
-}
-
-export async function getWorker(
-  db: DbConnection,
-  id: string,
-): Promise<Worker | null> {
-  const row = await db.queryGet<WorkerRow>(
-    "SELECT * FROM workers WHERE id = ?1",
-    id,
-  );
-  return row ? rowToWorker(row) : null;
-}
-
-export async function deleteWorker(
-  db: DbConnection,
-  id: string,
-): Promise<boolean> {
-  const result = await db.queryRun("DELETE FROM workers WHERE id = ?1", id);
-  return result.changes > 0;
-}

package/src/tools/context/list-drives.ts

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import { listDriveSummaries } from "../../db/context.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({});
-
-const outputSchema = z.object({
-  drives: z.array(
-    z.object({
-      drive: z.string(),
-      count: z.number(),
-    }),
-  ),
-  is_error: z.boolean(),
-  hint: z.string().optional(),
-});
-
-export const contextListDrivesTool = {
-  name: "context_list_drives",
-  description:
-    "List every drive that currently has content, with its item count. Use this to discover which values to pass as `drive` on other context tools (disk / url / agent / google-docs / github / …).",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (_input, ctx) => {
-    const drives = await listDriveSummaries(ctx.conn);
-    if (drives.length === 0) {
-      return {
-        drives: [],
-        is_error: false,
-        hint: "No context has been ingested yet. The user can run `botholomew context add <path-or-url>` to add content.",
-      };
-    }
-    return { drives, is_error: false };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/context/refresh.ts

@@ -1,165 +0,0 @@
-import { z } from "zod";
-import { parseDriveRef } from "../../context/drives.ts";
-import { refreshContextItems } from "../../context/refresh.ts";
-import {
-  type ContextItem,
-  listContextItems,
-  listContextItemsByPrefix,
-  resolveContextItem,
-} from "../../db/context.ts";
-import { buildContextTree } from "../dir/tree.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  ref: z
-    .string()
-    .optional()
-    .describe(
-      "UUID or 'drive:/path' of a single item, or 'drive:/prefix' to refresh a subtree. Mutually exclusive with `all`.",
-    ),
-  all: z
-    .boolean()
-    .optional()
-    .describe(
-      "Refresh every item that has an external origin (drive != 'agent'). Mutually exclusive with `ref`.",
-    ),
-});
-
-const outputSchema = z.object({
-  checked: z.number(),
-  updated: z.number(),
-  unchanged: z.number(),
-  missing: z.number(),
-  reembedded: z.number(),
-  chunks: z.number(),
-  embeddings_skipped: z.boolean(),
-  items: z.array(
-    z.object({
-      id: z.string(),
-      drive: z.string(),
-      path: z.string(),
-      ref: z.string(),
-      status: z.enum(["updated", "unchanged", "missing", "error"]),
-      error: z.string().optional(),
-    }),
-  ),
-  message: z.string(),
-  is_error: z.boolean(),
-  tree: z
-    .string()
-    .optional()
-    .describe(
-      "Snapshot of the context filesystem after the refresh so you can see what's currently stored.",
-    ),
-});
-
-const empty = {
-  checked: 0,
-  updated: 0,
-  unchanged: 0,
-  missing: 0,
-  reembedded: 0,
-  chunks: 0,
-  embeddings_skipped: false,
-  items: [],
-  tree: undefined as string | undefined,
-};
-
-export const contextRefreshTool = {
-  name: "context_refresh",
-  description:
-    "[[ bash equivalent command: curl ]] Re-import items from their origin (disk / URL / MCP) and re-embed changed items. Use `ref` for a single item or subtree, or `all: true` for every non-agent item. URL fetches use the project's MCPX client when available and fall back to plain HTTP.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    if (!input.ref && !input.all) {
-      return {
-        ...empty,
-        message: "Provide a `ref` or set `all: true`.",
-        is_error: true,
-      };
-    }
-    if (input.ref && input.all) {
-      return {
-        ...empty,
-        message: "`ref` and `all` are mutually exclusive.",
-        is_error: true,
-      };
-    }
-
-    let items: ContextItem[];
-    if (input.all) {
-      items = await listContextItems(ctx.conn);
-    } else {
-      const ref = input.ref as string;
-      const exact = await resolveContextItem(ctx.conn, ref);
-      if (exact) {
-        items = [exact];
-      } else {
-        const parsed = parseDriveRef(ref);
-        items = parsed
-          ? await listContextItemsByPrefix(
-              ctx.conn,
-              parsed.drive,
-              parsed.path,
-              {
-                recursive: true,
-              },
-            )
-          : [];
-      }
-    }
-
-    if (items.length === 0) {
-      return {
-        ...empty,
-        message: `No context items match \`${input.ref ?? "all"}\`.`,
-        is_error: true,
-      };
-    }
-
-    const refreshable = items.filter((i) => i.drive !== "agent");
-    if (refreshable.length === 0) {
-      return {
-        ...empty,
-        message:
-          "No refreshable items — everything matched lives on drive=agent (agent-authored content has no external origin).",
-        is_error: false,
-      };
-    }
-
-    const result = await refreshContextItems(
-      ctx.conn,
-      refreshable,
-      ctx.config,
-      ctx.mcpxClient,
-    );
-
-    const parts = [
-      `Checked ${result.checked}`,
-      `${result.updated} updated`,
-      `${result.unchanged} unchanged`,
-      `${result.missing} missing`,
-      `${result.reembedded} re-embedded (${result.chunks} chunks)`,
-    ];
-    if (result.embeddings_skipped) {
-      parts.push("embeddings skipped (no OpenAI API key configured)");
-    }
-
-    // For a single-ref refresh, render that ref's drive; for `all: true`,
-    // render the top-level drive summary so the scope of the tree matches
-    // the scope of the operation.
-    const treeDrive = input.all
-      ? undefined
-      : (result.items[0]?.drive ?? undefined);
-    const { tree } = await buildContextTree(ctx.conn, { drive: treeDrive });
-
-    return {
-      ...result,
-      message: parts.join(", "),
-      is_error: false,
-      tree,
-    };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;