@slopus/rig 0.0.1

package/dist/server/runLocalProtocolServer.js

@@ -0,0 +1,82 @@
+import { chmod, open } from "node:fs/promises";
+import { createProtocolHttpServer } from "./createProtocolHttpServer.js";
+import { createModelCatalog } from "./createModelCatalog.js";
+import { getLocalServerPaths } from "./LocalServerPaths.js";
+import { prepareLocalServerDirectory } from "./prepareLocalServerDirectory.js";
+import { PersistentSessionStore } from "./PersistentSessionStore.js";
+import { readLocalServerToken } from "./readLocalServerToken.js";
+import { removeStaleSocket } from "./removeStaleSocket.js";
+export async function runLocalProtocolServer(options = {}) {
+    const paths = getLocalServerPaths();
+    const socketPath = options.socketPath ?? paths.socketPath;
+    const tokenPath = options.tokenPath ?? paths.tokenPath;
+    await prepareLocalServerDirectory(paths.directory);
+    const token = await readLocalServerToken(tokenPath);
+    await removeStaleSocket(socketPath);
+    const modelCatalog = createModelCatalog({ cwd: process.cwd() });
+    const store = new PersistentSessionStore({ databasePath: paths.databasePath, modelCatalog });
+    let stopServer;
+    const server = createProtocolHttpServer({
+        modelCatalog,
+        onShutdown: () => stopServer?.(),
+        store,
+        token,
+    });
+    try {
+        const previousUmask = process.umask(0o077);
+        try {
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(socketPath, () => {
+                    server.off("error", reject);
+                    resolve();
+                });
+            });
+        }
+        finally {
+            process.umask(previousUmask);
+        }
+        await chmod(socketPath, 0o600);
+        await writeRegistry(paths.registryPath, {
+            pid: process.pid,
+            socketPath,
+            startedAt: new Date().toISOString(),
+        });
+        await new Promise((resolve) => {
+            let stopping = false;
+            stopServer = () => {
+                if (stopping) {
+                    return;
+                }
+                stopping = true;
+                try {
+                    store.repairInterruptedSessions("shutdown");
+                }
+                catch (error) {
+                    console.error(error instanceof Error
+                        ? error.message
+                        : `Failed to repair interrupted sessions: ${String(error)}`);
+                }
+                finally {
+                    server.close(() => resolve());
+                }
+            };
+            process.once("SIGINT", stopServer);
+            process.once("SIGTERM", stopServer);
+        });
+    }
+    finally {
+        stopServer = undefined;
+        store.close();
+    }
+}
+async function writeRegistry(path, payload) {
+    const file = await open(path, "w", 0o600);
+    try {
+        await file.writeFile(`${JSON.stringify(payload, null, 2)}\n`);
+        await file.chmod(0o600);
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/server/uniqueModelsById.d.ts

@@ -0,0 +1,3 @@
+import type { Model } from "../providers/types.js";
+export declare function uniqueModelsById(models: readonly Model[]): readonly Model[];
+//# sourceMappingURL=uniqueModelsById.d.ts.map

package/dist/server/uniqueModelsById.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueModelsById.d.ts","sourceRoot":"","sources":["../../sources/server/uniqueModelsById.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE,CAE3E"}

package/dist/server/uniqueModelsById.js

@@ -0,0 +1,3 @@
+export function uniqueModelsById(models) {
+    return [...new Map(models.map((model) => [model.id, model])).values()];
+}

package/dist/server/writeLocalServerToken.d.ts

@@ -0,0 +1,2 @@
+export declare function writeLocalServerToken(tokenPath: string): Promise<string>;
+//# sourceMappingURL=writeLocalServerToken.d.ts.map

package/dist/server/writeLocalServerToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeLocalServerToken.d.ts","sourceRoot":"","sources":["../../sources/server/writeLocalServerToken.ts"],"names":[],"mappings":"AAGA,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ9E"}

package/dist/server/writeLocalServerToken.js

@@ -0,0 +1,11 @@
+import { randomBytes } from "node:crypto";
+import { rename, writeFile, chmod } from "node:fs/promises";
+export async function writeLocalServerToken(tokenPath) {
+    const token = randomBytes(32).toString("base64url");
+    const temporaryPath = `${tokenPath}.${process.pid}.tmp`;
+    await writeFile(temporaryPath, `${token}\n`, { mode: 0o600 });
+    await chmod(temporaryPath, 0o600);
+    await rename(temporaryPath, tokenPath);
+    await chmod(tokenPath, 0o600);
+    return token;
+}

package/dist/tools/Agent.d.ts

@@ -0,0 +1,9 @@
+export declare const agentTool: import("../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    description: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    output: import("@sinclair/typebox").TString;
+    sessionId: import("@sinclair/typebox").TString;
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"aborted">, import("@sinclair/typebox").TLiteral<"completed">, import("@sinclair/typebox").TLiteral<"error">]>;
+}>>;
+//# sourceMappingURL=Agent.d.ts.map

package/dist/tools/Agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../sources/tools/Agent.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,SAAS;;;;;;;GAgDpB,CAAC"}

package/dist/tools/Agent.js

@@ -0,0 +1,49 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../agent/types.js";
+const agentResultSchema = Type.Object({
+    output: Type.String(),
+    sessionId: Type.String(),
+    status: Type.Union([Type.Literal("aborted"), Type.Literal("completed"), Type.Literal("error")]),
+});
+export const agentTool = defineTool({
+    name: "Agent",
+    label: "Agent",
+    description: "Start a synchronous subagent for a focused, self-contained task. The subagent has its own conversation history and returns its final response. It stops when this tool call is aborted.",
+    arguments: Type.Object({
+        description: Type.String({
+            description: "A short, human-readable description of the delegated task.",
+        }),
+        prompt: Type.String({
+            description: "Complete instructions for the subagent.",
+        }),
+    }),
+    returnType: agentResultSchema,
+    execute: async ({ description, prompt }, context, execution) => {
+        if (context.subagents === undefined || !context.subagents.canSpawn) {
+            throw new Error("This agent has reached the maximum subagent depth.");
+        }
+        const result = await context.subagents.spawn({
+            description,
+            prompt,
+            ...(execution.toolCallId !== undefined
+                ? { parentToolCallId: execution.toolCallId }
+                : {}),
+        }, execution.signal);
+        if (result.status !== "completed") {
+            throw new Error(result.output);
+        }
+        return result;
+    },
+    toLLM: (result) => [
+        {
+            type: "text",
+            text: result.status === "completed"
+                ? result.output
+                : `The subagent ${result.status}. ${result.output}`,
+        },
+    ],
+    toUI: (result, args) => result.status === "completed"
+        ? `Completed: ${args.description}`
+        : `${result.status === "aborted" ? "Stopped" : "Failed"}: ${args.description}`,
+    locks: [],
+});

package/dist/tools/claude/Bash.d.ts

@@ -0,0 +1,12 @@
+export declare const claudeBashTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    run_in_background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    stdout: import("@sinclair/typebox").TString;
+    stderr: import("@sinclair/typebox").TString;
+    exitCode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>;
+    timedOut: import("@sinclair/typebox").TBoolean;
+}>>;
+//# sourceMappingURL=Bash.d.ts.map

package/dist/tools/claude/Bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bash.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Bash.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,cAAc;;;;;;;;;;GA8BzB,CAAC"}

package/dist/tools/claude/Bash.js

@@ -0,0 +1,30 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { runShellCommand, shellOutputToText, shellToolOutputSchema, summarizeShellOutput, } from "../utils/index.js";
+export const claudeBashTool = defineTool({
+    name: "Bash",
+    label: "Bash",
+    description: "Run shell command",
+    arguments: Type.Object({
+        command: Type.String({ description: "The command to execute" }),
+        timeout: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds" })),
+        description: Type.Optional(Type.String({
+            description: 'Clear, concise description of what this command does in active voice. Never use words like "complex" or "risk" in the description - just describe what it does.',
+        })),
+        run_in_background: Type.Optional(Type.Boolean({
+            description: "Set to true to run this command in the background. Use Read to read the output later.",
+        })),
+    }),
+    returnType: shellToolOutputSchema,
+    execute: async ({ command, timeout }, context, execution) => {
+        const options = {};
+        if (timeout !== undefined)
+            options.timeoutMs = timeout;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        return runShellCommand(command, options, context);
+    },
+    toLLM: shellOutputToText,
+    toUI: (result) => summarizeShellOutput(result),
+    locks: [],
+});

package/dist/tools/claude/Edit.d.ts

@@ -0,0 +1,13 @@
+export declare const claudeEditTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    old_string: import("@sinclair/typebox").TString;
+    new_string: import("@sinclair/typebox").TString;
+    replace_all: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    replacements: import("@sinclair/typebox").TNumber;
+    fuzzy: import("@sinclair/typebox").TBoolean;
+    oldString: import("@sinclair/typebox").TString;
+    newString: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=Edit.d.ts.map

package/dist/tools/claude/Edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Edit.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Edit.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,cAAc;;;;;;;;;;;GAqCzB,CAAC"}

package/dist/tools/claude/Edit.js

@@ -0,0 +1,44 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { editFileReturnSchema, editTextFile } from "../utils/index.js";
+const CLAUDE_EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+Usage:
+- You must use your \`Read\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + arrow. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
+export const claudeEditTool = defineTool({
+    name: "Edit",
+    label: "Edit",
+    description: CLAUDE_EDIT_DESCRIPTION,
+    arguments: Type.Object({
+        file_path: Type.String({ description: "The absolute path to the file to modify" }),
+        old_string: Type.String({ description: "The text to replace" }),
+        new_string: Type.String({
+            description: "The text to replace it with (must be different from old_string)",
+        }),
+        replace_all: Type.Optional(Type.Boolean({ description: "Replace all occurrences of old_string (default false)" })),
+    }),
+    returnType: editFileReturnSchema,
+    execute: async ({ file_path, old_string, new_string, replace_all }, context) => {
+        const result = await editTextFile({
+            path: file_path,
+            oldString: old_string,
+            newString: new_string,
+            replaceAll: replace_all ?? false,
+            fuzzy: false,
+        }, context);
+        return result;
+    },
+    toLLM: (result) => [
+        {
+            type: "text",
+            text: `The file ${result.path} has been updated.`,
+        },
+    ],
+    toUI: (result) => `Edited ${result.path} (${result.replacements} replacement${result.replacements === 1 ? "" : "s"})`,
+    locks: [(args) => args.file_path],
+});

package/dist/tools/claude/Glob.d.ts

@@ -0,0 +1,7 @@
+export declare const claudeGlobTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=Glob.d.ts.map

package/dist/tools/claude/Glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Glob.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Glob.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,cAAc;;;;;GA6BzB,CAAC"}

package/dist/tools/claude/Glob.js

@@ -0,0 +1,36 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { countTextLines, globFiles, textOutputSchema, toTextBlocks } from "../utils/index.js";
+const CLAUDE_GLOB_DESCRIPTION = `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead`;
+export const claudeGlobTool = defineTool({
+    name: "Glob",
+    label: "Glob",
+    description: CLAUDE_GLOB_DESCRIPTION,
+    arguments: Type.Object({
+        pattern: Type.String({ description: "The glob pattern to match files against" }),
+        path: Type.Optional(Type.String({
+            description: 'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+        })),
+    }),
+    returnType: textOutputSchema,
+    execute: async ({ pattern, path }, context, execution) => {
+        const options = { pattern, limit: 100 };
+        if (path !== undefined)
+            options.path = path;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        const files = await globFiles(options, context);
+        return {
+            text: files.length > 0 ? files.join("\n") : "No files found",
+        };
+    },
+    toLLM: toTextBlocks,
+    toUI: (result, args) => result.text === "No files found"
+        ? `Found files for "${args.pattern}" (0)`
+        : `Found files for "${args.pattern}" (${countTextLines(result.text)})`,
+    locks: [],
+});

package/dist/tools/claude/Grep.d.ts

@@ -0,0 +1,19 @@
+export declare const claudeGrepTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    "-B": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-A": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-C": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-n": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    "-i": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    head_limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    multiline: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=Grep.d.ts.map

package/dist/tools/claude/Grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Grep.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Grep.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;GAkHzB,CAAC"}

package/dist/tools/claude/Grep.js

@@ -0,0 +1,103 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { countTextLines, runRipgrep, textOutputSchema, toTextBlocks } from "../utils/index.js";
+const CLAUDE_GREP_DESCRIPTION = `A powerful search tool built on ripgrep
+
+  Usage:
+  - ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command. The Grep tool has been optimized for correct permissions and access.
+  - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+  - Use Agent tool for open-ended searches requiring multiple rounds
+  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\`
+`;
+export const claudeGrepTool = defineTool({
+    name: "Grep",
+    label: "Grep",
+    description: CLAUDE_GREP_DESCRIPTION,
+    arguments: Type.Object({
+        pattern: Type.String({
+            description: "The regular expression pattern to search for in file contents",
+        }),
+        path: Type.Optional(Type.String({
+            description: "File or directory to search in (rg PATH). Defaults to current working directory.",
+        })),
+        glob: Type.Optional(Type.String({
+            description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob',
+        })),
+        output_mode: Type.Optional(Type.Union([
+            Type.Literal("content"),
+            Type.Literal("files_with_matches"),
+            Type.Literal("count"),
+        ], {
+            description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".',
+        })),
+        "-B": Type.Optional(Type.Number({
+            description: 'Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.',
+        })),
+        "-A": Type.Optional(Type.Number({
+            description: 'Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.',
+        })),
+        "-C": Type.Optional(Type.Number({ description: "Alias for context." })),
+        context: Type.Optional(Type.Number({
+            description: 'Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.',
+        })),
+        "-n": Type.Optional(Type.Boolean({
+            description: 'Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.',
+        })),
+        "-i": Type.Optional(Type.Boolean({ description: "Case insensitive search (rg -i)" })),
+        type: Type.Optional(Type.String({
+            description: "File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types.",
+        })),
+        head_limit: Type.Optional(Type.Number({
+            description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly -- large result sets waste context).',
+        })),
+        offset: Type.Optional(Type.Number({
+            description: 'Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0.',
+        })),
+        multiline: Type.Optional(Type.Boolean({
+            description: "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.",
+        })),
+    }),
+    returnType: textOutputSchema,
+    execute: async (args, context, execution) => {
+        const options = {
+            pattern: args.pattern,
+            outputMode: args.output_mode ?? "files_with_matches",
+            lineNumbers: args["-n"] ?? true,
+        };
+        const contextLines = args.context ?? args["-C"];
+        if (contextLines !== undefined)
+            options.context = contextLines;
+        if (args.path !== undefined)
+            options.path = args.path;
+        if (args.glob !== undefined)
+            options.glob = args.glob;
+        if (args["-B"] !== undefined)
+            options.before = args["-B"];
+        if (args["-A"] !== undefined)
+            options.after = args["-A"];
+        if (args["-i"] !== undefined)
+            options.ignoreCase = args["-i"];
+        if (args.type !== undefined)
+            options.type = args.type;
+        if (args.head_limit !== undefined)
+            options.headLimit = args.head_limit;
+        if (args.offset !== undefined)
+            options.offset = args.offset;
+        if (args.multiline !== undefined)
+            options.multiline = args.multiline;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        const result = await runRipgrep(options, context);
+        return {
+            text: result.text.length > 0 ? result.text : "No matches found",
+        };
+    },
+    toLLM: toTextBlocks,
+    toUI: (result, args) => result.text === "No matches found"
+        ? `Searched "${args.pattern}" (no matches)`
+        : `Searched "${args.pattern}" (${countTextLines(result.text)} matches)`,
+    locks: [],
+});

package/dist/tools/claude/Read.d.ts

@@ -0,0 +1,18 @@
+export declare const claudeReadTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+    startLine: import("@sinclair/typebox").TNumber;
+    totalLines: import("@sinclair/typebox").TNumber;
+    returnedLines: import("@sinclair/typebox").TNumber;
+    truncated: import("@sinclair/typebox").TBoolean;
+}>, import("@sinclair/typebox").TObject<{
+    image_url: import("@sinclair/typebox").TString;
+    mediaType: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>]>>;
+//# sourceMappingURL=Read.d.ts.map

package/dist/tools/claude/Read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Read.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Read.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;KAiEzB,CAAC"}

package/dist/tools/claude/Read.js

@@ -0,0 +1,84 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { mediaTypeForPath, readFileReturnSchema, readTextFile, textOutputSchema, } from "../utils/index.js";
+const MAX_LINES_TO_READ = 2000;
+const CLAUDE_READ_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
+- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;
+const claudeReadReturnSchema = Type.Union([
+    readFileReturnSchema,
+    Type.Object({
+        image_url: Type.String(),
+        mediaType: Type.String(),
+    }),
+    textOutputSchema,
+]);
+export const claudeReadTool = defineTool({
+    name: "Read",
+    label: "Read",
+    description: CLAUDE_READ_DESCRIPTION,
+    arguments: Type.Object({
+        file_path: Type.String({ description: "The absolute path to the file to read" }),
+        offset: Type.Optional(Type.Number({
+            description: "The line number to start reading from. Only provide if the file is too large to read at once",
+        })),
+        limit: Type.Optional(Type.Number({
+            description: "The number of lines to read. Only provide if the file is too large to read at once.",
+        })),
+    }),
+    returnType: claudeReadReturnSchema,
+    execute: async ({ file_path, offset, limit }, context) => {
+        const lower = file_path.toLowerCase();
+        if (/\.(png|jpe?g|gif|webp|bmp)$/.test(lower)) {
+            const mediaType = mediaTypeForPath(file_path);
+            const data = Buffer.from(await context.fs.readFileBuffer(file_path)).toString("base64");
+            return {
+                image_url: `data:${mediaType};base64,${data}`,
+                mediaType,
+            };
+        }
+        const options = {
+            path: file_path,
+            numbered: true,
+        };
+        if (offset !== undefined)
+            options.offset = offset;
+        if (limit !== undefined)
+            options.limit = limit;
+        return readTextFile(options, context);
+    },
+    toLLM: (result) => {
+        if ("image_url" in result) {
+            const match = /^data:([^;]+);base64,(.*)$/.exec(result.image_url);
+            return match
+                ? [{ type: "image", mediaType: match[1] ?? result.mediaType, data: match[2] ?? "" }]
+                : [{ type: "text", text: result.image_url }];
+        }
+        if ("content" in result) {
+            return [
+                { type: "text", text: result.content.length > 0 ? result.content : "(empty file)" },
+            ];
+        }
+        return [{ type: "text", text: result.text }];
+    },
+    toUI: (result, args) => {
+        if ("image_url" in result) {
+            return `Read image ${args.file_path}`;
+        }
+        if ("content" in result) {
+            return `Read ${result.path} (${result.returnedLines}/${result.totalLines} lines${result.truncated ? ", truncated" : ""})`;
+        }
+        return result.text;
+    },
+    locks: [],
+});

package/dist/tools/claude/TodoWrite.d.ts

@@ -0,0 +1,10 @@
+export declare const claudeTodoWriteTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    todos: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        content: import("@sinclair/typebox").TString;
+        activeForm: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"in_progress">, import("@sinclair/typebox").TLiteral<"completed">]>;
+    }>>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=TodoWrite.d.ts.map

package/dist/tools/claude/TodoWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TodoWrite.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/TodoWrite.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,mBAAmB;;;;;;;;GAgB9B,CAAC"}

package/dist/tools/claude/TodoWrite.js

@@ -0,0 +1,27 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { textOutputSchema, toTextBlocks } from "../utils/index.js";
+const todoSchema = Type.Object({
+    content: Type.String(),
+    activeForm: Type.String(),
+    status: Type.Union([
+        Type.Literal("pending"),
+        Type.Literal("in_progress"),
+        Type.Literal("completed"),
+    ]),
+});
+export const claudeTodoWriteTool = defineTool({
+    name: "TodoWrite",
+    label: "TodoWrite",
+    description: "Update the todo list for the current session. To be used proactively and often to track progress and pending tasks. Make sure that at least one task is in_progress at all times. Always provide both content (imperative) and activeForm (present continuous) for each task.",
+    arguments: Type.Object({
+        todos: Type.Array(todoSchema, { description: "The updated todo list" }),
+    }),
+    returnType: textOutputSchema,
+    execute: async ({ todos }) => ({
+        text: `Todos have been modified successfully. ${todos.length} item(s) provided.`,
+    }),
+    toLLM: toTextBlocks,
+    toUI: (_result, args) => `Updated ${args.todos.length} todo${args.todos.length === 1 ? "" : "s"}`,
+    locks: ["TodoWrite"],
+});