anyclaude-sdk 0.1.0

package/dist/team/taskBoard.js

@@ -0,0 +1,73 @@
+// In-memory task board shared across the coordinator and its workers. Tasks
+// carry ownership, status, and dependency edges (blocks / blockedBy) so the
+// coordinator can decompose work and gate execution on prerequisites.
+export class TaskBoard {
+    constructor() {
+        this.tasks = new Map();
+        this.counter = 0;
+    }
+    create(input) {
+        const now = Date.now();
+        const id = `task_${++this.counter}`;
+        const task = {
+            id,
+            subject: input.subject,
+            description: input.description,
+            owner: input.owner,
+            status: 'pending',
+            blocks: [],
+            blockedBy: input.blockedBy ? [...input.blockedBy] : [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.tasks.set(id, task);
+        // Maintain the reverse edge on prerequisites.
+        for (const dep of task.blockedBy) {
+            const d = this.tasks.get(dep);
+            if (d && !d.blocks.includes(id))
+                d.blocks.push(id);
+        }
+        return task;
+    }
+    update(id, patch) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return null;
+        Object.assign(t, patch);
+        t.updatedAt = Date.now();
+        return t;
+    }
+    get(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    list(filter) {
+        let out = [...this.tasks.values()];
+        if (filter?.status)
+            out = out.filter((t) => t.status === filter.status);
+        if (filter?.owner)
+            out = out.filter((t) => t.owner === filter.owner);
+        return out;
+    }
+    /** Atomically claim an unowned/pending task. Null if already claimed. */
+    claim(id, owner) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return null;
+        if (t.owner || t.status !== 'pending')
+            return null;
+        t.owner = owner;
+        t.status = 'in_progress';
+        t.updatedAt = Date.now();
+        return t;
+    }
+    /** True if any prerequisite is not yet completed. */
+    isBlocked(id) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return false;
+        return t.blockedBy.some((dep) => {
+            const d = this.tasks.get(dep);
+            return !d || d.status !== 'completed';
+        });
+    }
+}

package/dist/team/tools.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '../tools/types.js';
+export declare const sendMessage: Tool;
+export declare const taskCreate: Tool;
+export declare const taskUpdate: Tool;
+export declare const taskGet: Tool;
+export declare const boardList: Tool;
+export declare const TEAM_TOOLS: Tool[];

package/dist/team/tools.js

@@ -0,0 +1,190 @@
+// Coordinator/teammate tools: inter-agent messaging + task board CRUD. The
+// Mailbox and TaskBoard live on the ToolContext (injected by the agent loop as
+// `ctx.mailbox` / `ctx.board`); accessed via casts here so this file compiles
+// standalone before the loop wiring lands.
+function getMailbox(ctx) {
+    return ctx.mailbox;
+}
+function getBoard(ctx) {
+    return ctx.board;
+}
+function agentName(ctx) {
+    return ctx.agentName ?? 'coordinator';
+}
+const NOT_ENABLED = { content: 'Teammates are not enabled for this session.', isError: true };
+function renderTask(t) {
+    const deps = t.blockedBy.length ? ` blockedBy=[${t.blockedBy.join(',')}]` : '';
+    return `${t.id} [${t.status}]${t.owner ? ` @${t.owner}` : ''} — ${t.subject}${deps}`;
+}
+export const sendMessage = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'send_message',
+            description: 'Send a message to a teammate (by name) via the shared mailbox. Use to direct workers, hand off context, or coordinate.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    to: { type: 'string', description: 'Recipient teammate name.' },
+                    text: { type: 'string', description: 'Message body.' },
+                },
+                required: ['to', 'text'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const mailbox = getMailbox(ctx);
+        if (!mailbox)
+            return { ...NOT_ENABLED };
+        const to = String(input.to ?? '').trim();
+        const text = String(input.text ?? '');
+        if (!to || !text)
+            return { content: 'Error: `to` and `text` are required.', isError: true };
+        const id = mailbox.send(agentName(ctx), to, text);
+        return { content: `Message ${id} sent to ${to}.` };
+    },
+};
+export const taskCreate = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'task_create',
+            description: 'Create a task on the shared board. Set blocked_by to gate this task on prerequisites (their ids).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    subject: { type: 'string', description: 'Short task title.' },
+                    description: { type: 'string', description: 'What needs to be done.' },
+                    owner: { type: 'string', description: 'Assign to a teammate name.' },
+                    blocked_by: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Task ids that must complete first.',
+                    },
+                },
+                required: ['subject'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const board = getBoard(ctx);
+        if (!board)
+            return { ...NOT_ENABLED };
+        const subject = String(input.subject ?? '').trim();
+        if (!subject)
+            return { content: 'Error: `subject` is required.', isError: true };
+        const blockedBy = Array.isArray(input.blocked_by)
+            ? input.blocked_by.map(String)
+            : undefined;
+        const t = board.create({
+            subject,
+            description: input.description ? String(input.description) : undefined,
+            owner: input.owner ? String(input.owner) : undefined,
+            blockedBy,
+        });
+        return { content: `Created ${renderTask(t)}` };
+    },
+};
+export const taskUpdate = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'task_update',
+            description: 'Update a board task — status, owner, subject, or description.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: 'Task id.' },
+                    status: {
+                        type: 'string',
+                        enum: ['pending', 'in_progress', 'completed', 'failed'],
+                        description: 'New status.',
+                    },
+                    owner: { type: 'string' },
+                    subject: { type: 'string' },
+                    description: { type: 'string' },
+                },
+                required: ['id'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const board = getBoard(ctx);
+        if (!board)
+            return { ...NOT_ENABLED };
+        const id = String(input.id ?? '');
+        const patch = {};
+        if (input.status)
+            patch.status = input.status;
+        if (input.owner)
+            patch.owner = String(input.owner);
+        if (input.subject)
+            patch.subject = String(input.subject);
+        if (input.description)
+            patch.description = String(input.description);
+        const t = board.update(id, patch);
+        if (!t)
+            return { content: `No such task: ${id}`, isError: true };
+        return { content: `Updated ${renderTask(t)}` };
+    },
+};
+export const taskGet = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'task_get',
+            description: 'Get one board task by id (full detail).',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string', description: 'Task id.' } },
+                required: ['id'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const board = getBoard(ctx);
+        if (!board)
+            return { ...NOT_ENABLED };
+        const t = board.get(String(input.id ?? ''));
+        if (!t)
+            return { content: `No such task: ${input.id}`, isError: true };
+        const blocked = board.isBlocked(t.id) ? ' (blocked)' : '';
+        return {
+            content: `${renderTask(t)}${blocked}\n` +
+                (t.description ? `description: ${t.description}\n` : '') +
+                (t.blocks.length ? `blocks: ${t.blocks.join(', ')}` : ''),
+        };
+    },
+};
+export const boardList = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'board_list',
+            description: 'List tasks on the shared board, optionally filtered by status or owner.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    status: {
+                        type: 'string',
+                        enum: ['pending', 'in_progress', 'completed', 'failed'],
+                    },
+                    owner: { type: 'string' },
+                },
+            },
+        },
+    },
+    async run(input, ctx) {
+        const board = getBoard(ctx);
+        if (!board)
+            return { ...NOT_ENABLED };
+        const tasks = board.list({
+            status: input.status,
+            owner: input.owner ? String(input.owner) : undefined,
+        });
+        if (!tasks.length)
+            return { content: 'Board is empty.' };
+        return { content: tasks.map(renderTask).join('\n') };
+    },
+};
+export const TEAM_TOOLS = [sendMessage, taskCreate, taskUpdate, taskGet, boardList];

package/dist/tools/bash.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const bash: Tool;

package/dist/tools/bash.js

@@ -0,0 +1,45 @@
+const DESCRIPTION = `Executes a shell command in the workspace and returns its combined output (stdout + stderr).
+
+The shell depends on the workspace: a POSIX shell (sh/bash) on Linux/macOS or in WebContainer's jsh, and cmd.exe on Windows. Use commands appropriate to the host OS. The working directory persists between commands; shell state does not.
+
+Prefer the dedicated tools (read_file, write_file, edit_file, glob, grep, list_files) over shell equivalents (cat, sed, find, grep, ls) for a better experience.`;
+export const bash = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The bash command to run.' },
+                    timeout_ms: {
+                        type: 'number',
+                        description: 'Optional timeout in milliseconds (default 120000).',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Short human-readable description of what the command does.',
+                    },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const command = String(input.command ?? '').trim();
+        if (!command) {
+            return { content: 'Error: `command` is required.', isError: true };
+        }
+        const timeout = typeof input.timeout_ms === 'number' ? input.timeout_ms : undefined;
+        const { output, exitCode } = await ctx.exec.exec(command, timeout);
+        if (exitCode !== 0) {
+            const body = output || '(no output)';
+            return {
+                content: `Command exited with code ${exitCode}:\n${body}`,
+                isError: true,
+            };
+        }
+        return { content: output || '(command produced no output)' };
+    },
+};

package/dist/tools/config.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const config: Tool;

package/dist/tools/config.js

@@ -0,0 +1,44 @@
+const DESCRIPTION = `Read or write session configuration key/value pairs.
+
+actions: "get" (requires key), "set" (requires key + value), "list". Config is session-scoped and visible to subsequent tool calls; use it to remember small preferences or flags during a task.`;
+export const config = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'config',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', enum: ['get', 'set', 'list'], description: 'Operation to perform.' },
+                    key: { type: 'string', description: 'Config key (for get/set).' },
+                    value: { description: 'Value to store (for set). Any JSON value.' },
+                },
+                required: ['action'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        if (!ctx.store)
+            return { content: 'Session store unavailable.', isError: true };
+        const cfg = (ctx.store.config ??= {});
+        const action = String(input.action ?? '');
+        const key = input.key != null ? String(input.key) : '';
+        if (action === 'list') {
+            const keys = Object.keys(cfg);
+            return { content: keys.length ? JSON.stringify(cfg, null, 2) : '(empty config)' };
+        }
+        if (action === 'get') {
+            if (!key)
+                return { content: 'Error: `key` is required for get.', isError: true };
+            return { content: key in cfg ? JSON.stringify(cfg[key]) : `(unset: ${key})` };
+        }
+        if (action === 'set') {
+            if (!key)
+                return { content: 'Error: `key` is required for set.', isError: true };
+            cfg[key] = input.value;
+            return { content: `Set ${key} = ${JSON.stringify(input.value)}` };
+        }
+        return { content: `Unknown action "${action}". Use get/set/list.`, isError: true };
+    },
+};

package/dist/tools/define.d.ts

@@ -0,0 +1,18 @@
+import type { Tool, ToolContext, ToolResult } from './types.js';
+export interface DefineToolSpec {
+    /** Tool name the model calls (snake_case recommended). */
+    name: string;
+    /** Natural-language description shown to the model. */
+    description: string;
+    /** Argument schema: JSON-Schema `properties` + optional `required`. Defaults to no args. */
+    parameters?: {
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    /** Execution method. Receives the parsed input + the tool context (fs/exec/cwd/signal/…). */
+    run: (input: Record<string, unknown>, ctx: ToolContext) => Promise<ToolResult> | ToolResult;
+    /** Optional: spill threshold for large outputs (see Tool.maxResultChars). */
+    maxResultChars?: number;
+}
+/** Build a `Tool` from a friendly spec. */
+export declare function defineTool(spec: DefineToolSpec): Tool;

package/dist/tools/define.js

@@ -0,0 +1,21 @@
+/** Build a `Tool` from a friendly spec. */
+export function defineTool(spec) {
+    const tool = {
+        def: {
+            type: 'function',
+            function: {
+                name: spec.name,
+                description: spec.description,
+                parameters: {
+                    type: 'object',
+                    properties: spec.parameters?.properties ?? {},
+                    ...(spec.parameters?.required ? { required: spec.parameters.required } : {}),
+                },
+            },
+        },
+        run: async (input, ctx) => spec.run(input, ctx),
+    };
+    if (spec.maxResultChars !== undefined)
+        tool.maxResultChars = spec.maxResultChars;
+    return tool;
+}

package/dist/tools/delete_file.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const deleteFile: Tool;

package/dist/tools/delete_file.js

@@ -0,0 +1,33 @@
+const DESCRIPTION = `Deletes a file or directory from the workspace filesystem (recursive, force).`;
+export const deleteFile = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to delete.' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const path = String(input.path ?? '');
+        if (!path)
+            return { content: 'Error: `path` is required.', isError: true };
+        try {
+            await ctx.fs.deleteFile(path);
+        }
+        catch (err) {
+            return {
+                content: `Error deleting ${path}: ${err.message}`,
+                isError: true,
+            };
+        }
+        ctx.readFiles.delete(path);
+        return { content: `Deleted ${path}` };
+    },
+};

package/dist/tools/edit_file.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const editFile: Tool;

package/dist/tools/edit_file.js

@@ -0,0 +1,93 @@
+const DESCRIPTION = `Performs an exact string replacement in a file.
+
+- You must read the file with read_file at least once before editing it; otherwise this tool errors.
+- \`old_string\` must match the file contents exactly (including whitespace) and must be unique unless \`replace_all\` is set.
+- If \`old_string\` is not unique, the edit fails — provide more surrounding context, or set \`replace_all: true\` to replace every occurrence.`;
+/** Count non-overlapping occurrences of needle in haystack. */
+function countOccurrences(haystack, needle) {
+    if (needle === '')
+        return 0;
+    let count = 0;
+    let idx = haystack.indexOf(needle);
+    while (idx !== -1) {
+        count++;
+        idx = haystack.indexOf(needle, idx + needle.length);
+    }
+    return count;
+}
+export const editFile = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to edit.' },
+                    old_string: { type: 'string', description: 'Exact text to find.' },
+                    new_string: {
+                        type: 'string',
+                        description: 'Replacement text (must differ from old_string).',
+                    },
+                    replace_all: {
+                        type: 'boolean',
+                        description: 'Replace every occurrence instead of requiring uniqueness.',
+                    },
+                },
+                required: ['path', 'old_string', 'new_string'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const path = String(input.path ?? '');
+        if (!path)
+            return { content: 'Error: `path` is required.', isError: true };
+        if (!ctx.readFiles.has(path)) {
+            return {
+                content: `Error: you must read ${path} with read_file before editing it.`,
+                isError: true,
+            };
+        }
+        const oldString = typeof input.old_string === 'string' ? input.old_string : '';
+        const newString = typeof input.new_string === 'string' ? input.new_string : '';
+        const replaceAll = input.replace_all === true;
+        if (oldString === newString) {
+            return {
+                content: 'Error: `old_string` and `new_string` are identical.',
+                isError: true,
+            };
+        }
+        const text = await ctx.fs.readFile(path);
+        if (text === null) {
+            return { content: `Error: file not found: ${path}`, isError: true };
+        }
+        const occurrences = countOccurrences(text, oldString);
+        if (occurrences === 0) {
+            return {
+                content: `Error: \`old_string\` not found in ${path}.`,
+                isError: true,
+            };
+        }
+        if (!replaceAll && occurrences > 1) {
+            return {
+                content: `Error: \`old_string\` is not unique in ${path} (found ${occurrences} occurrences). Provide more context or set replace_all: true.`,
+                isError: true,
+            };
+        }
+        const updated = replaceAll
+            ? text.split(oldString).join(newString)
+            : text.replace(oldString, newString);
+        try {
+            await ctx.fs.writeFile(path, updated);
+        }
+        catch (err) {
+            return {
+                content: `Error writing ${path}: ${err.message}`,
+                isError: true,
+            };
+        }
+        const replaced = replaceAll ? occurrences : 1;
+        return { content: `Edited ${path} (${replaced} replacement${replaced === 1 ? '' : 's'}).` };
+    },
+};

package/dist/tools/fileTypes.d.ts

@@ -0,0 +1,32 @@
+import type { FileReadLimits } from './types.js';
+/**
+ * Binary file extensions to skip for text-based reads. Ported from Claude
+ * Code's constants/files.ts. `.pdf` and image types are included here, but
+ * read_file dispatches those to dedicated handlers before the binary check.
+ */
+export declare const BINARY_EXTENSIONS: Set<string>;
+export declare const IMAGE_EXTENSIONS: Set<string>;
+export declare const NOTEBOOK_EXTENSION = ".ipynb";
+export declare const PDF_EXTENSION = ".pdf";
+/** Default read caps (mirrors Claude Code: 256 KB / 25k tokens / 20 PDF pages). */
+export declare const DEFAULT_FILE_READ_LIMITS: FileReadLimits;
+/** Lowercased extension including the leading dot, or '' if none. */
+export declare function extOf(path: string): string;
+export declare function hasBinaryExtension(path: string): boolean;
+export declare function isImageExtension(path: string): boolean;
+export declare function isPdfExtension(path: string): boolean;
+export declare function isNotebookExtension(path: string): boolean;
+/** Map an image extension to its MIME type. */
+export declare function imageMediaType(ext: string): string;
+/** Detect image MIME type from magic bytes, or null if unrecognized. */
+export declare function detectImageFormatFromBytes(bytes: Uint8Array): string | null;
+/** Heuristic: a NUL byte in the first 8 KB means the file is binary. */
+export declare function looksBinary(bytes: Uint8Array): boolean;
+/** Rough token estimate (~4 chars/token). */
+export declare function roughTokenCount(text: string): number;
+/** Base64-encode bytes. Works in browser (btoa) and Node (Buffer). */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Base64-decode to bytes. Works in browser (atob) and Node (Buffer). */
+export declare function base64ToBytes(b64: string): Uint8Array;
+/** Human-readable byte size. */
+export declare function formatBytes(n: number): string;