botholomew 0.12.3 → 0.13.0

package/src/commands/tools.ts

@@ -1,367 +0,0 @@
-import ansis from "ansis";
-import type { Command } from "commander";
-import { z } from "zod";
-import { loadConfig } from "../config/loader.ts";
-import { getDbPath } from "../constants.ts";
-import { parseDriveRef } from "../context/drives.ts";
-import type { DbConnection } from "../db/connection.ts";
-import { getContextItemById } from "../db/context.ts";
-import { isUuid } from "../db/uuid.ts";
-import { registerAllTools } from "../tools/registry.ts";
-import {
-  type AnyToolDefinition,
-  getToolsByGroup,
-  type ToolContext,
-} from "../tools/tool.ts";
-import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
-
-registerAllTools();
-
-/**
- * Register context tool subcommands (read, write, edit, etc.) onto an
- * existing Commander command. Skips tools whose derived subcommand name
- * collides with an already-registered subcommand on the parent.
- */
-/** Context tools that are agent-only (not exposed as CLI subcommands) */
-const AGENT_ONLY_TOOLS = new Set(["update_beliefs", "update_goals"]);
-
-export function registerContextToolSubcommands(parent: Command) {
-  const existing = new Set(parent.commands.map((c: Command) => c.name()));
-
-  for (const tool of getToolsByGroup("context")) {
-    if (AGENT_ONLY_TOOLS.has(tool.name)) continue;
-    const subName = deriveSubName(tool.name);
-    if (existing.has(subName)) continue; // skip conflicts with management subcommands
-    registerToolAsCLI(parent, tool);
-  }
-}
-
-/** Derive CLI subcommand name from tool name: "context_read" → "read", "context_create_dir" → "create-dir" */
-function deriveSubName(toolName: string): string {
-  return toolName.replace(/^[^_]+_/, "").replace(/_/g, "-");
-}
-
-function registerToolAsCLI(parent: Command, tool: AnyToolDefinition) {
-  const subName = deriveSubName(tool.name);
-
-  // Inspect zod schema to determine positional args and options
-  const shape = tool.inputSchema.shape as Record<string, z.ZodType>;
-  const positionals: string[] = [];
-  const options: {
-    key: string;
-    flag: string;
-    description: string;
-    isArray: boolean;
-  }[] = [];
-
-  for (const [key, schema] of Object.entries(shape)) {
-    const desc = schema.description ?? key;
-    const isOptional = schema.isOptional();
-    const unwrapped = unwrapSchema(schema);
-
-    if (isPositionalArg(key, tool.name)) {
-      positionals.push(isOptional ? `[${key}]` : `<${key}>`);
-    } else if (unwrapped instanceof z.ZodBoolean) {
-      options.push({
-        key,
-        flag: `--${key.replace(/_/g, "-")}`,
-        description: desc,
-        isArray: false,
-      });
-    } else if (unwrapped instanceof z.ZodArray) {
-      options.push({
-        key,
-        flag: `--${key.replace(/_/g, "-")} <json>`,
-        description: desc,
-        isArray: true,
-      });
-    } else {
-      options.push({
-        key,
-        flag: `--${key.replace(/_/g, "-")} <value>`,
-        description: desc,
-        isArray: false,
-      });
-    }
-  }
-
-  const cmd = parent
-    .command(`${subName} ${positionals.join(" ")}`.trim())
-    .description(tool.description);
-
-  for (const opt of options) {
-    if (opt.isArray) {
-      cmd.option(opt.flag, opt.description);
-    } else {
-      cmd.option(opt.flag, opt.description);
-    }
-  }
-
-  cmd.action((...args: unknown[]) => {
-    let root: Command = parent;
-    while (root.parent) root = root.parent;
-    return withDb(root, async (conn, dir) => {
-      try {
-        const input = await buildInput(
-          tool,
-          positionals,
-          options,
-          shape,
-          args,
-          conn,
-        );
-
-        const ctx: ToolContext = {
-          conn,
-          dbPath: getDbPath(dir),
-          projectDir: dir,
-          config: await loadConfig(dir),
-          mcpxClient: null,
-        };
-
-        const result = await tool.execute(input, ctx);
-        formatOutput(result, tool.name);
-      } catch (err) {
-        logger.error(String(err));
-        process.exit(1);
-      }
-    });
-  });
-}
-
-async function buildInput(
-  tool: AnyToolDefinition,
-  positionals: string[],
-  options: {
-    key: string;
-    flag: string;
-    description: string;
-    isArray: boolean;
-  }[],
-  shape: Record<string, z.ZodType>,
-  args: unknown[],
-  conn: DbConnection,
-): Promise<Record<string, unknown>> {
-  const input: Record<string, unknown> = {};
-
-  // Positional args come first in Commander's action callback. Context tools
-  // carry `(drive, path)` or `(src_drive, src_path, …)` in their schema but
-  // accept a friendlier `drive:/path` or bare-UUID form as a single positional
-  // on the CLI.
-  for (let i = 0; i < positionals.length; i++) {
-    const key = positionals[i]?.replace(/[<>[\]]/g, "");
-    const value = args[i];
-    if (key === undefined || value === undefined) continue;
-    const splitTargets = driveRefSplitTargets(key, shape);
-    if (splitTargets && typeof value === "string") {
-      const parsed = parseDriveRef(value);
-      if (parsed) {
-        input[splitTargets.drive] = parsed.drive;
-        input[splitTargets.path] = parsed.path;
-        continue;
-      }
-      if (isUuid(value)) {
-        const item = await getContextItemById(conn, value);
-        if (item) {
-          input[splitTargets.drive] = item.drive;
-          input[splitTargets.path] = item.path;
-          continue;
-        }
-      }
-    }
-    input[key] = value;
-  }
-
-  // Options object is the last argument before the Command object
-  const optsObj = (args[positionals.length] ?? {}) as Record<string, unknown>;
-
-  for (const opt of options) {
-    const cliKey = opt.key.replace(/_/g, "-");
-    // Commander converts --foo-bar to fooBar
-    const camelKey = cliKey.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-    let value = optsObj[camelKey] ?? optsObj[opt.key];
-
-    if (value === undefined) continue;
-
-    const schemaForKey = shape[opt.key];
-    if (!schemaForKey) continue;
-    const unwrapped = unwrapSchema(schemaForKey);
-
-    // Parse JSON for array types
-    if (opt.isArray && typeof value === "string") {
-      value = JSON.parse(value);
-    }
-    // Parse numbers
-    else if (unwrapped instanceof z.ZodNumber && typeof value === "string") {
-      value = Number(value);
-    }
-
-    input[opt.key] = value;
-  }
-
-  // Validate with zod
-  const parsed = tool.inputSchema.safeParse(input);
-  if (!parsed.success) {
-    throw new Error(`Invalid arguments: ${JSON.stringify(parsed.error)}`);
-  }
-
-  return parsed.data;
-}
-
-function formatOutput(result: unknown, _toolName: string) {
-  if (result == null) return;
-
-  if (typeof result === "object") {
-    const obj = result as Record<string, unknown>;
-
-    // Structured error shape: { is_error: true, message, next_action_hint? }
-    if (obj.is_error === true) {
-      const msg = typeof obj.message === "string" ? obj.message : "Error";
-      logger.error(msg);
-      if (
-        typeof obj.next_action_hint === "string" &&
-        obj.next_action_hint.length > 0
-      ) {
-        console.log(ansis.dim(obj.next_action_hint));
-      }
-      process.exit(1);
-    }
-
-    // Special formatting for known output shapes
-    if ("tree" in obj && typeof obj.tree === "string") {
-      console.log(obj.tree);
-      return;
-    }
-
-    if ("content" in obj && typeof obj.content === "string") {
-      console.log(obj.content);
-      return;
-    }
-
-    if ("exists" in obj && typeof obj.exists === "boolean") {
-      if (!obj.exists) process.exit(1);
-      return;
-    }
-
-    if ("entries" in obj && Array.isArray(obj.entries)) {
-      for (const entry of obj.entries) {
-        const e = entry as { name: string; type: string; size: number };
-        const suffix = e.type === "directory" ? "/" : "";
-        console.log(`  ${e.name}${suffix}`);
-      }
-      return;
-    }
-
-    if ("drives" in obj && Array.isArray(obj.drives)) {
-      const drives = obj.drives as { drive: string; count: number }[];
-      if (drives.length === 0) {
-        if (typeof obj.hint === "string") console.log(ansis.dim(obj.hint));
-        return;
-      }
-      const widest = Math.max(...drives.map((d) => d.drive.length));
-      for (const d of drives) {
-        const label = `${d.drive}:/`.padEnd(widest + 2);
-        const plural = d.count === 1 ? "item" : "items";
-        console.log(
-          `  ${ansis.cyan(label)} ${ansis.dim(`(${d.count} ${plural})`)}`,
-        );
-      }
-      if (typeof obj.hint === "string") {
-        console.log(`\n${ansis.dim(obj.hint)}`);
-      }
-      return;
-    }
-
-    if ("matches" in obj && Array.isArray(obj.matches)) {
-      for (const match of obj.matches) {
-        if (typeof match === "string") {
-          console.log(match);
-        } else {
-          const m = match as { path: string; line: number; content: string };
-          console.log(`${m.path}:${m.line}: ${m.content}`);
-        }
-      }
-      return;
-    }
-
-    if ("results" in obj && Array.isArray(obj.results)) {
-      for (const [i, r] of (
-        obj.results as {
-          path: string;
-          title: string;
-          score: number;
-          snippet: string;
-        }[]
-      ).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.path)}`);
-        if (r.snippet) {
-          const snippet = r.snippet.slice(0, 120).replace(/\n/g, " ");
-          console.log(`   ${snippet}...`);
-        }
-        console.log("");
-      }
-      return;
-    }
-
-    // Default: print as JSON
-    console.log(JSON.stringify(obj, null, 2));
-  } else {
-    console.log(result);
-  }
-}
-
-function isPositionalArg(key: string, toolName: string): boolean {
-  // These keys are treated as positional arguments
-  const positionalKeys: Record<string, string[]> = {
-    context_create_dir: ["path"],
-    context_tree: ["path"],
-    context_dir_size: ["path"],
-    context_read: ["path"],
-    context_write: ["path"],
-    context_edit: ["path"],
-    context_delete: ["path"],
-    context_copy: ["src", "dst"],
-    context_move: ["src", "dst"],
-    context_info: ["path"],
-    context_exists: ["path"],
-    context_count_lines: ["path"],
-    context_search: ["query"],
-  };
-  return positionalKeys[toolName]?.includes(key) ?? false;
-}
-
-function unwrapSchema(schema: z.ZodType): z.ZodType {
-  if (schema instanceof z.ZodOptional) {
-    return unwrapSchema(schema.unwrap() as z.ZodType);
-  }
-  if (schema instanceof z.ZodDefault) {
-    return unwrapSchema(schema.unwrap() as z.ZodType);
-  }
-  return schema;
-}
-
-/**
- * Decide how to expand a positional `path`/`src`/`dst` value into the tool's
- * schema when it carries a `drive:/path` prefix. Returns the drive+path field
- * names in the schema, or null if the schema has no matching drive field.
- */
-function driveRefSplitTargets(
-  positionalKey: string,
-  shape: Record<string, z.ZodType>,
-): { drive: string; path: string } | null {
-  if (positionalKey === "path" && "drive" in shape && "path" in shape) {
-    return { drive: "drive", path: "path" };
-  }
-  if (positionalKey === "src" && "src_drive" in shape && "src_path" in shape) {
-    return { drive: "src_drive", path: "src_path" };
-  }
-  if (positionalKey === "dst" && "dst_drive" in shape && "dst_path" in shape) {
-    return { drive: "dst_drive", path: "dst_path" };
-  }
-  return null;
-}

package/src/context/describer.ts

@@ -1,140 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import type { BotholomewConfig } from "../config/schemas.ts";
-import { logger } from "../utils/logger.ts";
-
-const DESCRIBE_TOOL_NAME = "return_description";
-
-const DESCRIBE_TOOL = {
-  name: DESCRIBE_TOOL_NAME,
-  description: "Return a one-sentence description of this content.",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      description: {
-        type: "string",
-        description:
-          "A concise one-sentence summary of what this content is about.",
-      },
-    },
-    required: ["description"],
-  },
-};
-
-const TIMEOUT_MS = 10_000;
-const MAX_CONTENT_CHARS = 8000;
-const MAX_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
-
-const IMAGE_TYPES = new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-]);
-
-type ImageMediaType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";
-
-async function buildMessageContent(
-  opts: DescriberOpts,
-): Promise<Anthropic.Messages.ContentBlockParam[]> {
-  const textPrompt = `Describe this file in one sentence. Be specific about what it contains, not generic.\n\nFilename: ${opts.filename}\nMIME type: ${opts.mimeType}`;
-
-  if (opts.content) {
-    const truncated =
-      opts.content.length > MAX_CONTENT_CHARS
-        ? `${opts.content.slice(0, MAX_CONTENT_CHARS)}\n... (truncated)`
-        : opts.content;
-    return [{ type: "text", text: `${textPrompt}\n\nContent:\n${truncated}` }];
-  }
-
-  if (opts.filePath) {
-    const file = Bun.file(opts.filePath);
-    const size = file.size;
-
-    if (size > 0 && size <= MAX_FILE_BYTES) {
-      const data = Buffer.from(await file.arrayBuffer()).toString("base64");
-
-      if (IMAGE_TYPES.has(opts.mimeType)) {
-        return [
-          {
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: opts.mimeType as ImageMediaType,
-              data,
-            },
-          },
-          { type: "text", text: textPrompt },
-        ];
-      }
-
-      if (opts.mimeType === "application/pdf") {
-        return [
-          {
-            type: "document",
-            source: { type: "base64", media_type: "application/pdf", data },
-          },
-          { type: "text", text: textPrompt },
-        ];
-      }
-    }
-  }
-
-  return [
-    {
-      type: "text",
-      text: `${textPrompt}\n\n(Binary file — no content preview available)`,
-    },
-  ];
-}
-
-interface DescriberOpts {
-  filename: string;
-  mimeType: string;
-  content: string | null;
-  filePath?: string;
-}
-
-/**
- * Generate a short description of a file using the LLM.
- * For textual files, summarises the content.
- * For binary files, attaches images/PDFs directly or describes from metadata.
- */
-export async function generateDescription(
-  config: Required<BotholomewConfig>,
-  opts: DescriberOpts,
-): Promise<string> {
-  if (!config.anthropic_api_key) {
-    return "";
-  }
-
-  const client = new Anthropic({ apiKey: config.anthropic_api_key });
-
-  try {
-    const content = await buildMessageContent(opts);
-
-    const response = await Promise.race([
-      client.messages.create({
-        model: config.chunker_model,
-        max_tokens: 256,
-        tools: [DESCRIBE_TOOL],
-        tool_choice: { type: "tool", name: DESCRIBE_TOOL_NAME },
-        messages: [{ role: "user", content }],
-      }),
-      new Promise<never>((_, reject) =>
-        setTimeout(
-          () => reject(new Error("Description generation timeout")),
-          TIMEOUT_MS,
-        ),
-      ),
-    ]);
-
-    const toolBlock = response.content.find((b) => b.type === "tool_use");
-    if (!toolBlock || toolBlock.type !== "tool_use") return "";
-
-    const input = toolBlock.input as { description: string };
-    return input.description || "";
-  } catch (err) {
-    logger.debug(`Description generation failed: ${err}`);
-    return "";
-  }
-}

package/src/context/drives.ts

@@ -1,110 +0,0 @@
-/**
- * Drives name the origin of a context item. Every item lives at a
- * `(drive, path)` pair; the `drive:/path` string form is a display and CLI
- * convention (single column queries use the two columns directly).
- *
- * Built-in drives:
- *   disk       — local filesystem; path is the absolute filesystem path
- *   url        — generic HTTP(S) URL; path is the full URL
- *   agent      — agent-authored scratch; path is whatever the agent chose
- *   google-docs — Google Docs; path is `/<docId>`
- *   github     — GitHub content; path is `/<owner>/<repo>/<rest>`
- */
-
-export const BUILT_IN_DRIVES = [
-  "disk",
-  "url",
-  "agent",
-  "google-docs",
-  "github",
-] as const;
-
-export interface DriveTarget {
-  drive: string;
-  path: string;
-}
-
-/** Parse `drive:/path` → `{ drive, path }`. Returns null if not in drive form. */
-export function parseDriveRef(ref: string): DriveTarget | null {
-  const i = ref.indexOf(":");
-  if (i <= 0) return null;
-  const drive = ref.slice(0, i);
-  const path = ref.slice(i + 1);
-  if (!path.startsWith("/")) return null;
-  if (!/^[a-z][a-z0-9_-]*$/.test(drive)) return null;
-  return { drive, path };
-}
-
-/** Format a `(drive, path)` pair for display / CLI. */
-export function formatDriveRef(target: DriveTarget): string {
-  return `${target.drive}:${target.path}`;
-}
-
-/**
- * Detect the right drive for a URL. If `mcpxServerName` is provided, prefer it
- * as a hint (some MCP servers are named after the service they back).
- */
-export function detectDriveFromUrl(
-  url: string,
-  mcpxServerName?: string | null,
-): DriveTarget {
-  const hint = mcpxServerName?.toLowerCase() ?? "";
-  let parsed: URL | null = null;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return { drive: "url", path: `/${url}` };
-  }
-
-  const host = parsed.hostname.toLowerCase();
-
-  if (
-    host === "docs.google.com" ||
-    (hint.includes("google") && hint.includes("doc"))
-  ) {
-    const docId = extractGoogleDocId(parsed);
-    if (docId) return { drive: "google-docs", path: `/${docId}` };
-  }
-
-  if (
-    host === "github.com" ||
-    host === "raw.githubusercontent.com" ||
-    hint.includes("github")
-  ) {
-    const ghPath = extractGithubPath(parsed);
-    if (ghPath) return { drive: "github", path: ghPath };
-  }
-
-  return { drive: "url", path: `/${url}` };
-}
-
-function extractGoogleDocId(u: URL): string | null {
-  // https://docs.google.com/document/d/<docId>/edit
-  // https://docs.google.com/spreadsheets/d/<docId>/edit
-  const m = u.pathname.match(/\/d\/([^/]+)/);
-  return m?.[1] ?? null;
-}
-
-function extractGithubPath(u: URL): string | null {
-  // https://github.com/<owner>/<repo>/blob/<ref>/<path...>
-  // https://github.com/<owner>/<repo>/tree/<ref>/<path...>
-  // https://github.com/<owner>/<repo>
-  // https://raw.githubusercontent.com/<owner>/<repo>/<ref>/<path...>
-  const segs = u.pathname.split("/").filter(Boolean);
-  if (segs.length < 2) return null;
-  const [owner, repo, kind, _ref, ...rest] = segs;
-  if (!owner || !repo) return null;
-  if (u.hostname === "raw.githubusercontent.com") {
-    // segs: owner, repo, ref, ...rest
-    const [_o, _r, _f, ...raw] = segs;
-    return raw.length > 0
-      ? `/${owner}/${repo}/${raw.join("/")}`
-      : `/${owner}/${repo}`;
-  }
-  if (kind === "blob" || kind === "tree") {
-    return rest.length > 0
-      ? `/${owner}/${repo}/${rest.join("/")}`
-      : `/${owner}/${repo}`;
-  }
-  return `/${owner}/${repo}`;
-}