botholomew 0.7.1 → 0.7.2

package/README.md

@@ -125,6 +125,7 @@ Everything the agent can touch is here. No surprises.
 | `botholomew skill list\|show\|create` | Manage slash-command skills |
 | `botholomew file\|dir\|search ...` | Direct access to the agent's virtual filesystem |
 | `botholomew thread list\|view` | Browse the agent's interaction history |
+| `botholomew nuke context\|tasks\|schedules\|threads\|all` | Bulk-erase sections of the database |
 | `botholomew upgrade` | Self-update |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {

package/src/chat/agent.ts

@@ -5,10 +5,16 @@ import type {
   ToolUseBlock,
 } from "@anthropic-ai/sdk/resources/messages";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import { embedSingle } from "../context/embedder.ts";
 import { fitToContextWindow, getMaxInputTokens } from "../daemon/context.ts";
 import { maybeStoreResult } from "../daemon/large-results.ts";
-import { buildMetaHeader, loadPersistentContext } from "../daemon/prompt.ts";
+import {
+  buildMetaHeader,
+  extractKeywords,
+  loadPersistentContext,
+} from "../daemon/prompt.ts";
 import type { DbConnection } from "../db/connection.ts";
+import { hybridSearch } from "../db/embeddings.ts";
 import { logInteraction } from "../db/threads.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import {
@@ -17,6 +23,7 @@ import {
   type ToolContext,
   toAnthropicTool,
 } from "../tools/tool.ts";
+import { logger } from "../utils/logger.ts";
 
 registerAllTools();
 
@@ -49,11 +56,44 @@ export function getChatTools() {
 
 export async function buildChatSystemPrompt(
   projectDir: string,
+  options?: {
+    keywordSource?: string;
+    conn?: DbConnection;
+    config?: Required<BotholomewConfig>;
+  },
 ): Promise<string> {
   const parts: string[] = [];
 
   parts.push(...buildMetaHeader(projectDir));
-  parts.push(...(await loadPersistentContext(projectDir)));
+
+  const keywordSource = options?.keywordSource?.trim();
+  const taskKeywords = keywordSource ? extractKeywords(keywordSource) : null;
+
+  parts.push(...(await loadPersistentContext(projectDir, taskKeywords)));
+
+  // Relevant context from embeddings search
+  const conn = options?.conn;
+  const config = options?.config;
+  if (conn && config?.openai_api_key && keywordSource) {
+    try {
+      const queryVec = await embedSingle(keywordSource, config);
+      const results = await hybridSearch(conn, keywordSource, queryVec, 5);
+
+      if (results.length > 0) {
+        parts.push("## Relevant Context");
+        for (const r of results) {
+          const path = r.source_path || r.context_item_id;
+          parts.push(`### ${r.title} (${path})`);
+          if (r.chunk_content) {
+            parts.push(r.chunk_content.slice(0, 1000));
+          }
+          parts.push("");
+        }
+      }
+    } catch (err) {
+      logger.debug(`Failed to load contextual embeddings: ${err}`);
+    }
+  }
 
   parts.push("## Instructions");
   parts.push(
@@ -95,6 +135,20 @@ export interface ChatTurnCallbacks {
   ) => void;
 }
 
+/**
+ * Walk messages backward to find the most recent human-authored user message.
+ * After tool turns, `messages[messages.length - 1]` is a user entry whose
+ * content is a `ToolResultBlockParam[]` — we want the string content from the
+ * actual user, not tool output, as the keyword source.
+ */
+function findLastUserText(messages: MessageParam[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role === "user" && typeof m.content === "string") return m.content;
+  }
+  return "";
+}
+
 /**
  * Run a single chat turn: stream the assistant response, execute any tool calls,
  * and loop until the model produces end_turn with no tool calls.
@@ -102,14 +156,14 @@ export interface ChatTurnCallbacks {
  */
 export async function runChatTurn(input: {
   messages: MessageParam[];
-  systemPrompt: string;
+  projectDir: string;
   config: Required<BotholomewConfig>;
   conn: DbConnection;
   threadId: string;
   toolCtx: ToolContext;
   callbacks: ChatTurnCallbacks;
 }): Promise<void> {
-  const { messages, systemPrompt, config, conn, threadId, toolCtx, callbacks } =
+  const { messages, projectDir, config, conn, threadId, toolCtx, callbacks } =
     input;
 
   const client = new Anthropic({
@@ -126,6 +180,18 @@ export async function runChatTurn(input: {
   for (let turn = 0; !maxTurns || turn < maxTurns; turn++) {
     const startTime = Date.now();
 
+    // Rebuild the system prompt every iteration so that:
+    //   (1) `loading: contextual` files get matched against the latest user
+    //       message, and
+    //   (2) any update_beliefs / update_goals tool call in the previous
+    //       iteration is reflected in the next LLM call.
+    const keywordSource = findLastUserText(messages);
+    const systemPrompt = await buildChatSystemPrompt(projectDir, {
+      keywordSource,
+      conn,
+      config,
+    });
+
     fitToContextWindow(messages, systemPrompt, maxInputTokens);
     const stream = client.messages.stream({
       model: config.model,

package/src/chat/session.ts

@@ -17,11 +17,7 @@ import { loadSkills } from "../skills/loader.ts";
 import type { SkillDefinition } from "../skills/parser.ts";
 import type { ToolContext } from "../tools/tool.ts";
 import { generateThreadTitle } from "../utils/title.ts";
-import {
-  buildChatSystemPrompt,
-  type ChatTurnCallbacks,
-  runChatTurn,
-} from "./agent.ts";
+import { type ChatTurnCallbacks, runChatTurn } from "./agent.ts";
 
 export interface ChatSession {
   conn: DbConnection;
@@ -29,7 +25,6 @@ export interface ChatSession {
   projectDir: string;
   config: Required<BotholomewConfig>;
   messages: MessageParam[];
-  systemPrompt: string;
   toolCtx: ToolContext;
   skills: Map<string, SkillDefinition>;
   cleanup: () => Promise<void>;
@@ -83,8 +78,6 @@ export async function startChatSession(
     threadId = await createThread(conn, "chat_session", undefined, "New chat");
   }
 
-  const systemPrompt = await buildChatSystemPrompt(projectDir);
-
   const mcpxClient = await createMcpxClient(projectDir);
   const skills = await loadSkills(projectDir);
 
@@ -105,7 +98,6 @@ export async function startChatSession(
     projectDir,
     config,
     messages,
-    systemPrompt,
     toolCtx,
     skills,
     cleanup,
@@ -138,7 +130,7 @@ export async function sendMessage(
 
   await runChatTurn({
     messages: session.messages,
-    systemPrompt: session.systemPrompt,
+    projectDir: session.projectDir,
     config: session.config,
     conn: session.conn,
     threadId: session.threadId,

package/src/cli.ts

@@ -8,6 +8,7 @@ import { registerContextCommand } from "./commands/context.ts";
 import { registerDaemonCommand } from "./commands/daemon.ts";
 import { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
+import { registerNukeCommand } from "./commands/nuke.ts";
 import { registerPrepareCommand } from "./commands/prepare.ts";
 import { registerScheduleCommand } from "./commands/schedule.ts";
 import { registerSkillCommand } from "./commands/skill.ts";
@@ -40,6 +41,7 @@ registerChatCommand(program);
 registerContextCommand(program);
 registerMcpxCommand(program);
 registerSkillCommand(program);
+registerNukeCommand(program);
 registerPrepareCommand(program);
 registerCheckUpdateCommand(program);
 registerUpgradeCommand(program);

package/src/commands/nuke.ts

@@ -0,0 +1,149 @@
+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 { logger } from "../utils/logger.ts";
+import { getDaemonStatus } from "../utils/pid.ts";
+import { withDb } from "./with-db.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 ensureDaemonStopped(dir: string): Promise<boolean> {
+  const status = await getDaemonStatus(dir);
+  if (status) {
+    logger.error(
+      `Daemon is running (PID ${status.pid}). Stop it first: botholomew daemon stop`,
+    );
+    return false;
+  }
+  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.
+  if (scope === "context" || scope === "all") {
+    const { contextItems, embeddings } = await deleteAllContextItems(conn);
+    logger.success(
+      `Deleted ${contextItems} context_items, ${embeddings} embeddings`,
+    );
+  }
+  if (scope === "tasks" || scope === "all") {
+    const n = await deleteAllTasks(conn);
+    logger.success(`Deleted ${n} tasks`);
+  }
+  if (scope === "schedules" || scope === "all") {
+    const n = await deleteAllSchedules(conn);
+    logger.success(`Deleted ${n} schedules`);
+  }
+  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`);
+  }
+}
+
+function registerScope(
+  program: Command,
+  parent: Command,
+  scope: NukeScope,
+  description: string,
+) {
+  parent
+    .command(scope)
+    .description(description)
+    .option("-y, --yes", "confirm the deletion (required)")
+    .action((opts) =>
+      withDb(program, async (conn, dir) => {
+        if (!(await ensureDaemonStopped(dir))) {
+          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);
+        }
+
+        if (!opts.yes) {
+          printDryRun(scope, counts);
+          process.exit(1);
+        }
+
+        await runNuke(conn, scope);
+      }),
+    );
+}
+
+export function registerNukeCommand(program: Command) {
+  const nuke = program
+    .command("nuke")
+    .description("Bulk-erase sections of the database");
+
+  registerScope(
+    program,
+    nuke,
+    "context",
+    "Erase all context_items and embeddings",
+  );
+  registerScope(program, nuke, "tasks", "Erase all tasks");
+  registerScope(program, nuke, "schedules", "Erase all schedules");
+  registerScope(
+    program,
+    nuke,
+    "threads",
+    "Erase all threads and interactions (daemon + chat history)",
+  );
+  registerScope(
+    program,
+    nuke,
+    "all",
+    "Erase everything in the database (preserves schema, skills, and on-disk soul/beliefs/goals)",
+  );
+}

package/src/commands/skill.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import ansis from "ansis";
 import type { Command } from "commander";
 import { getSkillsDir } from "../constants.ts";
@@ -24,6 +24,67 @@ export function registerSkillCommand(program: Command) {
       }
     });
 
+  skill
+    .command("list")
+    .description("List all skills loaded from .botholomew/skills/")
+    .action(async () => {
+      const dir = program.opts().dir;
+      const skills = await loadSkills(dir);
+
+      if (skills.size === 0) {
+        logger.dim("No skill files found.");
+        return;
+      }
+
+      const sorted = [...skills.values()].sort((a, b) =>
+        a.name.localeCompare(b.name),
+      );
+
+      const header = `${ansis.bold("Name".padEnd(20))} ${ansis.bold("Description".padEnd(40))} ${ansis.bold("Args".padEnd(20))} ${ansis.bold("Path")}`;
+      console.log(header);
+      console.log("-".repeat(header.length));
+
+      for (const s of sorted) {
+        const name = s.name.padEnd(20);
+        const desc = s.description
+          ? s.description.slice(0, 39).padEnd(40)
+          : ansis.dim("(no description)".padEnd(40));
+        const args =
+          s.arguments.length > 0
+            ? s.arguments
+                .map((a) => a.name)
+                .join(",")
+                .slice(0, 19)
+                .padEnd(20)
+            : ansis.dim("none".padEnd(20));
+        const path = relative(dir, s.filePath);
+        console.log(`${name} ${desc} ${args} ${path}`);
+      }
+
+      console.log(`\n${ansis.dim(`${sorted.length} skill(s)`)}`);
+    });
+
+  skill
+    .command("show <name>")
+    .description("Print the raw contents of a skill file")
+    .action(async (name: string) => {
+      const dir = program.opts().dir;
+      const skills = await loadSkills(dir);
+      const s = skills.get(name.toLowerCase());
+
+      if (!s) {
+        logger.error(`Skill not found: ${name}`);
+        if (skills.size > 0) {
+          const available = [...skills.keys()].sort().join(", ");
+          console.error(ansis.dim(`Available: ${available}`));
+        }
+        process.exit(1);
+      }
+
+      const raw = await Bun.file(s.filePath).text();
+      process.stdout.write(raw);
+    });
+
   skill
     .command("create <name>")
     .description("Create a new skill file from a template")

package/src/daemon/prompt.ts

@@ -13,6 +13,21 @@ const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
 ).json();
 
+/**
+ * Extract keyword set from free-form text: lowercase, split on whitespace,
+ * keep words longer than 3 chars. Used to match `loading: contextual` files
+ * against the agent's current intent (task text for the daemon, latest user
+ * message for the chat).
+ */
+export function extractKeywords(text: string): Set<string> {
+  return new Set(
+    text
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 3),
+  );
+}
+
 /**
  * Load persistent context files from .botholomew/ directory.
  * Returns an array of formatted string sections for "always" loaded files.
@@ -85,12 +100,7 @@ export async function buildSystemPrompt(
 
   // Build keyword set from task for contextual loading
   const taskKeywords = task
-    ? new Set(
-        `${task.name} ${task.description}`
-          .toLowerCase()
-          .split(/\s+/)
-          .filter((w) => w.length > 3),
-      )
+    ? extractKeywords(`${task.name} ${task.description}`)
     : null;
 
   // Load context files from .botholomew/

package/src/db/context.ts

@@ -428,6 +428,17 @@ export async function deleteContextItemByPath(
   return deleteContextItem(db, item.id);
 }
 
+export async function deleteAllContextItems(
+  db: DbConnection,
+): Promise<{ contextItems: number; embeddings: number }> {
+  const embeddings = await db.queryRun("DELETE FROM embeddings");
+  const contextItems = await db.queryRun("DELETE FROM context_items");
+  return {
+    contextItems: contextItems.changes,
+    embeddings: embeddings.changes,
+  };
+}
+
 export async function deleteContextItemsByPrefix(
   db: DbConnection,
   prefix: string,

package/src/db/daemon-state.ts

@@ -0,0 +1,6 @@
+import type { DbConnection } from "./connection.ts";
+
+export async function deleteAllDaemonState(db: DbConnection): Promise<number> {
+  const result = await db.queryRun("DELETE FROM daemon_state");
+  return result.changes;
+}

package/src/db/schedules.ts

@@ -127,6 +127,11 @@ export async function deleteSchedule(
   return result.changes > 0;
 }
 
+export async function deleteAllSchedules(db: DbConnection): Promise<number> {
+  const result = await db.queryRun("DELETE FROM schedules");
+  return result.changes;
+}
+
 export async function markScheduleRun(
   db: DbConnection,
   id: string,

package/src/db/tasks.ts

@@ -229,6 +229,11 @@ export async function deleteTask(
   return result.changes > 0;
 }
 
+export async function deleteAllTasks(db: DbConnection): Promise<number> {
+  const result = await db.queryRun("DELETE FROM tasks");
+  return result.changes;
+}
+
 export async function resetTask(
   db: DbConnection,
   id: string,

package/src/db/threads.ts

@@ -205,6 +205,17 @@ export async function deleteThread(
   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,