botholomew 0.12.5 → 0.13.0

package/src/commands/db.ts

@@ -1,15 +1,14 @@
 import ansis from "ansis";
 import type { Command } from "commander";
 import { getDbPath } from "../constants.ts";
-import { withDb as coreWithDb } from "../db/connection.ts";
 import {
   isPidAlive,
   type ProbeResult,
   probeAllTables,
   repairDatabase,
 } from "../db/doctor.ts";
-import { listWorkers, type Worker } from "../db/workers.ts";
 import { logger } from "../utils/logger.ts";
+import { listWorkers, type Worker } from "../workers/store.ts";
 
 function statusBadge(status: ProbeResult["status"]): string {
   switch (status) {
@@ -81,17 +80,14 @@ async function doctor(program: Command, repair: boolean): Promise<void> {
 
   // Repair requires exclusive access — refuse if any worker is actually
   // running, otherwise the EXPORT would race with the worker's writes.
-  // Stale `status='running'` rows whose PID is dead (the exact case that
-  // tends to coexist with workers-table corruption) are reported but do
-  // not block repair: trying to flip them to `stopped` would just trip
-  // the same corruption we're about to fix.
-  const running = await coreWithDb(dbPath, async (conn) => {
-    try {
-      return await listWorkers(conn, { status: "running" });
-    } catch {
-      return [] as Worker[];
-    }
-  });
+  // Stale 'running' worker JSON files whose PID is dead are reported but
+  // don't block repair.
+  let running: Worker[];
+  try {
+    running = await listWorkers(dir, { status: "running" });
+  } catch {
+    running = [];
+  }
   const live = running.filter((w) => isPidAlive(w.pid));
   const stale = running.filter((w) => !isPidAlive(w.pid));
   if (live.length > 0) {

package/src/commands/init.ts

@@ -6,7 +6,10 @@ export function registerInitCommand(program: Command) {
   program
     .command("init")
     .description("Initialize a new Botholomew project in the current directory")
-    .option("--force", "overwrite existing .botholomew directory")
+    .option(
+      "--force",
+      "overwrite existing project files; also bypass the unsupported-filesystem check (iCloud/Dropbox/etc)",
+    )
     .action(async (opts) => {
       const dir = program.opts().dir;
       try {

package/src/commands/nuke.ts

@@ -1,56 +1,23 @@
+import { rm } from "node:fs/promises";
 import ansis from "ansis";
 import type { Command } from "commander";
-import type { DbConnection } from "../db/connection.ts";
-import { deleteAllContextItems } from "../db/context.ts";
-import { deleteAllDaemonState } from "../db/daemon-state.ts";
-import { deleteAllSchedules } from "../db/schedules.ts";
-import { deleteAllTasks } from "../db/tasks.ts";
-import { deleteAllThreads } from "../db/threads.ts";
-import { listWorkers } from "../db/workers.ts";
+import {
+  CONTEXT_DIR,
+  getContextDir,
+  SCHEDULES_DIR,
+  TASKS_DIR,
+  THREADS_DIR,
+} from "../constants.ts";
+import { deleteAllSchedules } from "../schedules/store.ts";
+import { deleteAllTasks } from "../tasks/store.ts";
+import { deleteAllThreads } from "../threads/store.ts";
 import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
+import { listWorkers } from "../workers/store.ts";
 
 type NukeScope = "context" | "tasks" | "schedules" | "threads" | "all";
 
-const TABLES_BY_SCOPE: Record<NukeScope, string[]> = {
-  context: ["context_items", "embeddings"],
-  tasks: ["tasks"],
-  schedules: ["schedules"],
-  threads: ["threads", "interactions"],
-  all: [
-    "context_items",
-    "embeddings",
-    "tasks",
-    "schedules",
-    "threads",
-    "interactions",
-    "daemon_state",
-  ],
-};
-
-async function countRows(conn: DbConnection, table: string): Promise<number> {
-  const row = await conn.queryGet<{ cnt: number }>(
-    `SELECT COUNT(*) AS cnt FROM ${table}`,
-  );
-  return row ? Number(row.cnt) : 0;
-}
-
-function printDryRun(scope: NukeScope, counts: Record<string, number>) {
-  console.log(ansis.red.bold(`Nuke scope: ${scope}`));
-  console.log("Would delete:");
-  const nameWidth = Math.max(...Object.keys(counts).map((k) => k.length));
-  for (const [table, count] of Object.entries(counts)) {
-    const padded = table.padEnd(nameWidth + 2);
-    console.log(`  ${padded}${ansis.dim(`${count} rows`)}`);
-  }
-  console.log("");
-  console.log(
-    ansis.yellow("Re-run with --yes to confirm. This cannot be undone."),
-  );
-}
-
-async function ensureNoRunningWorkers(conn: DbConnection): Promise<boolean> {
-  const running = await listWorkers(conn, { status: "running" });
+async function ensureNoRunningWorkers(projectDir: string): Promise<boolean> {
+  const running = await listWorkers(projectDir, { status: "running" });
   if (running.length > 0) {
     logger.error(
       `${running.length} worker(s) running. Stop them first: botholomew worker stop <id>`,
@@ -63,33 +30,24 @@ async function ensureNoRunningWorkers(conn: DbConnection): Promise<boolean> {
   return true;
 }
 
-async function runNuke(conn: DbConnection, scope: NukeScope): Promise<void> {
-  // Not wrapped in a transaction: DuckDB's FK index checks on DELETE FROM
-  // threads inside a transaction see stale interactions rows even after
-  // DELETE FROM interactions ran in the same transaction. Each helper is
-  // already a small sequence of statements, so auto-commit is fine for a
-  // destructive dev-time tool.
+async function runNuke(projectDir: string, scope: NukeScope): Promise<void> {
   if (scope === "context" || scope === "all") {
-    const { contextItems, embeddings } = await deleteAllContextItems(conn);
-    logger.success(
-      `Deleted ${contextItems} context_items, ${embeddings} embeddings`,
-    );
+    await rm(getContextDir(projectDir), { recursive: true, force: true });
+    logger.success(`Removed ${CONTEXT_DIR}/ directory`);
   }
   if (scope === "tasks" || scope === "all") {
-    const n = await deleteAllTasks(conn);
-    logger.success(`Deleted ${n} tasks`);
+    const n = await deleteAllTasks(projectDir);
+    logger.success(`Deleted ${n} task file(s) from ${TASKS_DIR}/`);
   }
   if (scope === "schedules" || scope === "all") {
-    const n = await deleteAllSchedules(conn);
-    logger.success(`Deleted ${n} schedules`);
+    const n = await deleteAllSchedules(projectDir);
+    logger.success(`Deleted ${n} schedule file(s) from ${SCHEDULES_DIR}/`);
   }
   if (scope === "threads" || scope === "all") {
-    const { threads, interactions } = await deleteAllThreads(conn);
-    logger.success(`Deleted ${threads} threads, ${interactions} interactions`);
-  }
-  if (scope === "all") {
-    const n = await deleteAllDaemonState(conn);
-    logger.success(`Deleted ${n} daemon_state entries`);
+    const { threads, interactions } = await deleteAllThreads(projectDir);
+    logger.success(
+      `Deleted ${threads} threads (${interactions} interactions) from ${THREADS_DIR}/`,
+    );
   }
 }
 
@@ -103,50 +61,59 @@ function registerScope(
     .command(scope)
     .description(description)
     .option("-y, --yes", "confirm the deletion (required)")
-    .action((opts) =>
-      withDb(program, async (conn) => {
-        if (!(await ensureNoRunningWorkers(conn))) {
-          process.exit(1);
-        }
-        const tables = TABLES_BY_SCOPE[scope];
-        const counts: Record<string, number> = {};
-        for (const t of tables) {
-          counts[t] = await countRows(conn, t);
-        }
+    .action(async (opts) => {
+      const dir = program.opts().dir;
+      if (!(await ensureNoRunningWorkers(dir))) {
+        process.exit(1);
+      }
 
-        if (!opts.yes) {
-          printDryRun(scope, counts);
-          process.exit(1);
-        }
+      if (!opts.yes) {
+        console.log(ansis.red.bold(`Nuke scope: ${scope}`));
+        console.log(
+          ansis.yellow(
+            `Re-run with --yes to confirm. This will delete files on disk; cannot be undone.`,
+          ),
+        );
+        process.exit(1);
+      }
 
-        await runNuke(conn, scope);
-      }),
-    );
+      await runNuke(dir, scope);
+    });
 }
 
 export function registerNukeCommand(program: Command) {
   const nuke = program
     .command("nuke")
-    .description("Bulk-erase sections of the database");
+    .description("Bulk-erase sections of the project");
 
   registerScope(
     program,
     nuke,
     "context",
-    "Erase all context_items and embeddings",
+    `Erase the entire ${CONTEXT_DIR}/ directory (user-curated knowledge)`,
+  );
+  registerScope(
+    program,
+    nuke,
+    "tasks",
+    `Delete all task files in ${TASKS_DIR}/`,
+  );
+  registerScope(
+    program,
+    nuke,
+    "schedules",
+    `Delete all schedule files in ${SCHEDULES_DIR}/`,
   );
-  registerScope(program, nuke, "tasks", "Erase all tasks");
-  registerScope(program, nuke, "schedules", "Erase all schedules");
   registerScope(
     program,
     nuke,
     "threads",
-    "Erase all threads and interactions (worker + chat history)",
+    `Delete all conversation history in ${THREADS_DIR}/`,
   );
   registerScope(
     program,
     nuke,
     "all",
-    "Erase everything in the database (preserves schema, skills, and on-disk soul/beliefs/goals)",
+    "Erase all agent-writable data: context/, tasks/, schedules/, threads/",
   );
 }

package/src/commands/schedule.ts

@@ -1,15 +1,15 @@
 import ansis from "ansis";
 import type { Command } from "commander";
-import type { Schedule } from "../db/schedules.ts";
+import type { Schedule } from "../schedules/schema.ts";
 import {
   createSchedule,
   deleteSchedule,
   getSchedule,
   listSchedules,
+  markScheduleRun,
   updateSchedule,
-} from "../db/schedules.ts";
+} from "../schedules/store.ts";
 import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
 
 export function registerScheduleCommand(program: Command) {
   const schedule = program.command("schedule").description("Manage schedules");
@@ -21,31 +21,22 @@ export function registerScheduleCommand(program: Command) {
     .option("--disabled", "show only disabled schedules")
     .option("-l, --limit <n>", "max number of schedules", Number.parseInt)
     .option("-o, --offset <n>", "skip first N schedules", Number.parseInt)
-    .action((opts) =>
-      withDb(program, async (conn) => {
-        const filters: {
-          enabled?: boolean;
-          limit?: number;
-          offset?: number;
-        } = {
-          limit: opts.limit,
-          offset: opts.offset,
-        };
-        if (opts.enabled) filters.enabled = true;
-        if (opts.disabled) filters.enabled = false;
-
-        const schedules = await listSchedules(conn, filters);
-
-        if (schedules.length === 0) {
-          logger.dim("No schedules found.");
-          return;
-        }
-
-        for (const s of schedules) {
-          printSchedule(s);
-        }
-      }),
-    );
+    .action(async (opts) => {
+      const dir = program.opts().dir;
+      const filters: { enabled?: boolean; limit?: number; offset?: number } = {
+        limit: opts.limit,
+        offset: opts.offset,
+      };
+      if (opts.enabled) filters.enabled = true;
+      if (opts.disabled) filters.enabled = false;
+
+      const schedules = await listSchedules(dir, filters);
+      if (schedules.length === 0) {
+        logger.dim("No schedules found.");
+        return;
+      }
+      for (const s of schedules) printSchedule(s);
+    });
 
   schedule
     .command("add <name>")
@@ -55,116 +46,108 @@ export function registerScheduleCommand(program: Command) {
       "how often to run (e.g. 'every morning')",
     )
     .option("--description <text>", "schedule description", "")
-    .action((name, opts) =>
-      withDb(program, async (conn) => {
-        const s = await createSchedule(conn, {
-          name,
-          description: opts.description,
-          frequency: opts.frequency,
-        });
-        logger.success(`Created schedule: ${s.name} (${s.id})`);
-      }),
-    );
+    .action(async (name, opts) => {
+      const dir = program.opts().dir;
+      const s = await createSchedule(dir, {
+        name,
+        description: opts.description,
+        frequency: opts.frequency,
+      });
+      logger.success(`Created schedule: ${s.name} (${s.id})`);
+    });
 
   schedule
     .command("view <id>")
     .description("View schedule details")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const s = await getSchedule(conn, id);
-        if (!s) {
-          logger.error(`Schedule not found: ${id}`);
-          process.exit(1);
-        }
-        printScheduleDetail(s);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const s = await getSchedule(dir, id);
+      if (!s) {
+        logger.error(`Schedule not found: ${id}`);
+        process.exit(1);
+      }
+      printScheduleDetail(s);
+    });
 
   schedule
     .command("enable <id>")
     .description("Enable a schedule")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const s = await updateSchedule(conn, id, { enabled: true });
-        if (!s) {
-          logger.error(`Schedule not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Enabled schedule: ${s.name}`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const s = await updateSchedule(dir, id, { enabled: true });
+      if (!s) {
+        logger.error(`Schedule not found: ${id}`);
+        process.exit(1);
+      }
+      logger.success(`Enabled schedule: ${s.name}`);
+    });
 
   schedule
     .command("disable <id>")
     .description("Disable a schedule")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const s = await updateSchedule(conn, id, { enabled: false });
-        if (!s) {
-          logger.error(`Schedule not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Disabled schedule: ${s.name}`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const s = await updateSchedule(dir, id, { enabled: false });
+      if (!s) {
+        logger.error(`Schedule not found: ${id}`);
+        process.exit(1);
+      }
+      logger.success(`Disabled schedule: ${s.name}`);
+    });
 
   schedule
     .command("delete <id>")
     .description("Delete a schedule")
-    .action((id) =>
-      withDb(program, async (conn) => {
-        const deleted = await deleteSchedule(conn, id);
-        if (!deleted) {
-          logger.error(`Schedule not found: ${id}`);
-          process.exit(1);
-        }
-        logger.success(`Deleted schedule: ${id}`);
-      }),
-    );
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const deleted = await deleteSchedule(dir, id);
+      if (!deleted) {
+        logger.error(`Schedule not found: ${id}`);
+        process.exit(1);
+      }
+      logger.success(`Deleted schedule: ${id}`);
+    });
 
   schedule
     .command("trigger <id>")
     .description("Manually trigger a schedule (creates tasks immediately)")
-    .action((id) =>
-      withDb(program, async (conn, dir) => {
-        const s = await getSchedule(conn, id);
-        if (!s) {
-          logger.error(`Schedule not found: ${id}`);
-          process.exit(1);
-        }
-
-        // Lazy import to avoid loading LLM deps for non-trigger commands
-        const { evaluateSchedule } = await import("../worker/schedules.ts");
-        const { loadConfig } = await import("../config/loader.ts");
-        const { createTask } = await import("../db/tasks.ts");
-        const { markScheduleRun } = await import("../db/schedules.ts");
-
-        const config = await loadConfig(dir);
-        const evaluation = await evaluateSchedule(config, s);
-
-        if (evaluation.tasksToCreate.length === 0) {
-          logger.dim("Schedule evaluated but produced no tasks.");
-        } else {
-          const createdIds: string[] = [];
-          for (const taskDef of evaluation.tasksToCreate) {
-            const blockedBy = (taskDef.depends_on ?? [])
-              .map((i: number) => createdIds[i])
-              .filter(Boolean) as string[];
-            const t = await createTask(conn, {
-              name: taskDef.name,
-              description: taskDef.description,
-              priority: taskDef.priority,
-              blocked_by: blockedBy,
-            });
-            createdIds.push(t.id);
-            logger.success(`Created task: ${t.name} (${t.id})`);
-          }
+    .action(async (id) => {
+      const dir = program.opts().dir;
+      const s = await getSchedule(dir, id);
+      if (!s) {
+        logger.error(`Schedule not found: ${id}`);
+        process.exit(1);
+      }
+
+      const { evaluateSchedule } = await import("../worker/schedules.ts");
+      const { loadConfig } = await import("../config/loader.ts");
+      const { createTask } = await import("../tasks/store.ts");
+
+      const config = await loadConfig(dir);
+      const evaluation = await evaluateSchedule(config, s);
+
+      if (evaluation.tasksToCreate.length === 0) {
+        logger.dim("Schedule evaluated but produced no tasks.");
+      } else {
+        const createdIds: string[] = [];
+        for (const taskDef of evaluation.tasksToCreate) {
+          const blockedBy = (taskDef.depends_on ?? [])
+            .map((i: number) => createdIds[i])
+            .filter(Boolean) as string[];
+          const t = await createTask(dir, {
+            name: taskDef.name,
+            description: taskDef.description,
+            priority: taskDef.priority,
+            blocked_by: blockedBy,
+          });
+          createdIds.push(t.id);
+          logger.success(`Created task: ${t.name} (${t.id})`);
         }
+      }
 
-        await markScheduleRun(conn, s.id);
-        logger.info(`Marked schedule "${s.name}" as run.`);
-      }),
-    );
+      await markScheduleRun(dir, s.id);
+      logger.info(`Marked schedule "${s.name}" as run.`);
+    });
 }
 
 function enabledColor(enabled: boolean): string {
@@ -173,9 +156,7 @@ function enabledColor(enabled: boolean): string {
 
 function printSchedule(s: Schedule) {
   const id = ansis.dim(s.id);
-  const lastRun = s.last_run_at
-    ? s.last_run_at.toISOString()
-    : ansis.dim("never");
+  const lastRun = s.last_run_at ?? ansis.dim("never");
   console.log(
     `  ${id}  ${enabledColor(s.enabled)}  ${s.frequency}  ${s.name}  (last: ${lastRun})`,
   );
@@ -187,9 +168,7 @@ function printScheduleDetail(s: Schedule) {
   console.log(`  Status:      ${enabledColor(s.enabled)}`);
   console.log(`  Frequency:   ${s.frequency}`);
   if (s.description) console.log(`  Description: ${s.description}`);
-  console.log(
-    `  Last run:    ${s.last_run_at ? s.last_run_at.toISOString() : ansis.dim("never")}`,
-  );
-  console.log(`  Created:     ${s.created_at.toISOString()}`);
-  console.log(`  Updated:     ${s.updated_at.toISOString()}`);
+  console.log(`  Last run:    ${s.last_run_at ?? ansis.dim("never")}`);
+  console.log(`  Created:     ${s.created_at}`);
+  console.log(`  Updated:     ${s.updated_at}`);
 }

package/src/commands/skill.ts

@@ -13,7 +13,7 @@ export function registerSkillCommand(program: Command) {
 
   skill
     .command("validate [file]")
-    .description("Validate skill files in .botholomew/skills/")
+    .description("Validate skill files in skills/")
     .action(async (file?: string) => {
       const dir = program.opts().dir;
 
@@ -26,7 +26,7 @@ export function registerSkillCommand(program: Command) {
 
   skill
     .command("list")
-    .description("List all skills loaded from .botholomew/skills/")
+    .description("List all skills loaded from skills/")
     .option("-l, --limit <n>", "max number of skills", Number.parseInt)
     .option("-o, --offset <n>", "skip first N skills", Number.parseInt)
     .action(async (opts: { limit?: number; offset?: number }) => {