anyclaude-sdk 0.1.0

package/dist/commands/index.js

@@ -0,0 +1,56 @@
+// Slash-command entry point. The agent loop calls runSlashCommand() when a user
+// message is a string beginning with '/'. Returns null when the text isn't a
+// recognized command (the loop then treats it as a normal prompt).
+import { BUILTIN_COMMANDS } from './builtins.js';
+export * from './types.js';
+export { BUILTIN_COMMANDS } from './builtins.js';
+/** Parse `/name args...` → { name (lowercased, no slash), args }. Null if not a command. */
+export function parseSlashCommand(text) {
+    const t = text.trimStart();
+    if (!t.startsWith('/'))
+        return null;
+    const body = t.slice(1);
+    const sp = body.search(/\s/);
+    if (sp === -1)
+        return { name: body.toLowerCase(), args: '' };
+    return { name: body.slice(0, sp).toLowerCase(), args: body.slice(sp + 1).trim() };
+}
+/**
+ * Resolve and execute a slash command. Returns the command's SlashOutcome, or
+ * null when the text isn't a slash command or names an unknown command (so the
+ * caller can fall back to treating it as a normal prompt).
+ */
+export async function runSlashCommand(text, ctx) {
+    const parsed = parseSlashCommand(text);
+    if (!parsed)
+        return null;
+    // User commands override built-ins by name.
+    const merged = mergeCommands(BUILTIN_COMMANDS, ctx.commands ?? []);
+    const command = merged.find((c) => c.name === parsed.name);
+    if (!command)
+        return null;
+    const fullCtx = { ...ctx, commands: merged };
+    return await command.run(parsed.args, fullCtx);
+}
+function mergeCommands(builtins, user) {
+    const byName = new Map();
+    for (const c of builtins)
+        byName.set(c.name, c);
+    for (const c of user)
+        byName.set(c.name, c); // user overrides
+    return [...byName.values()];
+}
+/**
+ * Define a custom prompt-template command (like a Claude Code markdown command).
+ * `$ARGUMENTS` in the template is replaced with the invocation args.
+ */
+export function promptCommand(name, description, prompt, argumentHint) {
+    return {
+        name,
+        description,
+        argumentHint,
+        run(args) {
+            return { expandedPrompt: prompt.replace(/\$ARGUMENTS/g, args) };
+        },
+    };
+}

package/dist/commands/types.d.ts

@@ -0,0 +1,110 @@
+import type { ChatMsg, Usage } from '../types/index.js';
+/** Minimal structural view of the LLM client a command may use (e.g. /compact). */
+export interface CommandLLM {
+    streamChat(messages: ChatMsg[], opts: {
+        model?: string;
+        signal?: AbortSignal;
+        onToken: (delta: string) => void;
+    }): Promise<{
+        text: string;
+    }>;
+}
+export interface SlashCommandContext {
+    /** Live reference to the conversation history (history[0] is the system msg). Read-only intent. */
+    history: ChatMsg[];
+    /** Tools currently available to the agent. */
+    tools: Array<{
+        name: string;
+        description: string;
+    }>;
+    /** Active model id, if known. */
+    model?: string;
+    /** Working directory. */
+    cwd: string;
+    /** Accumulated token usage so far, if tracked. */
+    usage?: Usage;
+    /** Mutable session state. */
+    store?: {
+        todos: unknown[];
+    };
+    /** Abort signal for long-running commands (e.g. /compact). */
+    signal?: AbortSignal;
+    /** LLM client, when available (required by /compact). */
+    llm?: CommandLLM;
+    /** The full merged command registry (built-ins + user commands), for /help. */
+    commands: SlashCommand[];
+    /** Current session id. */
+    sessionId?: string;
+    /** Session store, for /sessions, /resume, /rename. */
+    sessionStore?: {
+        list(): Promise<Array<{
+            sessionId: string;
+            title?: string;
+            updatedAt: number;
+            messageCount: number;
+        }>>;
+        load(id: string): Promise<ChatMsg[] | null>;
+        rename(id: string, title: string): Promise<void>;
+        remove(id: string): Promise<void>;
+    };
+    /** Paths the model has read this session, for /files. */
+    readFiles?: Set<string>;
+    /** Configured sub-agents, for /agents. */
+    agents?: Record<string, {
+        description: string;
+        model?: string;
+    }>;
+    /** MCP server statuses, for /mcp. */
+    mcpServers?: Array<{
+        name: string;
+        status: string;
+    }>;
+    /** Active permission mode, for /permissions. */
+    permissionMode?: string;
+    /** Background tasks, for /tasks. */
+    background?: {
+        list(): Array<{
+            id: string;
+            status: string;
+            description: string;
+        }>;
+    };
+    /** Team task board, for /board. */
+    board?: {
+        list(): Array<{
+            id: string;
+            status: string;
+            owner?: string;
+            subject: string;
+        }>;
+    };
+    /** Shell executor, for /diff. */
+    exec?: (command: string) => Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+    /** Filesystem, for /memory. */
+    fs?: {
+        readFile(path: string): Promise<string | null>;
+    };
+    /** Persistent memory store, for /memory. */
+    memory?: {
+        render(): Promise<string>;
+    };
+}
+export interface SlashOutcome {
+    /** Text surfaced to the user as a system `local_command_output` message. */
+    systemText?: string;
+    /** Replace the user's turn with this prompt and run the LLM normally. */
+    expandedPrompt?: string;
+    /** Replace the entire conversation history verbatim (include the system message). */
+    newHistory?: ChatMsg[];
+    /** Signals a compaction happened (loop emits a compact_boundary message). */
+    compacted?: boolean;
+}
+export interface SlashCommand {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    run(args: string, ctx: SlashCommandContext): Promise<SlashOutcome> | SlashOutcome;
+}

package/dist/commands/types.js

@@ -0,0 +1,5 @@
+// Slash-command system types. Ports Claude Code's /compact, /clear, /help, etc.
+// The agent loop invokes runSlashCommand() when a user message is a string that
+// starts with '/'. A command returns a SlashOutcome describing what the loop
+// should do (surface text, expand into a prompt, and/or rewrite history).
+export {};

package/dist/compact.d.ts

@@ -0,0 +1,22 @@
+import type { ChatMsg } from './types/index.js';
+/** Rough token estimate for a transcript (≈4 chars/token). */
+export declare function estimateTokens(history: ChatMsg[]): number;
+interface SummarizerLLM {
+    streamChat(messages: ChatMsg[], opts: {
+        model?: string;
+        signal?: AbortSignal;
+        onToken: (d: string) => void;
+    }): Promise<{
+        text: string;
+    }>;
+}
+/**
+ * Summarize `history` into a new transcript `[systemMsg, { user: summary }]`.
+ * Returns null if there's nothing to compact or the LLM produced no summary.
+ */
+export declare function summarizeHistory(history: ChatMsg[], llm: SummarizerLLM, opts?: {
+    model?: string;
+    signal?: AbortSignal;
+    focus?: string;
+}): Promise<ChatMsg[] | null>;
+export {};

package/dist/compact.js

@@ -0,0 +1,67 @@
+// Conversation compaction: summarize a long transcript into a compact form so
+// the context window doesn't overflow. Used by auto-compaction in the agent
+// loop (and shareable with the /compact slash command).
+/** Rough token estimate for a transcript (≈4 chars/token). */
+export function estimateTokens(history) {
+    let chars = 0;
+    for (const m of history) {
+        chars += typeof m.content === 'string' ? m.content.length : JSON.stringify(m.content).length;
+        if (m.tool_calls)
+            chars += JSON.stringify(m.tool_calls).length;
+    }
+    return Math.round(chars / 4);
+}
+/** Render a transcript (excluding the system message) as plain text. */
+function transcript(history) {
+    return history
+        .slice(1)
+        .map((m) => {
+        const body = typeof m.content === 'string'
+            ? m.content
+            : m.content
+                .map((b) => b.type === 'text'
+                ? b.text
+                : b.type === 'tool_use'
+                    ? `[tool_use ${b.name} ${JSON.stringify(b.input)}]`
+                    : b.type === 'tool_result'
+                        ? `[tool_result ${typeof b.content === 'string' ? b.content : '...'}]`
+                        : `[${b.type}]`)
+                .join('\n');
+        const calls = m.tool_calls?.length
+            ? ' ' + m.tool_calls.map((c) => `[call ${c.function.name}(${c.function.arguments})]`).join(' ')
+            : '';
+        return `${m.role.toUpperCase()}: ${body}${calls}`;
+    })
+        .join('\n\n');
+}
+/**
+ * Summarize `history` into a new transcript `[systemMsg, { user: summary }]`.
+ * Returns null if there's nothing to compact or the LLM produced no summary.
+ */
+export async function summarizeHistory(history, llm, opts = {}) {
+    if (history.length <= 2)
+        return null;
+    const instruction = 'Summarize the following conversation transcript concisely but completely. ' +
+        'Preserve: the user’s goals, key decisions, files created/edited (with paths), ' +
+        'important findings, and any unfinished work or next steps. Use short sections.' +
+        (opts.focus ? `\nPay special attention to: ${opts.focus}` : '');
+    const messages = [
+        { role: 'system', content: 'You are a precise conversation summarizer.' },
+        { role: 'user', content: `${instruction}\n\n---\n${transcript(history)}` },
+    ];
+    let summary = '';
+    try {
+        const res = await llm.streamChat(messages, {
+            model: opts.model,
+            signal: opts.signal,
+            onToken: () => { },
+        });
+        summary = res.text?.trim() ?? '';
+    }
+    catch {
+        return null;
+    }
+    if (!summary)
+        return null;
+    return [history[0], { role: 'user', content: `Summary of the conversation so far:\n${summary}` }];
+}

package/dist/fs/dexie.d.ts

@@ -0,0 +1,57 @@
+import type { FileSystem } from '../types/index.js';
+/** A stored filesystem node (file or directory). */
+export interface FsNode {
+    /** Normalized absolute path (primary key). */
+    path: string;
+    /** Parent directory path (indexed for readdir). '' for the root. */
+    parent: string;
+    /** Final path segment. */
+    name: string;
+    kind: 'file' | 'dir';
+    size: number;
+    /** Last-modified time, epoch ms. */
+    mtime: number;
+    /** POSIX-style mode bits. */
+    mode: number;
+    /** File contents (files only). */
+    data?: Uint8Array;
+    /** Symlink target (symlinks only). */
+    symlink?: string;
+}
+export interface DexieFileSystemOptions {
+    cwd?: string;
+    /** Wipe all nodes on first open (fresh filesystem). */
+    resetOnInit?: boolean;
+}
+export declare class DexieFileSystem implements FileSystem {
+    readonly cwd: string;
+    private readonly dbName;
+    private readonly resetOnInit;
+    private db;
+    private opening;
+    constructor(dbName?: string, options?: DexieFileSystemOptions);
+    private open;
+    private resolve;
+    /** Create every ancestor directory of `path` (and optionally `path` itself). */
+    private ensureDirs;
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+    /** Return node metadata (without the data blob), or null if missing. */
+    stat(path: string): Promise<Omit<FsNode, 'data'> | null>;
+    exists(path: string): Promise<boolean>;
+    chmod(path: string, mode: number): Promise<void>;
+    /** Create a symlink node at `linkPath` pointing at `target`. */
+    symlink(target: string, linkPath: string): Promise<void>;
+    /** Move/rename a node (and its descendants, for directories). */
+    rename(from: string, to: string): Promise<void>;
+    /** Wipe the entire filesystem (then recreate the root). */
+    clear(): Promise<void>;
+}

package/dist/fs/dexie.js

@@ -0,0 +1,243 @@
+// DexieFileSystem — a durable, full Linux-style filesystem backed by IndexedDB
+// via Dexie. Implements the SDK's FileSystem interface plus power-user methods
+// (stat/chmod/symlink/rename/exists/clear).
+//
+// Model: an inode-per-path table keyed by the normalized absolute path, with a
+// `parent` index for O(children) readdir. Persistent across reloads, queryable,
+// available in every browser that has IndexedDB.
+//
+// `dexie` is an OPTIONAL peer dependency — imported dynamically so this module
+// loads even when Dexie isn't installed (the error surfaces only on first use).
+import { ancestors, basename, dirname, resolvePath } from '../util/paths.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const DEFAULT_FILE_MODE = 0o644;
+const DEFAULT_DIR_MODE = 0o755;
+export class DexieFileSystem {
+    constructor(dbName = 'bcs-fs', options = {}) {
+        this.db = null;
+        this.opening = null;
+        this.dbName = dbName;
+        this.cwd = options.cwd ?? '/';
+        this.resetOnInit = options.resetOnInit ?? false;
+    }
+    // ---- lifecycle ----
+    async open() {
+        if (this.db)
+            return this.db;
+        if (this.opening)
+            return this.opening;
+        this.opening = (async () => {
+            // @ts-ignore optional peer dependency, resolved at runtime
+            const mod = await import('dexie');
+            const Dexie = mod.default ?? mod;
+            const db = new Dexie(this.dbName);
+            db.version(1).stores({
+                // primary key `path`, secondary index `parent`
+                nodes: 'path, parent',
+            });
+            this.db = db;
+            if (this.resetOnInit)
+                await db.nodes.clear();
+            // Ensure the root directory exists.
+            const root = await db.nodes.get('/');
+            if (!root) {
+                await db.nodes.put({
+                    path: '/',
+                    parent: '',
+                    name: '',
+                    kind: 'dir',
+                    size: 0,
+                    mtime: Date.now(),
+                    mode: DEFAULT_DIR_MODE,
+                });
+            }
+            return db;
+        })();
+        return this.opening;
+    }
+    resolve(p) {
+        return resolvePath(this.cwd, p);
+    }
+    /** Create every ancestor directory of `path` (and optionally `path` itself). */
+    async ensureDirs(db, path, includeSelf) {
+        const dirs = ancestors(path);
+        if (includeSelf)
+            dirs.push(path);
+        for (const dir of dirs) {
+            if (dir === '/' || dir === '')
+                continue;
+            const existing = await db.nodes.get(dir);
+            if (existing) {
+                if (existing.kind !== 'dir') {
+                    throw new Error(`ENOTDIR: '${dir}' exists and is not a directory`);
+                }
+                continue;
+            }
+            await db.nodes.put({
+                path: dir,
+                parent: dirname(dir),
+                name: basename(dir),
+                kind: 'dir',
+                size: 0,
+                mtime: Date.now(),
+                mode: DEFAULT_DIR_MODE,
+            });
+        }
+    }
+    // ---- FileSystem interface ----
+    async readFile(path) {
+        const bytes = await this.readBinary(path);
+        return bytes ? decoder.decode(bytes) : null;
+    }
+    async readBinary(path) {
+        try {
+            const db = await this.open();
+            const node = await db.nodes.get(this.resolve(path));
+            if (!node || node.kind !== 'file')
+                return null;
+            return node.data ?? new Uint8Array(0);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, contents) {
+        await this.writeBinary(path, encoder.encode(contents));
+    }
+    async writeBinary(path, data) {
+        const db = await this.open();
+        const abs = this.resolve(path);
+        await this.ensureDirs(db, abs, false);
+        const prev = await db.nodes.get(abs);
+        await db.nodes.put({
+            path: abs,
+            parent: dirname(abs),
+            name: basename(abs),
+            kind: 'file',
+            size: data.byteLength,
+            mtime: Date.now(),
+            mode: prev?.mode ?? DEFAULT_FILE_MODE,
+            data,
+        });
+    }
+    async deleteFile(path) {
+        const db = await this.open();
+        const abs = this.resolve(path);
+        if (abs === '/') {
+            await db.nodes.clear();
+            await this.open(); // recreate root
+            return;
+        }
+        const node = await db.nodes.get(abs);
+        await db.nodes.delete(abs);
+        if (node?.kind === 'dir') {
+            // rm -rf: remove all descendants (path prefix).
+            const descendants = await db.nodes.where('path').startsWith(abs + '/').primaryKeys();
+            for (const key of descendants)
+                await db.nodes.delete(key);
+        }
+    }
+    async readdir(path) {
+        try {
+            const db = await this.open();
+            const abs = this.resolve(path);
+            const node = await db.nodes.get(abs);
+            if (!node || node.kind !== 'dir')
+                return null;
+            const children = await db.nodes.where('parent').equals(abs).toArray();
+            return children.map((c) => ({ name: c.name, isDir: c.kind === 'dir' }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(path) {
+        const db = await this.open();
+        await this.ensureDirs(db, this.resolve(path), true);
+    }
+    // ---- power-user extensions ----
+    /** Return node metadata (without the data blob), or null if missing. */
+    async stat(path) {
+        try {
+            const db = await this.open();
+            const node = await db.nodes.get(this.resolve(path));
+            if (!node)
+                return null;
+            const { data: _data, ...meta } = node;
+            return meta;
+        }
+        catch {
+            return null;
+        }
+    }
+    async exists(path) {
+        const db = await this.open();
+        return (await db.nodes.get(this.resolve(path))) != null;
+    }
+    async chmod(path, mode) {
+        const db = await this.open();
+        const abs = this.resolve(path);
+        const node = await db.nodes.get(abs);
+        if (!node)
+            throw new Error(`ENOENT: no such file '${abs}'`);
+        node.mode = mode;
+        node.mtime = Date.now();
+        await db.nodes.put(node);
+    }
+    /** Create a symlink node at `linkPath` pointing at `target`. */
+    async symlink(target, linkPath) {
+        const db = await this.open();
+        const abs = this.resolve(linkPath);
+        await this.ensureDirs(db, abs, false);
+        await db.nodes.put({
+            path: abs,
+            parent: dirname(abs),
+            name: basename(abs),
+            kind: 'file',
+            size: target.length,
+            mtime: Date.now(),
+            mode: 0o777,
+            symlink: target,
+        });
+    }
+    /** Move/rename a node (and its descendants, for directories). */
+    async rename(from, to) {
+        const db = await this.open();
+        const src = this.resolve(from);
+        const dst = this.resolve(to);
+        const node = await db.nodes.get(src);
+        if (!node)
+            throw new Error(`ENOENT: no such file '${src}'`);
+        await this.ensureDirs(db, dst, false);
+        const move = (n, newPath) => ({
+            ...n,
+            path: newPath,
+            parent: dirname(newPath),
+            name: basename(newPath),
+            mtime: Date.now(),
+        });
+        if (node.kind === 'dir') {
+            const descendants = await db.nodes.where('path').startsWith(src + '/').toArray();
+            const moved = [move(node, dst)];
+            for (const d of descendants)
+                moved.push(move(d, dst + d.path.slice(src.length)));
+            await db.nodes.bulkPut(moved);
+            await db.nodes.delete(src);
+            for (const d of descendants)
+                await db.nodes.delete(d.path);
+        }
+        else {
+            await db.nodes.put(move(node, dst));
+            await db.nodes.delete(src);
+        }
+    }
+    /** Wipe the entire filesystem (then recreate the root). */
+    async clear() {
+        const db = await this.open();
+        await db.nodes.clear();
+        this.db = null;
+        this.opening = null;
+        await this.open();
+    }
+}

package/dist/fs/index.d.ts

@@ -0,0 +1,4 @@
+export { DexieFileSystem, type FsNode, type DexieFileSystemOptions, } from './dexie.js';
+export { OpfsFileSystem, type OpfsFileSystemOptions } from './opfs.js';
+export { seedLinuxTree, LINUX_DIRS, DEFAULT_HOME } from './linuxTree.js';
+export { MemoryFileSystem } from '../workspace/memory.js';

package/dist/fs/index.js

@@ -0,0 +1,13 @@
+// Persistent browser filesystems for browser-claude-sdk.
+//
+// - DexieFileSystem (recommended): IndexedDB-backed, durable, queryable, with
+//   metadata + power-user methods. Optional peer dependency `dexie`.
+// - OpfsFileSystem: Origin Private File System; native hierarchical handles,
+//   best for large binary files.
+// - seedLinuxTree: lay down a standard Linux FHS skeleton.
+export { DexieFileSystem, } from './dexie.js';
+export { OpfsFileSystem } from './opfs.js';
+export { seedLinuxTree, LINUX_DIRS, DEFAULT_HOME } from './linuxTree.js';
+// In-memory FileSystem (great for tests) — surfaced here alongside the
+// persistent backends for discoverability; it physically lives in workspace/.
+export { MemoryFileSystem } from '../workspace/memory.js';

package/dist/fs/linuxTree.d.ts

@@ -0,0 +1,11 @@
+import type { FileSystem } from '../types/index.js';
+export declare const DEFAULT_HOME = "/home/user";
+/** Standard Filesystem Hierarchy Standard directories we create. */
+export declare const LINUX_DIRS: string[];
+/**
+ * Idempotently create the Linux directory skeleton plus a few token files.
+ * Safe to call repeatedly (mkdir is recursive; writes overwrite identical content).
+ */
+export declare function seedLinuxTree(fs: FileSystem, opts?: {
+    home?: string;
+}): Promise<void>;

package/dist/fs/linuxTree.js

@@ -0,0 +1,43 @@
+// seedLinuxTree — populate a FileSystem with a standard FHS directory skeleton
+// so the agent sees a familiar Linux layout to work in.
+export const DEFAULT_HOME = '/home/user';
+/** Standard Filesystem Hierarchy Standard directories we create. */
+export const LINUX_DIRS = [
+    '/bin',
+    '/sbin',
+    '/etc',
+    '/home',
+    '/root',
+    '/tmp',
+    '/var',
+    '/var/log',
+    '/usr',
+    '/usr/bin',
+    '/usr/lib',
+    '/usr/local',
+    '/opt',
+    '/mnt',
+    '/proc',
+    '/sys',
+    '/dev',
+];
+const OS_RELEASE = `PRETTY_NAME="browser-claude-sdk sandbox"
+NAME="bcs-linux"
+ID=bcs
+VERSION_ID="1.0"
+HOME_URL="https://webcontainers.io"
+`;
+/**
+ * Idempotently create the Linux directory skeleton plus a few token files.
+ * Safe to call repeatedly (mkdir is recursive; writes overwrite identical content).
+ */
+export async function seedLinuxTree(fs, opts = {}) {
+    const home = opts.home ?? DEFAULT_HOME;
+    for (const dir of LINUX_DIRS) {
+        await fs.mkdir(dir);
+    }
+    await fs.mkdir(home);
+    await fs.writeFile('/etc/hostname', 'sandbox\n');
+    await fs.writeFile('/etc/os-release', OS_RELEASE);
+    await fs.writeFile(`${home}/.bashrc`, '');
+}

package/dist/fs/opfs.d.ts

@@ -0,0 +1,23 @@
+import type { FileSystem } from '../types/index.js';
+export interface OpfsFileSystemOptions {
+    cwd?: string;
+}
+export declare class OpfsFileSystem implements FileSystem {
+    readonly cwd: string;
+    constructor(options?: OpfsFileSystemOptions);
+    static isSupported(): boolean;
+    private root;
+    /** Walk to the directory handle for `dirSegments`, optionally creating it. */
+    private dirHandle;
+    private split;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    readFile(path: string): Promise<string | null>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    writeFile(path: string, contents: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+}