botholomew 0.12.5 → 0.14.0

package/src/commands/task.ts

@@ -1,16 +1,15 @@
 import ansis from "ansis";
 import type { Command } from "commander";
-import type { Task } from "../db/tasks.ts";
+import type { Task } from "../tasks/schema.ts";
 import {
   createTask,
   deleteTask,
   getTask,
   listTasks,
-  resetTask,
   updateTask,
-} from "../db/tasks.ts";
+  updateTaskStatus,
+} from "../tasks/store.ts";
 import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
 
 export function registerTaskCommand(program: Command) {
   const task = program.command("task").description("Manage tasks");
@@ -22,61 +21,58 @@ export function registerTaskCommand(program: Command) {
     .option("-p, --priority <priority>", "filter by priority")
     .option("-l, --limit <n>", "max number of tasks", Number.parseInt)
     .option("-o, --offset <n>", "skip first N tasks", Number.parseInt)
-    .action((opts) =>
-      withDb(program, async (conn) => {
-        const tasks = await listTasks(conn, {
-          status: opts.status,
-          priority: opts.priority,
-          limit: opts.limit,
-          offset: opts.offset,
-        });
-
-        if (tasks.length === 0) {
-          logger.dim("No tasks found.");
-          return;
-        }
-
-        const header = `${ansis.bold("ID".padEnd(36))}  ${ansis.bold("Status".padEnd(11))}  ${ansis.bold("Priority".padEnd(6))}  ${ansis.bold("Created".padEnd(19))}  ${ansis.bold("Updated".padEnd(19))}  ${ansis.bold("Name")}`;
-        console.log(header);
-        console.log("-".repeat(120));
-
-        for (const t of tasks) {
-          printTask(t);
-        }
-
-        console.log(`\n${ansis.dim(`${tasks.length} task(s)`)}`);
-      }),
-    );
+    .action(async (opts) => {
+      const dir = program.opts().dir;
+      const tasks = await listTasks(dir, {
+        status: opts.status,
+        priority: opts.priority,
+        limit: opts.limit,
+        offset: opts.offset,
+      });
+
+      if (tasks.length === 0) {
+        logger.dim("No tasks found.");
+        return;
+      }
+
+      const header = `${ansis.bold("ID".padEnd(36))}  ${ansis.bold("Status".padEnd(11))}  ${ansis.bold("Priority".padEnd(6))}  ${ansis.bold("Created".padEnd(19))}  ${ansis.bold("Updated".padEnd(19))}  ${ansis.bold("Name")}`;
+      console.log(header);
+      console.log("-".repeat(120));
+
+      for (const t of tasks) {
+        printTask(t);
+      }
+
+      console.log(`\n${ansis.dim(`${tasks.length} task(s)`)}`);
+    });
 
   task
     .command("add <name>")
     .description("Create a new task")
     .option("--description <text>", "task description", "")
     .option("-p, --priority <priority>", "low, medium, or high", "medium")
-    .action((name, opts) =>
-      withDb(program, async (conn) => {
-        const t = await createTask(conn, {
-          name,
-          description: opts.description,
-          priority: opts.priority,
-        });
-        logger.success(`Created task: ${t.name} (${t.id})`);
-      }),
-    );
+    .action(async (name, opts) => {
+      const dir = program.opts().dir;
+      const t = await createTask(dir, {
+        name,
+        description: opts.description,
+        priority: opts.priority,
+      });
+      logger.success(`Created task: ${t.name} (${t.id})`);
+    });
 
   task
     .command("view <id>")
     .description("View task details")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const t = await getTask(conn, id);
-        if (!t) {
-          logger.error(`Task not found: ${id}`);
-          process.exit(1);
-        }
-        printTaskDetail(t);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const t = await getTask(dir, id);
+      if (!t) {
+        logger.error(`Task not found: ${id}`);
+        process.exit(1);
+      }
+      printTaskDetail(t);
+    });
 
   task
     .command("update <id>")
@@ -85,55 +81,53 @@ export function registerTaskCommand(program: Command) {
     .option("--description <text>", "new description")
     .option("-p, --priority <priority>", "low, medium, or high")
     .option("-s, --status <status>", "new status")
-    .action((id, opts) =>
-      withDb(program, async (conn) => {
-        const updates: Parameters<typeof updateTask>[2] = {};
-        if (opts.name) updates.name = opts.name;
-        if (opts.description) updates.description = opts.description;
-        if (opts.priority) updates.priority = opts.priority;
-        if (opts.status) updates.status = opts.status;
-
-        try {
-          const t = await updateTask(conn, id, updates);
-          if (!t) {
-            logger.error(`Task not found: ${id}`);
-            process.exit(1);
-          }
-          printTaskDetail(t);
-        } catch (err) {
-          logger.error(String(err));
+    .action(async (id, opts) => {
+      const dir = program.opts().dir;
+      const updates: Parameters<typeof updateTask>[2] = {};
+      if (opts.name) updates.name = opts.name;
+      if (opts.description) updates.description = opts.description;
+      if (opts.priority) updates.priority = opts.priority;
+      if (opts.status) updates.status = opts.status;
+
+      try {
+        const t = await updateTask(dir, id, updates);
+        if (!t) {
+          logger.error(`Task not found: ${id}`);
           process.exit(1);
         }
-      }),
-    );
+        printTaskDetail(t);
+      } catch (err) {
+        logger.error(String(err));
+        process.exit(1);
+      }
+    });
 
   task
     .command("delete <id>")
     .description("Delete a task")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const deleted = await deleteTask(conn, id);
-        if (!deleted) {
-          logger.error(`Task not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Deleted task: ${id}`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const deleted = await deleteTask(dir, id);
+      if (!deleted) {
+        logger.error(`Task not found: ${id}`);
+        process.exit(1);
+      }
+      logger.success(`Deleted task: ${id}`);
+    });
 
   task
     .command("reset <id>")
     .description("Reset a stuck task back to pending")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const t = await resetTask(conn, id);
-        if (!t) {
-          logger.error(`Task not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Reset task: ${t.name} (${t.id})`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const t = await getTask(dir, id);
+      if (!t) {
+        logger.error(`Task not found: ${id}`);
+        process.exit(1);
+      }
+      await updateTaskStatus(dir, id, "pending", null, null);
+      logger.success(`Reset task: ${t.name} (${t.id})`);
+    });
 }
 
 function statusColor(status: Task["status"]): string {
@@ -162,11 +156,8 @@ function priorityColor(priority: Task["priority"]): string {
   }
 }
 
-function formatTime(date: Date): string {
-  return date
-    .toISOString()
-    .replace("T", " ")
-    .replace(/\.\d{3}Z$/, "");
+function formatTime(iso: string): string {
+  return iso.replace("T", " ").replace(/\.\d{3}Z$/, "");
 }
 
 function padColored(colored: string, raw: string, width: number): string {
@@ -196,6 +187,6 @@ function printTaskDetail(t: Task) {
   if (t.claimed_by) console.log(`  Claimed by:  ${t.claimed_by}`);
   if (t.blocked_by.length > 0)
     console.log(`  Blocked by:  ${t.blocked_by.join(", ")}`);
-  console.log(`  Created:     ${t.created_at.toISOString()}`);
-  console.log(`  Updated:     ${t.updated_at.toISOString()}`);
+  console.log(`  Created:     ${t.created_at}`);
+  console.log(`  Updated:     ${t.updated_at}`);
 }

package/src/commands/thread.ts

@@ -1,16 +1,16 @@
 import ansis from "ansis";
 import type { Command } from "commander";
-import type { Interaction, Thread } from "../db/threads.ts";
 import {
   deleteThread,
   getActiveThread,
   getInteractionsAfter,
   getThread,
+  type Interaction,
   isThreadEnded,
   listThreads,
-} from "../db/threads.ts";
+  type Thread,
+} from "../threads/store.ts";
 import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
 
 export function registerThreadCommand(program: Command) {
   const thread = program.command("thread").description("Manage chat threads");
@@ -21,24 +21,23 @@ export function registerThreadCommand(program: Command) {
     .option("-t, --type <type>", "filter by type (worker_tick, chat_session)")
     .option("-l, --limit <n>", "max number of threads", Number.parseInt)
     .option("-o, --offset <n>", "skip first N threads", Number.parseInt)
-    .action((opts) =>
-      withDb(program, async (conn) => {
-        const threads = await listThreads(conn, {
-          type: opts.type,
-          limit: opts.limit,
-          offset: opts.offset,
-        });
-
-        if (threads.length === 0) {
-          logger.dim("No threads found.");
-          return;
-        }
-
-        for (const t of threads) {
-          printThread(t);
-        }
-      }),
-    );
+    .action(async (opts) => {
+      const dir = program.opts().dir;
+      const threads = await listThreads(dir, {
+        type: opts.type,
+        limit: opts.limit,
+        offset: opts.offset,
+      });
+
+      if (threads.length === 0) {
+        logger.dim("No threads found.");
+        return;
+      }
+
+      for (const t of threads) {
+        printThread(t);
+      }
+    });
 
   thread
     .command("view <id>")
@@ -47,111 +46,107 @@ export function registerThreadCommand(program: Command) {
       "--only <roles>",
       "show only these roles (comma-separated: user,assistant,tool,system)",
     )
-    .action((id, opts) =>
-      withDb(program, async (conn) => {
-        const result = await getThread(conn, id);
-        if (!result) {
-          logger.error(`Thread not found: ${id}`);
-          process.exit(1);
-        }
-        const interactions = opts.only
-          ? result.interactions.filter((i) =>
-              (opts.only as string).split(",").includes(i.role),
-            )
-          : result.interactions;
-        printThreadDetail(result.thread, interactions);
-      }),
-    );
+    .action(async (id, opts) => {
+      const dir = program.opts().dir;
+      const result = await getThread(dir, id);
+      if (!result) {
+        logger.error(`Thread not found: ${id}`);
+        process.exit(1);
+      }
+      const interactions = opts.only
+        ? result.interactions.filter((i) =>
+            (opts.only as string).split(",").includes(i.role),
+          )
+        : result.interactions;
+      printThreadDetail(result.thread, interactions);
+    });
 
   thread
     .command("delete <id>")
     .description("Delete a thread and its interactions")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const deleted = await deleteThread(conn, id);
-        if (!deleted) {
-          logger.error(`Thread not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Deleted thread: ${id}`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const deleted = await deleteThread(dir, id);
+      if (!deleted) {
+        logger.error(`Thread not found: ${id}`);
+        process.exit(1);
+      }
+      logger.success(`Deleted thread: ${id}`);
+    });
 
   thread
     .command("follow [id]")
     .description("Follow a thread live (like tail -f)")
     .option("-i, --interval <ms>", "poll interval in ms", parseInt)
-    .action((id, opts) =>
-      withDb(program, async (conn) => {
-        let resolvedId: string;
-        if (id) {
-          resolvedId = id;
-        } else {
-          const active = await getActiveThread(conn);
-          if (!active) {
-            logger.error("No active thread found.");
-            process.exit(1);
-          }
-          resolvedId = active.id;
-        }
-
-        const result = await getThread(conn, resolvedId);
-        if (!result) {
-          logger.error(`Thread not found: ${resolvedId}`);
+    .action(async (id, opts) => {
+      const dir = program.opts().dir;
+      let resolvedId: string;
+      if (id) {
+        resolvedId = id;
+      } else {
+        const active = await getActiveThread(dir);
+        if (!active) {
+          logger.error("No active thread found.");
           process.exit(1);
         }
+        resolvedId = active.id;
+      }
+
+      const result = await getThread(dir, resolvedId);
+      if (!result) {
+        logger.error(`Thread not found: ${resolvedId}`);
+        process.exit(1);
+      }
+
+      printThreadDetail(result.thread, result.interactions);
+
+      if (result.thread.ended_at) {
+        logger.dim("Thread already ended.");
+        return;
+      }
+
+      let lastSequence =
+        result.interactions.length > 0
+          ? (result.interactions[result.interactions.length - 1]?.sequence ?? 0)
+          : 0;
+
+      const pollMs = opts.interval ?? 500;
+      logger.info(
+        `Following thread ${ansis.dim(resolvedId)}... (Ctrl+C to stop)`,
+      );
+
+      const interval = setInterval(async () => {
+        try {
+          const newInteractions = await getInteractionsAfter(
+            dir,
+            resolvedId,
+            lastSequence,
+          );
+          for (const i of newInteractions) {
+            printInteraction(i);
+            lastSequence = i.sequence;
+          }
 
-        printThreadDetail(result.thread, result.interactions);
-
-        if (result.thread.ended_at) {
-          logger.dim("Thread already ended.");
-          return;
+          const ended = await isThreadEnded(dir, resolvedId);
+          if (ended) {
+            logger.dim("Thread ended.");
+            clearInterval(interval);
+            process.exit(0);
+          }
+        } catch {
+          // Transient FS errors — retry next tick
         }
+      }, pollMs);
 
-        let lastSequence =
-          result.interactions.length > 0
-            ? (result.interactions[result.interactions.length - 1]?.sequence ??
-              0)
-            : 0;
-
-        const pollMs = opts.interval ?? 500;
-        logger.info(
-          `Following thread ${ansis.dim(resolvedId)}... (Ctrl+C to stop)`,
-        );
-
-        const interval = setInterval(async () => {
-          try {
-            const newInteractions = await getInteractionsAfter(
-              conn,
-              resolvedId,
-              lastSequence,
-            );
-            for (const i of newInteractions) {
-              printInteraction(i);
-              lastSequence = i.sequence;
-            }
-
-            const ended = await isThreadEnded(conn, resolvedId);
-            if (ended) {
-              logger.dim("Thread ended.");
-              clearInterval(interval);
-              process.exit(0);
-            }
-          } catch {
-            // Transient DB errors (e.g. SQLITE_BUSY) — retry next tick
-          }
-        }, pollMs);
-
-        process.on("SIGINT", () => {
-          clearInterval(interval);
-          console.log();
-          process.exit(0);
-        });
-
-        // Keep the process alive
-        await new Promise(() => {});
-      }),
-    );
+      process.on("SIGINT", () => {
+        clearInterval(interval);
+        console.log();
+        process.exit(0);
+      });
+
+      // Keep the process alive
+      await new Promise(() => {});
+    });
 }
 
 function typeColor(type: Thread["type"]): string {