botholomew 0.1.0

package/src/db/tasks.ts

@@ -0,0 +1,194 @@
+import type { DbConnection } from "./connection.ts";
+import { uuidv7 } from "./uuid.ts";
+
+export const TASK_PRIORITIES = ["low", "medium", "high"] as const;
+export const TASK_STATUSES = [
+  "pending",
+  "in_progress",
+  "failed",
+  "complete",
+  "waiting",
+] as const;
+
+export interface Task {
+  id: string;
+  name: string;
+  description: string;
+  priority: (typeof TASK_PRIORITIES)[number];
+  status: (typeof TASK_STATUSES)[number];
+  waiting_reason: string | null;
+  claimed_by: string | null;
+  claimed_at: Date | null;
+  blocked_by: string[];
+  context_ids: string[];
+  created_at: Date;
+  updated_at: Date;
+}
+
+interface TaskRow {
+  id: string;
+  name: string;
+  description: string;
+  priority: string;
+  status: string;
+  waiting_reason: string | null;
+  claimed_by: string | null;
+  claimed_at: string | null;
+  blocked_by: string;
+  context_ids: string;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToTask(row: TaskRow): Task {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    priority: row.priority as Task["priority"],
+    status: row.status as Task["status"],
+    waiting_reason: row.waiting_reason,
+    claimed_by: row.claimed_by,
+    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 || "[]"),
+    created_at: new Date(row.created_at),
+    updated_at: new Date(row.updated_at),
+  };
+}
+
+export async function createTask(
+  db: DbConnection,
+  params: {
+    name: string;
+    description?: string;
+    priority?: Task["priority"];
+    blocked_by?: string[];
+    context_ids?: string[];
+  },
+): Promise<Task> {
+  const id = uuidv7();
+  const blockedBy = JSON.stringify(params.blocked_by ?? []);
+  const contextIds = JSON.stringify(params.context_ids ?? []);
+
+  const row = db
+    .query(
+      `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;
+  if (!row) throw new Error("INSERT did not return a row");
+  return rowToTask(row);
+}
+
+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;
+  return row ? rowToTask(row) : null;
+}
+
+export async function listTasks(
+  db: DbConnection,
+  filters?: {
+    status?: Task["status"];
+    priority?: Task["priority"];
+    limit?: number;
+  },
+): Promise<Task[]> {
+  const conditions: string[] = [];
+  const params: string[] = [];
+
+  if (filters?.status) {
+    params.push(filters.status);
+    conditions.push(`status = ?${params.length}`);
+  }
+  if (filters?.priority) {
+    params.push(filters.priority);
+    conditions.push(`priority = ?${params.length}`);
+  }
+
+  const where =
+    conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters?.limit ? `LIMIT ${filters.limit}` : "";
+
+  const rows = db
+    .query(
+      `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[];
+  return rows.map(rowToTask);
+}
+
+export async function updateTaskStatus(
+  db: DbConnection,
+  id: string,
+  status: Task["status"],
+  reason?: string,
+): Promise<void> {
+  db.query(
+    `UPDATE tasks
+     SET status = ?1, waiting_reason = ?2, updated_at = datetime('now')
+     WHERE id = ?3`,
+  ).run(status, reason ?? null, id);
+}
+
+export async function claimNextTask(
+  db: DbConnection,
+  claimedBy = "daemon",
+): Promise<Task | null> {
+  // Find highest-priority unblocked pending task
+  const row = db
+    .query(
+      `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;
+
+  if (!row) return null;
+  const task = rowToTask(row);
+
+  // 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);
+
+  return {
+    ...task,
+    status: "in_progress",
+    claimed_by: claimedBy,
+    claimed_at: new Date(),
+  };
+}

package/src/db/threads.ts

@@ -0,0 +1,202 @@
+import type { DbConnection } from "./connection.ts";
+import { uuidv7 } from "./uuid.ts";
+
+export interface Thread {
+  id: string;
+  type: "daemon_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();
+  db.query(
+    `INSERT INTO threads (id, type, task_id, title)
+     VALUES (?1, ?2, ?3, ?4)`,
+  ).run(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 = db
+    .query(
+      "SELECT COALESCE(MAX(sequence), 0) + 1 AS next_seq FROM interactions WHERE thread_id = ?1",
+    )
+    .get(threadId) as { next_seq: number };
+  const sequence = seqRow.next_seq;
+
+  const id = uuidv7();
+  db.query(
+    `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)`,
+  ).run(
+    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> {
+  db.query("UPDATE threads SET ended_at = datetime('now') WHERE id = ?1").run(
+    threadId,
+  );
+}
+
+export async function getThread(
+  db: DbConnection,
+  threadId: string,
+): Promise<{ thread: Thread; interactions: Interaction[] } | null> {
+  const threadRow = db
+    .query("SELECT * FROM threads WHERE id = ?1")
+    .get(threadId) as ThreadRow | null;
+  if (!threadRow) return null;
+
+  const interactionRows = db
+    .query(
+      "SELECT * FROM interactions WHERE thread_id = ?1 ORDER BY sequence ASC",
+    )
+    .all(threadId) as InteractionRow[];
+
+  return {
+    thread: rowToThread(threadRow),
+    interactions: interactionRows.map(rowToInteraction),
+  };
+}
+
+export async function listThreads(
+  db: DbConnection,
+  filters?: {
+    type?: Thread["type"];
+    taskId?: string;
+    limit?: number;
+  },
+): Promise<Thread[]> {
+  const conditions: string[] = [];
+  const params: string[] = [];
+
+  if (filters?.type) {
+    params.push(filters.type);
+    conditions.push(`type = ?${params.length}`);
+  }
+  if (filters?.taskId) {
+    params.push(filters.taskId);
+    conditions.push(`task_id = ?${params.length}`);
+  }
+
+  const where =
+    conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters?.limit ? `LIMIT ${filters.limit}` : "";
+
+  const rows = db
+    .query(
+      `SELECT * FROM threads ${where}
+     ORDER BY started_at DESC
+     ${limit}`,
+    )
+    .all(...params) as ThreadRow[];
+  return rows.map(rowToThread);
+}

package/src/db/uuid.ts

@@ -0,0 +1 @@
+export { v7 as uuidv7 } from "uuid";

package/src/init/index.ts

@@ -0,0 +1,84 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { getBotholomewDir, getDbPath, getMcpxDir } from "../constants.ts";
+import { getConnection } from "../db/connection.ts";
+import { migrate } from "../db/schema.ts";
+import { logger } from "../utils/logger.ts";
+import {
+  BELIEFS_MD,
+  DEFAULT_CONFIG,
+  DEFAULT_MCPX_SERVERS,
+  GOALS_MD,
+  SOUL_MD,
+} from "./templates.ts";
+
+export async function initProject(
+  projectDir: string,
+  opts: { force?: boolean } = {},
+): Promise<void> {
+  const dotDir = getBotholomewDir(projectDir);
+  const mcpxDir = getMcpxDir(projectDir);
+
+  // Check if already initialized
+  const dirExists = await Bun.file(join(dotDir, "soul.md")).exists();
+  if (dirExists && !opts.force) {
+    throw new Error(
+      `.botholomew already initialized in ${projectDir}. Use --force to reinitialize.`,
+    );
+  }
+
+  // Create directories
+  await mkdir(dotDir, { recursive: true });
+  await mkdir(mcpxDir, { recursive: true });
+
+  // Write template files
+  await Bun.write(join(dotDir, "soul.md"), SOUL_MD);
+  await Bun.write(join(dotDir, "beliefs.md"), BELIEFS_MD);
+  await Bun.write(join(dotDir, "goals.md"), GOALS_MD);
+
+  // Write config (without API key)
+  await Bun.write(
+    join(dotDir, "config.json"),
+    `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`,
+  );
+
+  // Write mcpx servers config
+  await Bun.write(
+    join(mcpxDir, "servers.json"),
+    `${JSON.stringify(DEFAULT_MCPX_SERVERS, null, 2)}\n`,
+  );
+
+  // Initialize database
+  const dbPath = getDbPath(projectDir);
+  const conn = getConnection(dbPath);
+  migrate(conn);
+  conn.close();
+
+  // Update .gitignore
+  await updateGitignore(projectDir);
+
+  logger.success("Initialized Botholomew project");
+  logger.dim(`  Directory: ${dotDir}`);
+  logger.dim(`  Database: ${dbPath}`);
+  logger.dim("");
+  logger.dim("Next steps:");
+  logger.dim("  1. Set ANTHROPIC_API_KEY or add it to .botholomew/config.json");
+  logger.dim("  2. Run 'botholomew task add' to create your first task");
+  logger.dim("  3. Run 'botholomew daemon start' to start the daemon");
+}
+
+async function updateGitignore(projectDir: string): Promise<void> {
+  const gitignorePath = join(projectDir, ".gitignore");
+  const file = Bun.file(gitignorePath);
+
+  let content = "";
+  if (await file.exists()) {
+    content = await file.text();
+  }
+
+  const entry = ".botholomew/";
+  if (content.includes(entry)) return;
+
+  const section = `\n# Botholomew (auto-generated)\n${entry}\n`;
+  await Bun.write(gitignorePath, `${content.trimEnd()}\n${section}`);
+}

package/src/init/templates.ts

@@ -0,0 +1,48 @@
+export const SOUL_MD = `---
+loading: always
+agent-modification: false
+---
+
+# Soul
+
+You are Botholomew, an AI agent for knowledge work. You help humans manage information, research topics, organize knowledge, and complete intellectual tasks.
+
+You are thoughtful, thorough, and proactive. You work through your task queue methodically, prioritizing appropriately and asking for clarification when needed.
+`;
+
+export const BELIEFS_MD = `---
+loading: always
+agent-modification: true
+---
+
+# Beliefs
+
+*These are things Botholomew has learned about the world and this project.*
+*Botholomew updates this file as it learns.*
+
+- I should be concise and clear in my work products.
+- I should ask for help when I'm stuck rather than guessing.
+`;
+
+export const GOALS_MD = `---
+loading: always
+agent-modification: true
+---
+
+# Goals
+
+*These are the current goals for this project.*
+*Botholomew updates this file as goals are completed or new ones are added.*
+
+- Get set up and ready to help.
+`;
+
+export const DEFAULT_CONFIG = {
+  model: "claude-sonnet-4-20250514",
+  tick_interval_seconds: 300,
+  max_tick_duration_seconds: 120,
+};
+
+export const DEFAULT_MCPX_SERVERS = {
+  mcpServers: {},
+};

package/src/tools/dir/create.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { contextPathExists, createContextItem } from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  path: z.string().describe("Directory path to create"),
+  parents: z
+    .boolean()
+    .optional()
+    .describe("Create parent directories as needed"),
+});
+
+const outputSchema = z.object({
+  created: z.boolean(),
+  path: z.string(),
+});
+
+export const dirCreateTool = {
+  name: "dir_create",
+  description: "Create a directory in the virtual filesystem.",
+  group: "dir",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const exists = await contextPathExists(ctx.conn, input.path);
+    if (exists) {
+      return { created: false, path: input.path };
+    }
+
+    await createContextItem(ctx.conn, {
+      title: input.path.split("/").filter(Boolean).pop() ?? input.path,
+      contextPath: input.path,
+      mimeType: "inode/directory",
+      isTextual: false,
+    });
+
+    return { created: true, path: input.path };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/dir/list.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import {
+  getDistinctDirectories,
+  listContextItemsByPrefix,
+} from "../../db/context.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const DirEntrySchema = z.object({
+  name: z.string(),
+  type: z.enum(["file", "directory"]),
+  size: z.number(),
+});
+
+const inputSchema = z.object({
+  path: z.string().optional().describe("Directory path (defaults to /)"),
+  recursive: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Include contents of subdirectories (defaults to true)"),
+  limit: z
+    .number()
+    .optional()
+    .default(100)
+    .describe("Maximum number of entries to return (defaults to 100)"),
+  offset: z
+    .number()
+    .optional()
+    .default(0)
+    .describe("Number of entries to skip (defaults to 0)"),
+});
+
+const outputSchema = z.object({
+  entries: z.array(DirEntrySchema),
+  total: z.number(),
+});
+
+export const dirListTool = {
+  name: "dir_list",
+  description: "List directory contents in the virtual filesystem.",
+  group: "dir",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const path = input.path ?? "/";
+    const recursive = input.recursive ?? true;
+    const limit = input.limit ?? 100;
+    const offset = input.offset ?? 0;
+    const normalizedPath = path.endsWith("/") ? path : `${path}/`;
+
+    const allItems = await listContextItemsByPrefix(ctx.conn, path, {
+      recursive,
+    });
+
+    const entries: z.infer<typeof DirEntrySchema>[] = allItems.map((item) => ({
+      name: recursive
+        ? item.context_path
+        : item.context_path.slice(normalizedPath.length),
+      type:
+        item.mime_type === "inode/directory"
+          ? ("directory" as const)
+          : ("file" as const),
+      size: item.content?.length ?? 0,
+    }));
+
+    // Add subdirectories (if not recursive, show immediate child dirs)
+    if (!recursive) {
+      const dirs = await getDistinctDirectories(ctx.conn, path);
+      for (const dir of dirs) {
+        const name = dir.slice(normalizedPath.length);
+        if (!entries.some((e) => e.name === name)) {
+          entries.push({ name, type: "directory", size: 0 });
+        }
+      }
+    }
+
+    entries.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    const total = entries.length;
+    const paginated = entries.slice(offset, offset + limit);
+
+    return { entries: paginated, total };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/dir/size.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { listContextItemsByPrefix } from "../../db/context.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().describe("Directory path (defaults to /)"),
+  recursive: z
+    .boolean()
+    .optional()
+    .describe("Include subdirectories (defaults to true)"),
+});
+
+const outputSchema = z.object({
+  bytes: z.number(),
+  formatted: z.string(),
+});
+
+export const dirSizeTool = {
+  name: "dir_size",
+  description: "Get the total size of files in a directory.",
+  group: "dir",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const path = input.path ?? "/";
+    const items = await listContextItemsByPrefix(ctx.conn, path, {
+      recursive: input.recursive !== false,
+    });
+
+    let bytes = 0;
+    for (const item of items) {
+      if (item.content != null) bytes += item.content.length;
+    }
+
+    return { bytes, formatted: formatBytes(bytes) };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;