anyclaude-sdk 0.4.2 → 0.4.4

package/README.md

@@ -277,6 +277,28 @@ await fs.writeFile('/app/index.ts', 'export const x = 1')
 const workspace = composeWorkspace(fs, new NoopCommandExecutor())
 ```
 
+## Skills (programmatic)
+
+Declare reusable prompt-skills inline — each becomes a `/name` slash command and is invokable by the agent through the `skill` tool. `$ARGUMENTS` is substituted at call time:
+
+```ts
+import { query, defineSkill } from 'anyclaude-sdk'
+
+query({
+  prompt, workspace, llm,
+  skills: [
+    defineSkill({
+      name: 'changelog',
+      description: 'Summarize git changes into a changelog entry',
+      instructions: 'Write a concise changelog entry for: $ARGUMENTS',
+      argumentHint: '<since>',
+    }),
+  ],
+})
+```
+
+You can also pass plain `Skill` objects, or `skills: true` to load `.claude/skills/*.md` from the workspace.
+
 ## Serverless & the "survivor"
 
 Run `query()` in a serverless function and stream `SDKMessage`s to the browser. For runs longer than the platform's time cap, checkpoint at a turn boundary and continue transparently in a fresh invocation:

package/dist/agent.js

@@ -12,7 +12,7 @@ import { ALL_CLAUDE_CODE_TOOLS, toolByName, toolDefs } from './tools/index.js';
 import { task as taskTool } from './tools/task.js';
 import { askUserQuestion } from './tools/ask_user.js';
 import { loadMcpServers } from './mcp/index.js';
-import { runSlashCommand } from './commands/index.js';
+import { runSlashCommand, BUILTIN_COMMANDS } from './commands/index.js';
 import { BackgroundTaskManager, BACKGROUND_TOOLS } from './background/index.js';
 import { Mailbox, TaskBoard, TEAM_TOOLS, TEAM_DISPATCH_TOOLS, coordinatorPrompt } from './team/index.js';
 import { MEMORY_TOOLS } from './memory/index.js';
@@ -395,9 +395,9 @@ export async function* runAgent(options) {
         mcp_servers: mcpStatuses,
         model: model ?? 'unknown',
         permissionMode,
-        slash_commands: [],
+        slash_commands: [...new Set([...BUILTIN_COMMANDS, ...allCommands].map((c) => c.name.replace(/^\//, '')))],
         output_style: 'default',
-        skills: [],
+        skills: skills.map((s) => s.name),
         agents: agents ? Object.keys(agents) : undefined,
         uuid: uuid(),
         session_id: sessionId,

package/dist/fs/dexie.d.ts

@@ -22,11 +22,16 @@ export interface DexieFileSystemOptions {
     cwd?: string;
     /** Wipe all nodes on first open (fresh filesystem). */
     resetOnInit?: boolean;
+    /** Use an existing Dexie instance instead of opening one by name — lets the
+     *  filesystem share a database your app already owns. It must declare a
+     *  `nodes` table keyed by `path` (or be a fresh Dexie this FS can version). */
+    db?: unknown;
 }
 export declare class DexieFileSystem implements FileSystem {
     readonly cwd: string;
     private readonly dbName;
     private readonly resetOnInit;
+    private readonly injectedDb;
     private db;
     private opening;
     constructor(dbName?: string, options?: DexieFileSystemOptions);

package/dist/fs/dexie.js

@@ -20,6 +20,7 @@ export class DexieFileSystem {
         this.dbName = dbName;
         this.cwd = options.cwd ?? '/';
         this.resetOnInit = options.resetOnInit ?? false;
+        this.injectedDb = options.db ?? null;
     }
     // ---- lifecycle ----
     async open() {
@@ -28,14 +29,25 @@ export class DexieFileSystem {
         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',
-            });
+            let db;
+            if (this.injectedDb) {
+                // Use the caller's Dexie instance. Declare our schema if it isn't open
+                // yet; an already-open db is assumed to carry a compatible `nodes` table.
+                db = this.injectedDb;
+                if (!db.isOpen?.()) {
+                    db.version(1).stores({ nodes: 'path, parent' });
+                }
+            }
+            else {
+                // @ts-ignore optional peer dependency, resolved at runtime
+                const mod = await import('dexie');
+                const Dexie = mod.default ?? mod;
+                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();

package/dist/skills/define.d.ts

@@ -0,0 +1,24 @@
+import type { Skill } from './types.js';
+export interface DefineSkillSpec {
+    /** Skill name — used as the slash-command name and the `skill` tool lookup key. */
+    name: string;
+    /** One-line description of what the skill does (shown to the model + in /help). */
+    description: string;
+    /** The skill's instructions / prompt template. `$ARGUMENTS` is substituted at call time. */
+    instructions: string;
+    /** Optional argument hint, e.g. "<file>" or "<topic>". */
+    argumentHint?: string;
+}
+/**
+ * Define a skill programmatically:
+ *
+ *   query({ skills: [defineSkill({
+ *     name: 'changelog',
+ *     description: 'Summarize git changes into a changelog entry',
+ *     instructions: 'Write a concise changelog entry for: $ARGUMENTS',
+ *   })] })
+ *
+ * It is registered as a `/changelog` slash command and is invokable by the agent
+ * through the `skill` tool. (You can also pass plain `Skill` objects directly.)
+ */
+export declare function defineSkill(spec: DefineSkillSpec): Skill;

package/dist/skills/define.js

@@ -0,0 +1,29 @@
+/**
+ * Define a skill programmatically:
+ *
+ *   query({ skills: [defineSkill({
+ *     name: 'changelog',
+ *     description: 'Summarize git changes into a changelog entry',
+ *     instructions: 'Write a concise changelog entry for: $ARGUMENTS',
+ *   })] })
+ *
+ * It is registered as a `/changelog` slash command and is invokable by the agent
+ * through the `skill` tool. (You can also pass plain `Skill` objects directly.)
+ */
+export function defineSkill(spec) {
+    const name = String(spec.name ?? '').trim();
+    if (!name)
+        throw new Error('defineSkill: `name` is required.');
+    if (!/^[A-Za-z0-9][\w:-]*$/.test(name)) {
+        throw new Error(`defineSkill: invalid name "${name}" (use letters, digits, _ - :).`);
+    }
+    const instructions = String(spec.instructions ?? '');
+    if (!instructions.trim())
+        throw new Error(`defineSkill("${name}"): \`instructions\` is required.`);
+    return {
+        name,
+        description: String(spec.description ?? '').trim(),
+        body: instructions,
+        ...(spec.argumentHint ? { argumentHint: String(spec.argumentHint) } : {}),
+    };
+}

package/dist/skills/index.d.ts

@@ -2,3 +2,4 @@ export type { Skill } from './types.js';
 export { parseSkill } from './parse.js';
 export { loadSkillsFromFs, skillsToCommands, applySkillArgs } from './load.js';
 export { skill } from './tool.js';
+export { defineSkill, type DefineSkillSpec } from './define.js';

package/dist/skills/index.js

@@ -3,3 +3,4 @@
 export { parseSkill } from './parse.js';
 export { loadSkillsFromFs, skillsToCommands, applySkillArgs } from './load.js';
 export { skill } from './tool.js';
+export { defineSkill } from './define.js';

package/dist/tools/index.d.ts

@@ -23,6 +23,11 @@ export { defineTool, type DefineToolSpec } from './define.js';
 export { askUserQuestion } from './ask_user.js';
 /** Every built-in Claude Code tool, ready to pass to `query()`. */
 export declare const ALL_CLAUDE_CODE_TOOLS: Tool[];
+/** Built-in tools that operate on the workspace (filesystem + shell). Pass as
+ *  `query({ clientTools: WORKSPACE_TOOL_NAMES })` to execute them on the HOST
+ *  (e.g. a browser WebContainer or IndexedDB FS) instead of server-side. Pair
+ *  with anyclaude-react's `createWorkspaceClientTools(workspace)`. */
+export declare const WORKSPACE_TOOL_NAMES: readonly ["bash", "write_file", "read_file", "edit_file", "multi_edit", "delete_file", "list_files", "glob", "grep"];
 /** Extract the OpenAI-shape definitions to send to the LLM. */
 export declare function toolDefs(tools: Tool[]): ToolDef[];
 /** Build a name→tool lookup for dispatching tool calls. */

package/dist/tools/index.js

@@ -36,6 +36,21 @@ export const ALL_CLAUDE_CODE_TOOLS = [
     toolSearch,
     config,
 ];
+/** Built-in tools that operate on the workspace (filesystem + shell). Pass as
+ *  `query({ clientTools: WORKSPACE_TOOL_NAMES })` to execute them on the HOST
+ *  (e.g. a browser WebContainer or IndexedDB FS) instead of server-side. Pair
+ *  with anyclaude-react's `createWorkspaceClientTools(workspace)`. */
+export const WORKSPACE_TOOL_NAMES = [
+    'bash',
+    'write_file',
+    'read_file',
+    'edit_file',
+    'multi_edit',
+    'delete_file',
+    'list_files',
+    'glob',
+    'grep',
+];
 /** Extract the OpenAI-shape definitions to send to the LLM. */
 export function toolDefs(tools) {
     return tools.map((t) => t.def);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Standalone, browser-compatible SDK providing Claude Code agent capabilities (tools, tool loop, multi-turn, MCP, sub-agents, sessions) against any OpenAI/Anthropic-compatible LLM endpoint. Runs in the browser (WebContainer), Node, and Bun — no backend required.",
   "type": "module",
   "main": "./dist/index.js",