botholomew 0.11.3 → 0.11.5

package/package.json

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

package/src/chat/agent.ts

@@ -29,7 +29,7 @@ import {
 
 registerAllTools();
 
-/** Tools available in chat mode — no worker terminal tools, no destructive file tools */
+/** Tools available in chat mode — no worker terminal tools (complete/fail/wait), no bulk-destructive file tools (delete, copy/move, dir ops) */
 const CHAT_TOOL_NAMES = new Set([
   "create_task",
   "list_tasks",
@@ -39,6 +39,9 @@ const CHAT_TOOL_NAMES = new Set([
   "context_refresh",
   "context_tree",
   "context_list_drives",
+  "context_read",
+  "context_write",
+  "context_edit",
   "search_grep",
   "search_semantic",
   "list_threads",

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;