botholomew 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {
@@ -23,6 +23,9 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.88.0",
+    "@evantahler/mcpx": "0.18.3",
+    "@huggingface/transformers": "^4.0.1",
+    "@sqliteai/sqlite-vector": "^0.9.95",
     "ansis": "^4.2.0",
     "commander": "^14.0.0",
     "gray-matter": "^4.0.3",

package/src/cli.ts

@@ -8,6 +8,8 @@ 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 { registerPrepareCommand } from "./commands/prepare.ts";
+import { registerScheduleCommand } from "./commands/schedule.ts";
 import { registerTaskCommand } from "./commands/task.ts";
 import { registerToolCommands } from "./commands/tools.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
@@ -31,10 +33,12 @@ program
 registerInitCommand(program);
 registerDaemonCommand(program);
 registerTaskCommand(program);
+registerScheduleCommand(program);
 registerChatCommand(program);
 registerContextCommand(program);
 registerMcpxCommand(program);
 registerToolCommands(program);
+registerPrepareCommand(program);
 registerCheckUpdateCommand(program);
 registerUpgradeCommand(program);
 

package/src/commands/context.ts

@@ -1,5 +1,20 @@
+import { readdir, stat } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import ansis from "ansis";
 import type { Command } from "commander";
+import { isText } from "istextorbinary";
+import { loadConfig } from "../config/loader.ts";
+import { embedSingle, warmupEmbedder } from "../context/embedder.ts";
+import { ingestContextItem } from "../context/ingest.ts";
+import type { DbConnection } from "../db/connection.ts";
+import {
+  createContextItem,
+  listContextItems,
+  listContextItemsByPrefix,
+} from "../db/context.ts";
+import { hybridSearch, initVectorSearch } from "../db/embeddings.ts";
 import { logger } from "../utils/logger.ts";
+import { withDb } from "./with-db.ts";
 
 export function registerContextCommand(program: Command) {
   const ctx = program.command("context").description("Manage context items");
@@ -7,21 +22,160 @@ export function registerContextCommand(program: Command) {
   ctx
     .command("list")
     .description("List context items")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
-    });
+    .option("--path <prefix>", "filter by path prefix")
+    .option("-l, --limit <n>", "max number of items", Number.parseInt)
+    .action((opts) =>
+      withDb(program, async (conn) => {
+        const items = opts.path
+          ? await listContextItemsByPrefix(conn, opts.path, {
+              recursive: true,
+              limit: opts.limit,
+            })
+          : await listContextItems(conn, { limit: opts.limit });
+
+        if (items.length === 0) {
+          logger.dim("No context items found.");
+          return;
+        }
+
+        const header = `${ansis.bold("Path".padEnd(40))} ${"Title".padEnd(25)} ${"Type".padEnd(20)} Indexed`;
+        console.log(header);
+        console.log("-".repeat(header.length));
+
+        for (const item of items) {
+          const indexed = item.indexed_at
+            ? ansis.green("yes")
+            : ansis.dim("no");
+          console.log(
+            `${item.context_path.padEnd(40)} ${item.title.slice(0, 24).padEnd(25)} ${item.mime_type.slice(0, 19).padEnd(20)} ${indexed}`,
+          );
+        }
+
+        console.log(`\n${ansis.dim(`${items.length} item(s)`)}`);
+      }),
+    );
 
   ctx
     .command("add <path>")
     .description("Add a file or directory to context")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
-    });
+    .option("--prefix <prefix>", "virtual path prefix", "/")
+    .action((path, opts) =>
+      withDb(program, async (conn, dir) => {
+        const config = await loadConfig(dir);
+        await warmupEmbedder();
+
+        const resolvedPath = resolve(path);
+        const info = await stat(resolvedPath);
+
+        let added = 0;
+        let chunks = 0;
+
+        if (info.isDirectory()) {
+          const entries = await walkDirectory(resolvedPath);
+          for (const filePath of entries) {
+            const relativePath = filePath.slice(resolvedPath.length);
+            const contextPath = join(opts.prefix, relativePath);
+            const count = await addFile(conn, config, filePath, contextPath);
+            if (count >= 0) {
+              added++;
+              chunks += count;
+            }
+          }
+        } else {
+          const contextPath = join(opts.prefix, basename(resolvedPath));
+          const count = await addFile(conn, config, resolvedPath, contextPath);
+          if (count >= 0) {
+            added++;
+            chunks += count;
+          }
+        }
+
+        logger.success(`Added ${added} file(s), ${chunks} chunk(s) indexed.`);
+      }),
+    );
 
   ctx
     .command("search <query>")
     .description("Search context items")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
+    .option("-k, --top-k <n>", "max results", Number.parseInt, 10)
+    .action((query, opts) =>
+      withDb(program, async (conn) => {
+        await warmupEmbedder();
+        initVectorSearch(conn);
+        const queryVec = await embedSingle(query);
+        const results = hybridSearch(conn, query, queryVec, opts.topK);
+
+        if (results.length === 0) {
+          logger.dim("No results found.");
+          return;
+        }
+
+        for (const [i, r] of results.entries()) {
+          const score = (r.score * 100).toFixed(1);
+          console.log(
+            `${ansis.bold(`${i + 1}.`)} ${ansis.cyan(r.title)} ${ansis.dim(`(${score}%)`)}`,
+          );
+          console.log(`   ${ansis.dim(r.source_path || r.context_item_id)}`);
+          if (r.chunk_content) {
+            const snippet = r.chunk_content.slice(0, 120).replace(/\n/g, " ");
+            console.log(`   ${snippet}...`);
+          }
+          console.log("");
+        }
+      }),
+    );
+}
+
+async function addFile(
+  conn: DbConnection,
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  filePath: string,
+  contextPath: string,
+): Promise<number> {
+  try {
+    const bunFile = Bun.file(filePath);
+    const mimeType = bunFile.type.split(";")[0] || "application/octet-stream";
+    const filename = basename(filePath);
+    const textual = isText(filename) !== false;
+
+    const content = textual ? await bunFile.text() : null;
+
+    const item = await createContextItem(conn, {
+      title: filename,
+      content: content ?? undefined,
+      mimeType,
+      sourcePath: filePath,
+      contextPath,
+      isTextual: textual,
     });
+
+    if (textual && content) {
+      const count = await ingestContextItem(conn, item.id, config);
+      console.log(`  + ${contextPath} (${count} chunks)`);
+      return count;
+    }
+
+    console.log(`  + ${contextPath} (binary, not indexed)`);
+    return 0;
+  } catch (err) {
+    logger.warn(`  ! ${contextPath}: ${err}`);
+    return -1;
+  }
+}
+
+async function walkDirectory(dirPath: string): Promise<string[]> {
+  const files: string[] = [];
+  const entries = await readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) continue; // skip hidden dirs
+      files.push(...(await walkDirectory(fullPath)));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
 }

package/src/commands/mcpx.ts

@@ -1,29 +1,245 @@
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { Command } from "commander";
+import { getMcpxDir } from "../constants.ts";
 import { logger } from "../utils/logger.ts";
 
+const require = createRequire(import.meta.url);
+const ourPkg = require("../../package.json");
+const mcpxPkg = require("@evantahler/mcpx/package.json");
+
+if (mcpxPkg.version !== ourPkg.dependencies["@evantahler/mcpx"]) {
+  throw new Error(
+    `@evantahler/mcpx version mismatch: installed ${mcpxPkg.version}, expected ${ourPkg.dependencies["@evantahler/mcpx"]}`,
+  );
+}
+
+const MCPX_CLI = fileURLToPath(import.meta.resolve("@evantahler/mcpx/cli"));
+
+export async function runMcpx(
+  projectDir: string,
+  args: (string | undefined)[],
+  opts?: { inherit?: boolean },
+): Promise<string> {
+  const mcpxDir = getMcpxDir(projectDir);
+  const filteredArgs = args.filter((a): a is string => a !== undefined);
+  const proc = Bun.spawn(["bun", MCPX_CLI, ...filteredArgs, "-c", mcpxDir], {
+    stdout: opts?.inherit ? "inherit" : "pipe",
+    stderr: opts?.inherit ? "inherit" : "pipe",
+    stdin: opts?.inherit ? "inherit" : undefined,
+  });
+  const exitCode = await proc.exited;
+
+  if (opts?.inherit) {
+    if (exitCode !== 0) process.exit(exitCode);
+    return "";
+  }
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  if (exitCode !== 0) {
+    logger.error(stderr.trim() || stdout.trim());
+    process.exit(exitCode);
+  }
+  return stdout;
+}
+
+function getDir(program: Command): string {
+  return program.opts().dir;
+}
+
 export function registerMcpxCommand(program: Command) {
   const mcpx = program
     .command("mcpx")
     .description("Manage MCP servers via MCPX");
 
+  // --- servers ---
   mcpx
-    .command("list")
-    .description("List configured MCP servers")
+    .command("servers")
+    .description("List configured MCP server names")
     .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
+      const out = await runMcpx(getDir(program), ["servers"]);
+      process.stdout.write(out);
     });
 
+  // --- info ---
   mcpx
-    .command("add <server>")
+    .command("info <first> [second]")
+    .description(
+      "Show server overview, or schema for a specific tool (server is optional if tool name is unambiguous)",
+    )
+    .action(async (first: string, second?: string) => {
+      const out = await runMcpx(getDir(program), ["info", first, second]);
+      process.stdout.write(out);
+    });
+
+  // --- search ---
+  mcpx
+    .command("search <terms...>")
+    .description("Search tools by keyword and/or semantic similarity")
+    .action(async (terms: string[]) => {
+      const out = await runMcpx(getDir(program), ["search", ...terms]);
+      process.stdout.write(out);
+    });
+
+  // --- exec ---
+  mcpx
+    .command("exec <first> [second] [third]")
+    .description(
+      "Execute a tool call (server is optional if tool name is unambiguous)",
+    )
+    .action(async (first: string, second?: string, third?: string) => {
+      const out = await runMcpx(getDir(program), [
+        "exec",
+        first,
+        second,
+        third,
+      ]);
+      process.stdout.write(out);
+    });
+
+  // --- add ---
+  mcpx
+    .command("add <name>")
     .description("Add an MCP server")
+    .option("--command <cmd>", "Stdio server command")
+    .option("--args <args...>", "Stdio server arguments")
+    .option("--url <url>", "HTTP server URL")
+    .option("--transport <type>", "HTTP transport: sse or streamable-http")
+    .option("--env <pairs...>", "Environment variables as KEY=VALUE pairs")
+    .action(
+      async (
+        name: string,
+        opts: {
+          command?: string;
+          args?: string[];
+          url?: string;
+          transport?: string;
+          env?: string[];
+        },
+      ) => {
+        const cliArgs: string[] = ["add", name];
+        if (opts.command) cliArgs.push("--command", opts.command);
+        if (opts.args) {
+          for (const a of opts.args) cliArgs.push("--args", a);
+        }
+        if (opts.url) cliArgs.push("--url", opts.url);
+        if (opts.transport) cliArgs.push("--transport", opts.transport);
+        if (opts.env) {
+          for (const e of opts.env) cliArgs.push("--env", e);
+        }
+        const out = await runMcpx(getDir(program), cliArgs);
+        process.stdout.write(out);
+      },
+    );
+
+  // --- remove ---
+  mcpx
+    .command("remove <name>")
+    .description("Remove an MCP server")
+    .action(async (name: string) => {
+      const out = await runMcpx(getDir(program), ["remove", name]);
+      process.stdout.write(out);
+    });
+
+  // --- ping ---
+  mcpx
+    .command("ping [servers...]")
+    .description("Check connectivity to MCP servers")
+    .action(async (servers: string[]) => {
+      const out = await runMcpx(getDir(program), ["ping", ...servers]);
+      process.stdout.write(out);
+    });
+
+  // --- auth ---
+  mcpx
+    .command("auth <server>")
+    .description("Authenticate with an HTTP MCP server")
+    .action(async (server: string) => {
+      await runMcpx(getDir(program), ["auth", server], { inherit: true });
+    });
+
+  // --- resource ---
+  mcpx
+    .command("resource [server] [uri]")
+    .description("List resources for a server, or read a specific resource")
+    .action(async (server?: string, uri?: string) => {
+      const out = await runMcpx(getDir(program), ["resource", server, uri]);
+      process.stdout.write(out);
+    });
+
+  // --- prompt ---
+  mcpx
+    .command("prompt [server] [name] [args]")
+    .description("List prompts for a server, or get a specific prompt")
+    .action(async (server?: string, name?: string, argsJson?: string) => {
+      const out = await runMcpx(getDir(program), [
+        "prompt",
+        server,
+        name,
+        argsJson,
+      ]);
+      process.stdout.write(out);
+    });
+
+  // --- task ---
+  mcpx
+    .command("task <action> <server> [taskId]")
+    .description("Manage async tasks (actions: list, get, result, cancel)")
+    .action(async (action: string, server: string, taskId?: string) => {
+      const out = await runMcpx(getDir(program), [
+        "task",
+        action,
+        server,
+        taskId,
+      ]);
+      process.stdout.write(out);
+    });
+
+  // --- import-global ---
+  mcpx
+    .command("import-global")
+    .description("Copy system-wide MCPX settings (~/.mcpx) into this project")
     .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
+      const globalDir = join(homedir(), ".mcpx");
+      if (!existsSync(globalDir)) {
+        logger.error("No global MCPX config found at ~/.mcpx");
+        process.exit(1);
+      }
+
+      const projectMcpxDir = getMcpxDir(getDir(program));
+      if (!existsSync(projectMcpxDir)) {
+        mkdirSync(projectMcpxDir, { recursive: true });
+      }
+
+      const filesToCopy = ["servers.json", "auth.json", "search.json"];
+      let copied = 0;
+      for (const file of filesToCopy) {
+        const src = join(globalDir, file);
+        if (!existsSync(src)) continue;
+        const dest = join(projectMcpxDir, file);
+        copyFileSync(src, dest);
+        logger.success(`Copied ${file}`);
+        copied++;
+      }
+
+      if (copied === 0) {
+        logger.warn("No config files found in ~/.mcpx to copy.");
+      } else {
+        logger.success(
+          `Imported ${copied} file(s) from ~/.mcpx into ${projectMcpxDir}`,
+        );
+      }
     });
 
+  // --- index ---
   mcpx
-    .command("test <tool>")
-    .description("Test a tool call")
+    .command("index")
+    .description("Build the search index from all configured servers")
     .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
+      await runMcpx(getDir(program), ["index"], { inherit: true });
     });
 }

package/src/commands/prepare.ts

@@ -0,0 +1,16 @@
+import type { Command } from "commander";
+import { warmupEmbedder } from "../context/embedder.ts";
+import { logger } from "../utils/logger.ts";
+
+export function registerPrepareCommand(program: Command) {
+  program
+    .command("prepare")
+    .description(
+      "Download and cache required models. Run this in CI or on first setup.",
+    )
+    .action(async () => {
+      logger.info("Preparing Botholomew...");
+      await warmupEmbedder();
+      logger.success("All models downloaded and ready.");
+    });
+}

package/src/commands/schedule.ts

@@ -0,0 +1,186 @@
+import ansis from "ansis";
+import type { Command } from "commander";
+import type { Schedule } from "../db/schedules.ts";
+import {
+  createSchedule,
+  deleteSchedule,
+  getSchedule,
+  listSchedules,
+  updateSchedule,
+} from "../db/schedules.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");
+
+  schedule
+    .command("list")
+    .description("List all schedules")
+    .option("--enabled", "show only enabled schedules")
+    .option("--disabled", "show only disabled schedules")
+    .action((opts) =>
+      withDb(program, async (conn) => {
+        const filters: { enabled?: boolean } = {};
+        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);
+        }
+      }),
+    );
+
+  schedule
+    .command("add <name>")
+    .description("Create a new schedule")
+    .requiredOption(
+      "-f, --frequency <text>",
+      "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})`);
+      }),
+    );
+
+  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);
+      }),
+    );
+
+  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}`);
+      }),
+    );
+
+  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}`);
+      }),
+    );
+
+  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}`);
+      }),
+    );
+
+  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("../daemon/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})`);
+          }
+        }
+
+        await markScheduleRun(conn, s.id);
+        logger.info(`Marked schedule "${s.name}" as run.`);
+      }),
+    );
+}
+
+function enabledColor(enabled: boolean): string {
+  return enabled ? ansis.green("enabled") : ansis.dim("disabled");
+}
+
+function printSchedule(s: Schedule) {
+  const id = ansis.dim(s.id.slice(0, 8));
+  const lastRun = s.last_run_at
+    ? s.last_run_at.toISOString()
+    : ansis.dim("never");
+  console.log(
+    `  ${id}  ${enabledColor(s.enabled)}  ${s.frequency}  ${s.name}  (last: ${lastRun})`,
+  );
+}
+
+function printScheduleDetail(s: Schedule) {
+  console.log(ansis.bold(s.name));
+  console.log(`  ID:          ${s.id}`);
+  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()}`);
+}