botholomew 0.6.1 → 0.6.2

package/src/init/templates.ts

@@ -37,6 +37,29 @@ agent-modification: true
 - Get set up and ready to help.
 `;
 
+export const SUMMARIZE_SKILL = `---
+name: summarize
+description: "Summarize the current conversation"
+arguments: []
+---
+
+Summarize this conversation so far. Provide a concise bullet-point summary
+of what we discussed, any decisions made, and any open action items.
+`;
+
+export const STANDUP_SKILL = `---
+name: standup
+description: "Generate a standup update from recent tasks"
+arguments: []
+---
+
+Generate a standup update. Look at recent tasks (completed in the last 24 hours
+and currently in progress) and format a brief standup-style update with:
+- What was done (completed tasks)
+- What's in progress
+- Any blockers or waiting items
+`;
+
 export const DEFAULT_CONFIG = {
   anthropic_api_key: "your-api-key-here",
   model: "claude-opus-4-20250514",

package/src/skills/commands.ts

@@ -0,0 +1,61 @@
+import type { SkillDefinition } from "./parser.ts";
+import { renderSkill } from "./parser.ts";
+
+export interface SlashCommandContext {
+  skills: Map<string, SkillDefinition>;
+  addSystemMessage: (content: string) => void;
+  queueUserMessage: (content: string) => void;
+  exit: () => void;
+}
+
+/**
+ * Handle a slash-command input. Returns true if the command was consumed
+ * (recognized or errored), false if it should fall through.
+ */
+export function handleSlashCommand(
+  input: string,
+  ctx: SlashCommandContext,
+): boolean {
+  const spaceIdx = input.indexOf(" ");
+  const commandPart = spaceIdx === -1 ? input : input.slice(0, spaceIdx);
+  const rawArgs = spaceIdx === -1 ? "" : input.slice(spaceIdx + 1).trim();
+  const name = commandPart.slice(1).toLowerCase(); // remove leading /
+
+  // Built-in commands
+  if (name === "quit" || name === "exit") {
+    ctx.exit();
+    return true;
+  }
+
+  if (name === "skills") {
+    if (ctx.skills.size === 0) {
+      ctx.addSystemMessage(
+        "No skills loaded. Add .md files to .botholomew/skills/",
+      );
+    } else {
+      const lines = ["Available skills:"];
+      for (const [skillName, skill] of ctx.skills) {
+        lines.push(
+          `  /${skillName.padEnd(16)} ${skill.description || "(no description)"}`,
+        );
+      }
+      ctx.addSystemMessage(lines.join("\n"));
+    }
+    return true;
+  }
+
+  // Skill dispatch
+  const skill = ctx.skills.get(name);
+  if (skill) {
+    const rendered = renderSkill(skill, rawArgs);
+    ctx.addSystemMessage(`Running skill: ${skill.name}`);
+    ctx.queueUserMessage(rendered);
+    return true;
+  }
+
+  // Unknown command
+  ctx.addSystemMessage(
+    `Unknown command: /${name}. Type /skills to see available commands.`,
+  );
+  return true;
+}

package/src/skills/loader.ts

@@ -0,0 +1,36 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { getSkillsDir } from "../constants.ts";
+import { parseSkillFile, type SkillDefinition } from "./parser.ts";
+
+export async function loadSkills(
+  projectDir: string,
+): Promise<Map<string, SkillDefinition>> {
+  const skills = new Map<string, SkillDefinition>();
+  const dir = getSkillsDir(projectDir);
+
+  let entries: string[];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return skills; // directory doesn't exist — graceful for pre-M7 projects
+  }
+
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = join(dir, entry);
+    const raw = await Bun.file(filePath).text();
+    const skill = parseSkillFile(raw, filePath);
+    skills.set(skill.name, skill);
+  }
+
+  return skills;
+}
+
+export async function getSkill(
+  projectDir: string,
+  name: string,
+): Promise<SkillDefinition | null> {
+  const skills = await loadSkills(projectDir);
+  return skills.get(name.toLowerCase()) ?? null;
+}

package/src/skills/parser.ts

@@ -0,0 +1,95 @@
+import { basename } from "node:path";
+import matter from "gray-matter";
+
+export interface SkillArgDef {
+  name: string;
+  description: string;
+  required: boolean;
+  default?: string;
+}
+
+export interface SkillDefinition {
+  name: string;
+  description: string;
+  arguments: SkillArgDef[];
+  body: string;
+  filePath: string;
+}
+
+export function parseSkillFile(raw: string, filePath: string): SkillDefinition {
+  const { data, content } = matter(raw);
+
+  const name: string =
+    typeof data.name === "string" && data.name
+      ? data.name.toLowerCase()
+      : basename(filePath, ".md").toLowerCase();
+
+  const description: string =
+    typeof data.description === "string" ? data.description : "";
+
+  const args: SkillArgDef[] = [];
+  if (Array.isArray(data.arguments)) {
+    for (const arg of data.arguments) {
+      if (arg && typeof arg === "object" && typeof arg.name === "string") {
+        args.push({
+          name: arg.name,
+          description:
+            typeof arg.description === "string" ? arg.description : "",
+          required: arg.required === true,
+          default: typeof arg.default === "string" ? arg.default : undefined,
+        });
+      }
+    }
+  }
+
+  return {
+    name,
+    description,
+    arguments: args,
+    body: content.trim(),
+    filePath,
+  };
+}
+
+/**
+ * Split a raw argument string into positional tokens,
+ * respecting double-quoted strings.
+ */
+function tokenize(raw: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let inQuote = false;
+
+  for (const ch of raw) {
+    if (ch === '"') {
+      inQuote = !inQuote;
+    } else if (!inQuote && /\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
+  const tokens = tokenize(rawArgs);
+  let result = skill.body;
+
+  result = result.replaceAll("$ARGUMENTS", rawArgs);
+
+  // Replace $1-$9 with positional args or defaults
+  for (let i = 1; i <= 9; i++) {
+    const token = tokens[i - 1];
+    const argDef = skill.arguments[i - 1];
+    const value = token ?? argDef?.default ?? "";
+    result = result.replaceAll(`$${i}`, value);
+  }
+
+  return result;
+}

package/src/tools/context/search.ts

@@ -22,9 +22,9 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const searchContextTool = {
-  name: "search_context",
-  description: "Search the context database by keyword.",
+export const contextSearchTool = {
+  name: "context_search",
+  description: "Search context by keyword.",
   group: "context",
   inputSchema,
   outputSchema,

package/src/tools/dir/create.ts

@@ -16,10 +16,10 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const dirCreateTool = {
-  name: "dir_create",
-  description: "Create a directory in the virtual filesystem.",
-  group: "dir",
+export const contextCreateDirTool = {
+  name: "context_create_dir",
+  description: "Create a directory in context.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {

package/src/tools/dir/list.ts

@@ -36,10 +36,10 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const dirListTool = {
-  name: "dir_list",
-  description: "List directory contents in the virtual filesystem.",
-  group: "dir",
+export const contextListDirTool = {
+  name: "context_list_dir",
+  description: "List directory contents in context.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {

package/src/tools/dir/size.ts

@@ -24,10 +24,10 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const dirSizeTool = {
-  name: "dir_size",
-  description: "Get the total size of files in a directory.",
-  group: "dir",
+export const contextDirSizeTool = {
+  name: "context_dir_size",
+  description: "Get the total size of context items in a directory.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {

package/src/tools/dir/tree.ts

@@ -1,92 +1,275 @@
 import { z } from "zod";
-import { listContextItemsByPrefix } from "../../db/context.ts";
+import {
+  countContextItemsByPrefix,
+  listContextItemsByPrefix,
+} from "../../db/context.ts";
 import type { ToolDefinition } from "../tool.ts";
 
-const DEFAULT_MAX_ITEMS = 200;
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_ITEMS_PER_DIR = 15;
+const HARD_FETCH_CAP = 1000;
 
 const inputSchema = z.object({
   path: z
     .string()
     .optional()
     .describe("Root path for the tree (defaults to /)"),
-  max_items: z
+  max_depth: z
     .number()
+    .int()
+    .positive()
     .optional()
-    .default(DEFAULT_MAX_ITEMS)
+    .default(DEFAULT_MAX_DEPTH)
     .describe(
-      `Maximum number of items to include (defaults to ${DEFAULT_MAX_ITEMS})`,
+      `Maximum depth of directories to render (defaults to ${DEFAULT_MAX_DEPTH}). Use a deeper path to drill in.`,
     ),
+  items_per_dir: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .default(DEFAULT_ITEMS_PER_DIR)
+    .describe(
+      `Maximum entries shown per directory (defaults to ${DEFAULT_ITEMS_PER_DIR}). Overflow shown as "(+N more)".`,
+    ),
+});
+
+const TruncatedDirSchema = z.object({
+  path: z.string(),
+  shown: z.number(),
+  total: z.number(),
 });
 
 const outputSchema = z.object({
   tree: z.string(),
   is_error: z.boolean(),
+  total_items: z.number(),
+  truncated_dirs: z.array(TruncatedDirSchema),
+  hint: z.string(),
 });
 
-export const dirTreeTool = {
-  name: "dir_tree",
+interface DirNode {
+  name: string;
+  fullPath: string;
+  isDir: true;
+  children: TreeEntry[];
+}
+
+interface FileNode {
+  name: string;
+  fullPath: string;
+  isDir: false;
+}
+
+type TreeEntry = DirNode | FileNode;
+
+export const contextTreeTool = {
+  name: "context_tree",
   description:
-    "Render a directory as a markdown-style tree in the virtual filesystem.",
-  group: "dir",
+    "Render a directory as a markdown-style tree. Use max_depth and items_per_dir to bound output; drill in by passing a deeper path.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
     const path = input.path ?? "/";
-    const maxItems = input.max_items ?? DEFAULT_MAX_ITEMS;
-    const items = await listContextItemsByPrefix(ctx.conn, path, {
+    const maxDepth = input.max_depth ?? DEFAULT_MAX_DEPTH;
+    const itemsPerDir = input.items_per_dir ?? DEFAULT_ITEMS_PER_DIR;
+    const normalizedPath = path.endsWith("/") ? path : `${path}/`;
+
+    const totalItems = await countContextItemsByPrefix(ctx.conn, path, {
       recursive: true,
-      limit: maxItems,
     });
 
-    if (items.length === 0) {
-      return { tree: `${path}\n  (empty)`, is_error: false };
+    if (totalItems === 0) {
+      return {
+        tree: `${path}\n  (empty)`,
+        is_error: false,
+        total_items: 0,
+        truncated_dirs: [],
+        hint: "Directory is empty.",
+      };
     }
 
-    const normalizedPath = path.endsWith("/") ? path : `${path}/`;
+    const items = await listContextItemsByPrefix(ctx.conn, path, {
+      recursive: true,
+      limit: HARD_FETCH_CAP,
+    });
 
-    // Build tree structure
-    const lines: string[] = [path];
+    // Build tree structure: dirs map child name -> child node
+    const root: DirNode = {
+      name: path,
+      fullPath: path,
+      isDir: true,
+      children: [],
+    };
+    const dirIndex = new Map<string, DirNode>();
+    dirIndex.set(stripTrailingSlash(path), root);
+
+    for (const item of items) {
+      const relative = item.context_path.slice(normalizedPath.length);
+      if (relative.length === 0) continue; // root itself, skip
+      const parts = relative.split("/").filter((p) => p.length > 0);
+      const isExplicitDir = item.mime_type === "inode/directory";
 
-    // Collect all paths and sort
-    const paths = items.map((i) => i.context_path).sort();
+      // Walk segments, creating intermediate directories as needed
+      let parentDir = root;
+      let currentRel = "";
+      for (let i = 0; i < parts.length; i++) {
+        const segment = parts[i];
+        if (!segment) continue;
+        currentRel = currentRel ? `${currentRel}/${segment}` : segment;
+        const fullPath = `${normalizedPath}${currentRel}`;
+        const isLeaf = i === parts.length - 1;
+        const isDirHere = !isLeaf || isExplicitDir;
 
-    // Collect all directory prefixes
-    const dirSet = new Set<string>();
-    for (const p of paths) {
-      const relative = p.slice(normalizedPath.length);
-      const parts = relative.split("/");
-      for (let i = 1; i < parts.length; i++) {
-        dirSet.add(parts.slice(0, i).join("/"));
+        if (isDirHere) {
+          const key = stripTrailingSlash(fullPath);
+          let dir = dirIndex.get(key);
+          if (!dir) {
+            dir = {
+              name: segment,
+              fullPath,
+              isDir: true,
+              children: [],
+            };
+            dirIndex.set(key, dir);
+            parentDir.children.push(dir);
+          }
+          parentDir = dir;
+        } else {
+          parentDir.children.push({
+            name: segment,
+            fullPath,
+            isDir: false,
+          });
+        }
       }
     }
 
-    // Merge dirs and files, sort
-    const allEntries = [
-      ...Array.from(dirSet).map((d) => ({ path: d, isDir: true })),
-      ...paths.map((p) => ({
-        path: p.slice(normalizedPath.length),
-        isDir: false,
-      })),
-    ].sort((a, b) => a.path.localeCompare(b.path));
-
-    for (let i = 0; i < allEntries.length; i++) {
-      const entry = allEntries[i];
-      if (!entry) continue;
-      const depth = entry.path.split("/").length - 1;
-      const isLast =
-        i === allEntries.length - 1 ||
-        (allEntries[i + 1]?.path.split("/").length ?? 0) - 1 <= depth;
-      const prefix = isLast ? "└── " : "├── ";
-      const indent = "│   ".repeat(depth);
-      const name = entry.path.split("/").pop() ?? "";
-      const suffix = entry.isDir ? "/" : "";
-      lines.push(`${indent}${prefix}${name}${suffix}`);
+    // Sort each directory's children: dirs first, then alphabetical
+    for (const dir of dirIndex.values()) {
+      dir.children.sort((a, b) => {
+        if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
     }
 
-    if (items.length >= maxItems) {
-      lines.push(`... (truncated at ${maxItems} items)`);
-    }
+    const truncatedDirs: Array<{
+      path: string;
+      shown: number;
+      total: number;
+    }> = [];
+    const depthLimitedDirs: string[] = [];
+
+    const lines: string[] = [path];
+
+    const render = (
+      dir: DirNode,
+      indent: string,
+      currentDepth: number,
+    ): void => {
+      const children = dir.children;
+      const total = children.length;
+      const shown = Math.min(total, itemsPerDir);
+      const visible = children.slice(0, shown);
+      const overflow = total - shown;
+
+      if (overflow > 0) {
+        truncatedDirs.push({
+          path: stripTrailingSlash(dir.fullPath),
+          shown,
+          total,
+        });
+      }
+
+      for (let i = 0; i < visible.length; i++) {
+        const child = visible[i];
+        if (!child) continue;
+        const isLastVisible = i === visible.length - 1 && overflow === 0;
+        const connector = isLastVisible ? "└── " : "├── ";
+        const childIndent = isLastVisible ? "    " : "│   ";
+
+        if (child.isDir) {
+          const atDepthLimit = currentDepth + 1 >= maxDepth;
+          if (atDepthLimit && child.children.length > 0) {
+            depthLimitedDirs.push(stripTrailingSlash(child.fullPath));
+            const subCount = countDescendants(child);
+            lines.push(
+              `${indent}${connector}${child.name}/ (${subCount} ${
+                subCount === 1 ? "item" : "items"
+              }, drill in)`,
+            );
+          } else {
+            lines.push(`${indent}${connector}${child.name}/`);
+            render(child, indent + childIndent, currentDepth + 1);
+          }
+        } else {
+          lines.push(`${indent}${connector}${child.name}`);
+        }
+      }
+
+      if (overflow > 0) {
+        lines.push(`${indent}└── ... (+${overflow} more)`);
+      }
+    };
+
+    render(root, "", 0);
 
-    return { tree: lines.join("\n"), is_error: false };
+    const hint = buildHint({
+      truncatedDirs,
+      depthLimitedDirs,
+      totalItems,
+    });
+
+    return {
+      tree: lines.join("\n"),
+      is_error: false,
+      total_items: totalItems,
+      truncated_dirs: truncatedDirs,
+      hint,
+    };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;
+
+function stripTrailingSlash(p: string): string {
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+
+function countDescendants(dir: DirNode): number {
+  let count = 0;
+  for (const child of dir.children) {
+    count += 1;
+    if (child.isDir) count += countDescendants(child);
+  }
+  return count;
+}
+
+function buildHint(args: {
+  truncatedDirs: Array<{ path: string; shown: number; total: number }>;
+  depthLimitedDirs: string[];
+  totalItems: number;
+}): string {
+  const { truncatedDirs, depthLimitedDirs } = args;
+  const parts: string[] = [];
+
+  if (truncatedDirs.length > 0) {
+    const first = truncatedDirs[0];
+    if (first) {
+      parts.push(
+        `${truncatedDirs.length} ${truncatedDirs.length === 1 ? "directory was" : "directories were"} capped by items_per_dir; raise items_per_dir or call context_tree with path="${first.path}".`,
+      );
+    }
+  }
+
+  if (depthLimitedDirs.length > 0) {
+    const first = depthLimitedDirs[0];
+    if (first) {
+      parts.push(
+        `${depthLimitedDirs.length} ${depthLimitedDirs.length === 1 ? "directory was" : "directories were"} not expanded due to max_depth; raise max_depth or call context_tree with path="${first}".`,
+      );
+    }
+  }
+
+  if (parts.length === 0) return "Tree is complete.";
+  return parts.join(" ");
+}

package/src/tools/file/copy.ts

@@ -18,10 +18,10 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const fileCopyTool = {
-  name: "file_copy",
-  description: "Copy a file in the virtual filesystem.",
-  group: "file",
+export const contextCopyTool = {
+  name: "context_copy",
+  description: "Copy a context item.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {

package/src/tools/file/count-lines.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { getContextItemByPath } from "../../db/context.ts";
+import { resolveContextItemOrThrow } from "../../db/context.ts";
 import type { ToolDefinition } from "../tool.ts";
 
 const inputSchema = z.object({
-  path: z.string().describe("File path"),
+  path: z.string().describe("File path or context item ID"),
 });
 
 const outputSchema = z.object({
@@ -11,15 +11,14 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const fileCountLinesTool = {
-  name: "file_count_lines",
-  description: "Count the number of lines in a text file.",
-  group: "file",
+export const contextCountLinesTool = {
+  name: "context_count_lines",
+  description: "Count the number of lines in a text context item.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {
-    const item = await getContextItemByPath(ctx.conn, input.path);
-    if (!item) throw new Error(`Not found: ${input.path}`);
+    const item = await resolveContextItemOrThrow(ctx.conn, input.path);
     if (item.content == null) throw new Error(`No text content: ${input.path}`);
 
     return { lines: item.content.split("\n").length, is_error: false };

package/src/tools/file/delete.ts

@@ -22,10 +22,10 @@ const outputSchema = z.object({
   is_error: z.boolean(),
 });
 
-export const fileDeleteTool = {
-  name: "file_delete",
-  description: "Delete a file or directory from the virtual filesystem.",
-  group: "file",
+export const contextDeleteTool = {
+  name: "context_delete",
+  description: "Delete a context item or directory.",
+  group: "context",
   inputSchema,
   outputSchema,
   execute: async (input, ctx) => {