botholomew 0.11.4 → 0.11.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {

package/src/chat/agent.ts

@@ -56,6 +56,7 @@ const CHAT_TOOL_NAMES = new Set([
   "mcp_info",
   "mcp_exec",
   "read_large_result",
+  "pipe_to_context",
   "spawn_worker",
   "skill_list",
   "skill_read",

package/src/context/embedder-impl.ts

@@ -47,11 +47,13 @@ function isModelCached(model: string): boolean {
 async function getPipeline(model: string): Promise<FeatureExtractionPipeline> {
   let p = pipelinePromises.get(model);
   if (!p) {
-    logger.info(
-      isModelCached(model)
-        ? `Loading embedding model ${model}`
-        : `Loading embedding model ${model} (first run, downloading weights)`,
-    );
+    if (isModelCached(model)) {
+      logger.debug(`Loading embedding model ${model}`);
+    } else {
+      logger.info(
+        `Loading embedding model ${model} (first run, downloading weights)`,
+      );
+    }
     p = pipeline("feature-extraction", model);
     pipelinePromises.set(model, p);
   }

package/src/skills/commands.ts

@@ -1,5 +1,5 @@
 import type { SkillDefinition } from "./parser.ts";
-import { renderSkill, validateSkillArgs } from "./parser.ts";
+import { renderSkill, tokenizeForSkill, validateSkillArgs } from "./parser.ts";
 
 export interface SlashCommand {
   name: string;
@@ -40,6 +40,58 @@ export function formatSkillUsage(skill: SkillDefinition): string {
   return parts.join(" ");
 }
 
+/**
+ * Detect when a multi-arg skill received unquoted whitespace-separated
+ * input that the greedy-last splitter has packed into the final slot.
+ * The user almost certainly intended one of the words to belong to a
+ * different slot (or the whole thing to be a single argument), so we
+ * surface a parse breakdown instead of silently committing to one
+ * interpretation.
+ *
+ * Returns null when the input is unambiguous and may proceed.
+ */
+export function detectAmbiguousSplit(
+  skill: SkillDefinition,
+  rawArgs: string,
+): { tokens: string[] } | null {
+  if (skill.arguments.length < 2) return null;
+  if (rawArgs.includes('"') || rawArgs.includes("'")) return null;
+  const tokens = tokenizeForSkill(rawArgs, skill);
+  const last = tokens[tokens.length - 1];
+  if (!last || !/\s/.test(last)) return null;
+  return { tokens };
+}
+
+function formatAmbiguityHint(skill: SkillDefinition, tokens: string[]): string {
+  const slots: string[] = [];
+  const nameWidth = skill.arguments.reduce(
+    (m, a) => Math.max(m, a.name.length),
+    0,
+  );
+  skill.arguments.forEach((argDef, i) => {
+    const value =
+      tokens[i] !== undefined
+        ? `"${tokens[i]}"`
+        : argDef.default !== undefined
+          ? `"${argDef.default}" (default)`
+          : "(unset)";
+    slots.push(`  ${argDef.name.padEnd(nameWidth)} = ${value}`);
+  });
+
+  const firstWord = tokens[0] ?? "";
+  const restPreview = tokens.slice(1).join(" ");
+  const fullPreview = [firstWord, restPreview].filter(Boolean).join(" ");
+
+  return [
+    `/${skill.name}: ambiguous input. Parsed as:`,
+    ...slots,
+    "",
+    "Quote the multi-word argument to confirm, e.g.:",
+    `  /${skill.name} "${fullPreview}"`,
+    `  /${skill.name} '${firstWord}' '${restPreview}'`,
+  ].join("\n");
+}
+
 /**
  * Handle a slash-command input. Returns true if the command was consumed
  * (recognized or errored), false if it should fall through.
@@ -96,6 +148,11 @@ export function handleSlashCommand(
       );
       return true;
     }
+    const ambiguous = detectAmbiguousSplit(skill, rawArgs);
+    if (ambiguous) {
+      ctx.addSystemMessage(formatAmbiguityHint(skill, ambiguous.tokens));
+      return true;
+    }
     const rendered = renderSkill(skill, rawArgs);
     ctx.queueUserMessage(rendered, { display: input });
     return true;

package/src/skills/parser.ts

@@ -52,18 +52,22 @@ export function parseSkillFile(raw: string, filePath: string): SkillDefinition {
 }
 
 /**
- * Split a raw argument string into positional tokens,
- * respecting double-quoted strings.
+ * Split a raw argument string into positional tokens, respecting both
+ * single- and double-quoted strings. A closing quote must match the
+ * opening quote; the other quote character is treated as a literal
+ * inside the run.
  */
 export function tokenize(raw: string): string[] {
   const tokens: string[] = [];
   let current = "";
-  let inQuote = false;
+  let quoteChar: '"' | "'" | null = null;
 
   for (const ch of raw) {
-    if (ch === '"') {
-      inQuote = !inQuote;
-    } else if (!inQuote && /\s/.test(ch)) {
+    if (quoteChar === null && (ch === '"' || ch === "'")) {
+      quoteChar = ch;
+    } else if (quoteChar !== null && ch === quoteChar) {
+      quoteChar = null;
+    } else if (quoteChar === null && /\s/.test(ch)) {
       if (current) {
         tokens.push(current);
         current = "";
@@ -77,12 +81,75 @@ export function tokenize(raw: string): string[] {
   return tokens;
 }
 
+/**
+ * Schema-aware tokenizer used by skill rendering. When a skill declares
+ * N >= 1 positional arguments, the first N - 1 tokens are split with
+ * `tokenize()` and the **last** token captures the entire remaining
+ * input verbatim (with surrounding whitespace trimmed and a single
+ * surrounding pair of matched quotes stripped). This makes the common
+ * case of an unquoted multi-word final argument "just work" — e.g.
+ * `/write-as-evan why are avocados good?` for a single-arg skill puts
+ * the whole sentence into `$1`.
+ *
+ * When N === 0 (no declared arguments), behaves exactly like
+ * `tokenize()`.
+ */
+export function tokenizeForSkill(
+  raw: string,
+  skill: SkillDefinition,
+): string[] {
+  const n = skill.arguments.length;
+  if (n === 0) return tokenize(raw);
+
+  const tokens: string[] = [];
+  let current = "";
+  let quoteChar: '"' | "'" | null = null;
+  let i = 0;
+
+  for (; i < raw.length && tokens.length < n - 1; i++) {
+    const ch = raw[i] as string;
+    if (quoteChar === null && (ch === '"' || ch === "'")) {
+      quoteChar = ch;
+    } else if (quoteChar !== null && ch === quoteChar) {
+      quoteChar = null;
+    } else if (quoteChar === null && /\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+
+  // Flush any in-progress token if we hit the N-1 cap mid-run.
+  if (current) {
+    tokens.push(current);
+    current = "";
+  }
+
+  let remainder = raw.slice(i).trim();
+  if (remainder.length >= 2) {
+    const first = remainder[0];
+    const last = remainder[remainder.length - 1];
+    if ((first === '"' || first === "'") && first === last) {
+      // Strip surrounding quotes only when the entire remainder is a
+      // single quoted string with no interior unescaped same-quote.
+      const inner = remainder.slice(1, -1);
+      if (!inner.includes(first)) remainder = inner;
+    }
+  }
+  if (remainder.length > 0) tokens.push(remainder);
+
+  return tokens;
+}
+
 function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
-  const tokens = tokenize(rawArgs);
+  const tokens = tokenizeForSkill(rawArgs, skill);
   let result = skill.body;
 
   // Replace $<argName> placeholders first, longest names first so a `$start`
@@ -123,7 +190,7 @@ export function validateSkillArgs(
   skill: SkillDefinition,
   rawArgs: string,
 ): { missing: string[] } {
-  const tokens = tokenize(rawArgs);
+  const tokens = tokenizeForSkill(rawArgs, skill);
   const missing: string[] = [];
   skill.arguments.forEach((argDef, i) => {
     if (!argDef.required) return;

package/src/tools/context/pipe.ts

@@ -0,0 +1,228 @@
+import { isText } from "istextorbinary";
+import { z } from "zod";
+import { formatDriveRef } from "../../context/drives.ts";
+import { ingestByPath } from "../../context/ingest.ts";
+import {
+  createContextItemStrict,
+  PathConflictError,
+  upsertContextItem,
+} from "../../db/context.ts";
+import { getTool, type ToolDefinition } from "../tool.ts";
+
+const PREVIEW_CHARS = 200;
+const ERROR_MESSAGE_CAP = 2000;
+const TOOL_NAME = "pipe_to_context";
+
+function mimeFromPath(path: string): string {
+  const type = Bun.file(path).type.split(";")[0];
+  return type ?? "application/octet-stream";
+}
+
+function isTextualPath(path: string): boolean {
+  const filename = path.split("/").pop() ?? path;
+  return isText(filename) !== false;
+}
+
+function truncate(s: string, cap: number): string {
+  if (s.length <= cap) return s;
+  return `${s.slice(0, cap)}…[truncated, ${s.length - cap} more chars]`;
+}
+
+const inputSchema = z.object({
+  tool_name: z
+    .string()
+    .describe(
+      "Name of the tool to dispatch. Its full output is piped into a context item; you (the LLM) will only see the storage acknowledgment, never the raw bytes.",
+    ),
+  tool_input: z
+    .record(z.string(), z.unknown())
+    .describe(
+      "Arguments to pass to the inner tool (same shape as a normal call).",
+    ),
+  drive: z
+    .string()
+    .default("agent")
+    .describe(
+      "Drive to write to (defaults to 'agent', the agent's scratch drive).",
+    ),
+  path: z.string().describe("Path within the drive (starts with /)"),
+  title: z
+    .string()
+    .optional()
+    .describe("Title for the file (defaults to filename)"),
+  description: z.string().optional().describe("Description of the file"),
+  on_conflict: z
+    .enum(["error", "overwrite"])
+    .optional()
+    .describe(
+      "What to do if a file already exists at this (drive, path). Defaults to 'error'. Pass 'overwrite' to replace.",
+    ),
+});
+
+const outputSchema = z.object({
+  is_error: z.boolean(),
+  id: z.string().optional(),
+  drive: z.string().optional(),
+  path: z.string().optional(),
+  ref: z.string().optional(),
+  bytes_written: z.number().optional(),
+  preview: z
+    .string()
+    .optional()
+    .describe(
+      `First ${PREVIEW_CHARS} characters of the stored content so you can sanity-check what was captured.`,
+    ),
+  inner_tool_is_error: z.boolean().optional(),
+  error_type: z
+    .enum([
+      "unknown_tool",
+      "forbidden_tool",
+      "invalid_input",
+      "inner_tool_error",
+      "path_conflict",
+    ])
+    .optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
+});
+
+export const pipeToContextTool = {
+  name: TOOL_NAME,
+  description:
+    "[[ bash equivalent command: cmd > file ]] Run another tool and pipe its full output directly into a context item, without the result flowing through the conversation. Use this when you need a large tool output (web pages, search dumps, big mcp_exec results) to be searchable/embedded for later but you do NOT need to read the bytes yourself. You'll only see the storage ack (drive, path, id, size, short preview).",
+  group: "context",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const inner = getTool(input.tool_name);
+    if (!inner) {
+      return {
+        is_error: true,
+        error_type: "unknown_tool",
+        message: `No tool named "${input.tool_name}".`,
+        next_action_hint:
+          "Check the tool name spelling, or call the inner tool directly if you do need to see its output.",
+      };
+    }
+
+    if (inner.name === TOOL_NAME || inner.terminal) {
+      return {
+        is_error: true,
+        error_type: "forbidden_tool",
+        message: `Tool "${inner.name}" cannot be piped (terminal tools and pipe_to_context itself are not allowed).`,
+        next_action_hint:
+          "Pipe a non-terminal tool (search_grep, mcp_exec, context_refresh, etc.) instead.",
+      };
+    }
+
+    const parsedInner = inner.inputSchema.safeParse(input.tool_input);
+    if (!parsedInner.success) {
+      const issues = parsedInner.error.issues
+        .map((i) => `${i.path.join(".")}: ${i.message}`)
+        .join("; ");
+      return {
+        is_error: true,
+        error_type: "invalid_input",
+        message: `Invalid input for ${inner.name}: ${issues}.`,
+        next_action_hint:
+          "Fix tool_input to match the inner tool's schema and retry.",
+      };
+    }
+
+    let innerResult: unknown;
+    try {
+      innerResult = await inner.execute(parsedInner.data, ctx);
+    } catch (err) {
+      return {
+        is_error: true,
+        error_type: "inner_tool_error",
+        inner_tool_is_error: true,
+        message: truncate(
+          `Tool ${inner.name} threw: ${err instanceof Error ? err.message : String(err)}`,
+          ERROR_MESSAGE_CAP,
+        ),
+        next_action_hint:
+          "Retry with different arguments, or call the tool directly to see the full error.",
+      };
+    }
+
+    const innerIsError =
+      typeof innerResult === "object" &&
+      innerResult !== null &&
+      "is_error" in innerResult
+        ? (innerResult as { is_error: boolean }).is_error
+        : false;
+
+    const innerOutput =
+      typeof innerResult === "string"
+        ? innerResult
+        : JSON.stringify(innerResult);
+
+    if (innerIsError) {
+      return {
+        is_error: true,
+        error_type: "inner_tool_error",
+        inner_tool_is_error: true,
+        message: truncate(innerOutput, ERROR_MESSAGE_CAP),
+        next_action_hint:
+          "The inner tool returned an error and nothing was written. Fix the inputs and retry, or pipe a different tool.",
+      };
+    }
+
+    const mimeType = mimeFromPath(input.path);
+    const isTextual = isTextualPath(input.path);
+    const title =
+      input.title ?? input.path.split("/").filter(Boolean).pop() ?? input.path;
+    const onConflict = input.on_conflict ?? "error";
+    const target = { drive: input.drive, path: input.path };
+
+    try {
+      const item =
+        onConflict === "overwrite"
+          ? await upsertContextItem(ctx.conn, {
+              title,
+              description: input.description,
+              content: innerOutput,
+              drive: target.drive,
+              path: target.path,
+              mimeType,
+              isTextual,
+            })
+          : await createContextItemStrict(ctx.conn, {
+              title,
+              description: input.description,
+              content: innerOutput,
+              drive: target.drive,
+              path: target.path,
+              mimeType,
+              isTextual,
+            });
+
+      await ingestByPath(ctx.conn, target, ctx.config);
+
+      return {
+        is_error: false,
+        id: item.id,
+        drive: item.drive,
+        path: item.path,
+        ref: formatDriveRef(item),
+        bytes_written: innerOutput.length,
+        preview: innerOutput.slice(0, PREVIEW_CHARS),
+      };
+    } catch (err) {
+      if (err instanceof PathConflictError) {
+        return {
+          is_error: true,
+          error_type: "path_conflict",
+          drive: err.drive,
+          path: err.path,
+          ref: formatDriveRef({ drive: err.drive, path: err.path }),
+          message: `A file already exists at ${formatDriveRef({ drive: err.drive, path: err.path })} (id: ${err.existingId}). The inner tool ran but its output was discarded.`,
+          next_action_hint:
+            "Retry with on_conflict='overwrite' to replace, or pick a different path.",
+        };
+      }
+      throw err;
+    }
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/registry.ts

@@ -2,6 +2,7 @@
 import { capabilitiesRefreshTool } from "./capabilities/refresh.ts";
 // Context tools
 import { contextListDrivesTool } from "./context/list-drives.ts";
+import { pipeToContextTool } from "./context/pipe.ts";
 import { readLargeResultTool } from "./context/read-large-result.ts";
 import { contextRefreshTool } from "./context/refresh.ts";
 import { contextSearchTool } from "./context/search.ts";
@@ -85,6 +86,7 @@ export function registerAllTools(): void {
   registerTool(updateBeliefsTool);
   registerTool(updateGoalsTool);
   registerTool(readLargeResultTool);
+  registerTool(pipeToContextTool);
 
   // Capabilities
   registerTool(capabilitiesRefreshTool);