@matterailab/orbcode 0.1.3

package/dist/tools/executors/listFiles.js

@@ -0,0 +1,65 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveWorkspacePath } from "../types.js";
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".turbo",
+    "__pycache__",
+    ".venv",
+    "venv",
+]);
+const MAX_ENTRIES = 800;
+export function walkFiles(root, recursive, maxEntries = MAX_ENTRIES) {
+    const entries = [];
+    const queue = [root];
+    while (queue.length > 0 && entries.length < maxEntries) {
+        const dir = queue.shift();
+        let dirents;
+        try {
+            dirents = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        dirents.sort((a, b) => a.name.localeCompare(b.name));
+        for (const dirent of dirents) {
+            if (entries.length >= maxEntries)
+                break;
+            const full = path.join(dir, dirent.name);
+            // Always report forward-slash paths: the UI (@-mention filtering) and
+            // the model both treat "/" as the separator, even on Windows.
+            const rel = path.relative(root, full).split(path.sep).join("/");
+            if (dirent.isDirectory()) {
+                entries.push(rel + "/");
+                if (recursive && !IGNORED_DIRS.has(dirent.name) && !dirent.name.startsWith(".")) {
+                    queue.push(full);
+                }
+            }
+            else {
+                entries.push(rel);
+            }
+        }
+    }
+    return entries;
+}
+export async function listFiles(args, context) {
+    const dirPath = resolveWorkspacePath(context.cwd, String(args.path ?? "."));
+    const recursive = Boolean(args.recursive);
+    if (!fs.existsSync(dirPath)) {
+        return { text: `Directory not found: ${dirPath}`, isError: true };
+    }
+    const entries = walkFiles(dirPath, recursive);
+    if (entries.length === 0) {
+        return { text: `Directory ${dirPath} is empty.` };
+    }
+    let text = entries.join("\n");
+    if (entries.length >= MAX_ENTRIES) {
+        text += `\n\n(Truncated at ${MAX_ENTRIES} entries.)`;
+    }
+    return { text };
+}

package/dist/tools/executors/searchFiles.js

@@ -0,0 +1,104 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import picomatch from "picomatch";
+import { resolveWorkspacePath } from "../types.js";
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".turbo",
+    "__pycache__",
+    ".venv",
+    "venv",
+]);
+const MAX_RESULTS = 300;
+const MAX_FILE_SIZE = 2 * 1024 * 1024; // skip files over 2MB
+const MAX_LINE_LENGTH = 500;
+export async function searchFiles(args, context) {
+    const dirPath = resolveWorkspacePath(context.cwd, String(args.path ?? "."));
+    const regexSource = String(args.regex ?? "");
+    const filePattern = args.file_pattern == null || args.file_pattern === "" ? null : String(args.file_pattern);
+    let regex;
+    try {
+        regex = new RegExp(regexSource);
+    }
+    catch (error) {
+        return { text: `Invalid regex: ${error.message}`, isError: true };
+    }
+    if (!fs.existsSync(dirPath)) {
+        return { text: `Directory not found: ${dirPath}`, isError: true };
+    }
+    // A bare pattern like "*.ts" should match at any depth, like ripgrep -g.
+    const isMatch = filePattern
+        ? picomatch(filePattern.includes("/") ? filePattern : `**/${filePattern}`, { dot: true })
+        : () => true;
+    const results = [];
+    let matchCount = 0;
+    const walk = (dir) => {
+        if (matchCount >= MAX_RESULTS)
+            return;
+        let dirents;
+        try {
+            dirents = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const dirent of dirents) {
+            if (matchCount >= MAX_RESULTS)
+                return;
+            const full = path.join(dir, dirent.name);
+            if (dirent.isDirectory()) {
+                if (!IGNORED_DIRS.has(dirent.name) && !dirent.name.startsWith("."))
+                    walk(full);
+                continue;
+            }
+            // picomatch only understands forward slashes, so normalize Windows paths.
+            const rel = path.relative(dirPath, full).split(path.sep).join("/");
+            if (!isMatch(rel))
+                continue;
+            let stat;
+            try {
+                stat = fs.statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.size > MAX_FILE_SIZE)
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(full, "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (content.includes("\u0000"))
+                continue; // binary
+            const lines = content.split("\n");
+            const fileMatches = [];
+            for (let i = 0; i < lines.length && matchCount < MAX_RESULTS; i++) {
+                if (regex.test(lines[i])) {
+                    matchCount++;
+                    const lineText = lines[i].length > MAX_LINE_LENGTH ? lines[i].slice(0, MAX_LINE_LENGTH) + "…" : lines[i];
+                    fileMatches.push(`  ${i + 1}: ${lineText}`);
+                }
+            }
+            if (fileMatches.length > 0) {
+                results.push(`${rel}\n${fileMatches.join("\n")}`);
+            }
+        }
+    };
+    walk(dirPath);
+    if (results.length === 0) {
+        return { text: `No matches found for "${regexSource}" in ${dirPath}.` };
+    }
+    let text = `Found ${matchCount} match${matchCount === 1 ? "" : "es"}:\n\n${results.join("\n\n")}`;
+    if (matchCount >= MAX_RESULTS) {
+        text += `\n\n(Truncated at ${MAX_RESULTS} matches. Narrow your regex or file_pattern.)`;
+    }
+    return { text };
+}

package/dist/tools/executors/web.js

@@ -0,0 +1,72 @@
+import { getUrlFromToken } from "../../auth/auth.js";
+export async function webSearch(args, context) {
+    const query = String(args.query ?? "");
+    if (!query)
+        return { text: "FAILED: query is empty", isError: true };
+    try {
+        const url = getUrlFromToken("https://api.matterai.so/axoncode/websearch", context.token);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${context.token}`,
+            },
+            body: JSON.stringify({ query }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            return { text: `Web search failed (${response.status})`, isError: true };
+        }
+        const data = (await response.json());
+        const results = data.results;
+        if (!results || results.length === 0) {
+            return { text: `No results found for query: "${query}"` };
+        }
+        const formatted = results
+            .map((result, index) => {
+            let entry = `[${index + 1}] ${result.title}\nURL: ${result.url}`;
+            if (result.publish_date)
+                entry += `\nPublished: ${result.publish_date}`;
+            if (result.excerpts && result.excerpts.length > 0)
+                entry += `\n\n${result.excerpts.join("\n\n")}`;
+            return entry;
+        })
+            .join("\n\n---\n\n");
+        return { text: `Web search results for "${query}":\n\n${formatted}` };
+    }
+    catch (error) {
+        return { text: `Web search failed: ${error.message}`, isError: true };
+    }
+}
+export async function webFetch(args, context) {
+    const targetUrl = String(args.url ?? "");
+    try {
+        new URL(targetUrl);
+    }
+    catch {
+        return { text: `Invalid URL format: ${targetUrl}`, isError: true };
+    }
+    try {
+        const apiUrl = getUrlFromToken("https://api.matterai.so/axoncode/webFetch", context.token);
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${context.token}`,
+            },
+            body: JSON.stringify({ url: targetUrl }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            return { text: `Web fetch failed (${response.status})`, isError: true };
+        }
+        const data = (await response.json());
+        if (!data.excerpts || data.excerpts.length === 0) {
+            return { text: `No content could be extracted from URL: "${targetUrl}"` };
+        }
+        return { text: `Content from ${targetUrl}:\n\n${data.excerpts.join("\n\n")}` };
+    }
+    catch (error) {
+        return { text: `Web fetch failed: ${error.message}`, isError: true };
+    }
+}

package/dist/tools/index.js

@@ -0,0 +1,85 @@
+import { nativeTools } from "./schemas/index.js";
+import { fileEdit, fileWrite, multiFileEdit, readFile } from "./executors/files.js";
+import { listFiles } from "./executors/listFiles.js";
+import { searchFiles } from "./executors/searchFiles.js";
+import { executeCommand } from "./executors/executeCommand.js";
+import { webFetch, webSearch } from "./executors/web.js";
+export { nativeTools };
+/** Tools that modify the user's system and need approval before running. */
+export function getApprovalKind(toolName, args) {
+    switch (toolName) {
+        case "file_edit":
+        case "multi_file_edit":
+        case "file_write":
+            return "edit";
+        case "execute_command":
+            return "command";
+        default:
+            return "none";
+    }
+}
+/** One-line human summary of a tool call, shown in the UI. */
+export function describeToolCall(toolName, args) {
+    switch (toolName) {
+        case "read_file":
+            return String(args.file_path ?? "");
+        case "file_write":
+            return String(args.file_path ?? "");
+        case "file_edit":
+            return String(args.file_path ?? "");
+        case "multi_file_edit": {
+            const edits = Array.isArray(args.edits) ? args.edits : [];
+            const files = [...new Set(edits.map((e) => e.file_path ?? ""))];
+            return `${edits.length} edits in ${files.length} file${files.length === 1 ? "" : "s"}`;
+        }
+        case "execute_command":
+            return String(args.command ?? "");
+        case "list_files":
+            return `${args.path ?? "."}${args.recursive ? " (recursive)" : ""}`;
+        case "search_files":
+            return `/${args.regex ?? ""}/ in ${args.path ?? "."}${args.file_pattern ? ` (${args.file_pattern})` : ""}`;
+        case "web_search":
+            return String(args.query ?? "");
+        case "web_fetch":
+            return String(args.url ?? "");
+        case "update_todo_list":
+            return "updating tasks";
+        case "ask_followup_question":
+            return String(args.question ?? "");
+        case "attempt_completion":
+            return "task complete";
+        default:
+            return toolName;
+    }
+}
+const executors = {
+    read_file: readFile,
+    file_write: fileWrite,
+    file_edit: fileEdit,
+    multi_file_edit: multiFileEdit,
+    list_files: listFiles,
+    search_files: searchFiles,
+    execute_command: executeCommand,
+    web_search: webSearch,
+    web_fetch: webFetch,
+    update_todo_list: async (args, context) => {
+        context.setTodos(String(args.todos ?? ""));
+        return { text: "Todo list updated." };
+    },
+    // ask_followup_question and attempt_completion are handled by the agent loop.
+};
+export async function executeTool(toolName, args, context) {
+    const executor = executors[toolName];
+    if (!executor) {
+        return { text: `Tool "${toolName}" is not available in OrbCode CLI.`, isError: true };
+    }
+    try {
+        return await executor(args, context);
+    }
+    catch (error) {
+        return { text: `Tool ${toolName} failed: ${error.message}`, isError: true };
+    }
+}
+export function getActiveTools() {
+    return nativeTools;
+}

package/dist/tools/schemas/ask_followup_question.js

@@ -0,0 +1,40 @@
+export default {
+    type: "function",
+    function: {
+        name: "ask_followup_question",
+        description: "Ask the user a question to gather additional information needed to complete the task. Use when clarification or more detail is required before proceeding.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                question: {
+                    type: "string",
+                    description: "Clear, specific question that captures the missing information you need",
+                },
+                follow_up: {
+                    type: ["array", "null"],
+                    description: "Optional list of 2-4 suggested responses; each suggestion must be a complete, actionable answer and may include a mode switch",
+                    items: {
+                        type: "object",
+                        properties: {
+                            text: {
+                                type: "string",
+                                description: "Suggested answer the user can pick",
+                            },
+                            mode: {
+                                type: ["string", "null"],
+                                description: "Optional mode slug to switch to if this suggestion is chosen (e.g., agent, plan)",
+                            },
+                        },
+                        required: ["text", "mode"],
+                        additionalProperties: false,
+                    },
+                    minItems: 2,
+                    maxItems: 4,
+                },
+            },
+            required: ["question"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/attempt_completion.js

@@ -0,0 +1,19 @@
+export default {
+    type: "function",
+    function: {
+        name: "attempt_completion",
+        description: "After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again. IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must confirm that you've received successful results from the user for any previous tool uses. If not, then DO NOT use this tool.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                result: {
+                    type: "string",
+                    description: "Final result message to deliver to the user once the task is complete",
+                },
+            },
+            required: ["result"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/browser_action.js

@@ -0,0 +1,60 @@
+export default {
+    type: "function",
+    function: {
+        name: "browser_action",
+        description: "Interact with a Puppeteer-controlled browser session. Always start by launching at a URL and always finish by closing the browser. While the browser is active, do not call any other tools. Use coordinates within the viewport to hover or click, provide text for typing, and ensure actions are grounded in the latest screenshot and console logs.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    description: "Browser action to perform",
+                    enum: ["launch", "hover", "click", "type", "resize", "scroll_down", "scroll_up", "close"],
+                },
+                url: {
+                    type: ["string", "null"],
+                    description: "URL to open when performing the launch action; must include protocol",
+                },
+                coordinate: {
+                    type: ["object", "null"],
+                    description: "Screen coordinate for hover or click actions; target the center of the desired element",
+                    properties: {
+                        x: {
+                            type: "number",
+                            description: "Horizontal pixel position within the current viewport",
+                        },
+                        y: {
+                            type: "number",
+                            description: "Vertical pixel position within the current viewport",
+                        },
+                    },
+                    required: ["x", "y"],
+                    additionalProperties: false,
+                },
+                size: {
+                    type: ["object", "null"],
+                    description: "Viewport dimensions to apply when performing the resize action",
+                    properties: {
+                        width: {
+                            type: "number",
+                            description: "Viewport width in pixels",
+                        },
+                        height: {
+                            type: "number",
+                            description: "Viewport height in pixels",
+                        },
+                    },
+                    required: ["width", "height"],
+                    additionalProperties: false,
+                },
+                text: {
+                    type: ["string", "null"],
+                    description: "Text to type when performing the type action",
+                },
+            },
+            required: ["action"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/check_past_chat_memories.js

@@ -0,0 +1,23 @@
+export default {
+    type: "function",
+    function: {
+        name: "check_past_chat_memories",
+        description: "Search through previous chat completion results to find relevant context from past tasks. Use this when you need to recall what was implemented or fixed in previous chats.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                regex: {
+                    type: "string",
+                    description: "Regular expression pattern to search memory contents",
+                },
+                workspace: {
+                    type: "string",
+                    description: "Filter by workspace directory (optional, defaults to current workspace)",
+                },
+            },
+            required: ["regex"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/codebase_search.js

@@ -0,0 +1,23 @@
+export default {
+    type: "function",
+    function: {
+        name: "codebase_search",
+        description: "Run a semantic search across the workspace to find files relevant to a natural-language query. Reuse the user's wording where possible and keep queries in English.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Meaning-based search query describing the information you need",
+                },
+                path: {
+                    type: ["string", "null"],
+                    description: "Optional subdirectory (relative to the workspace) to limit the search scope",
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/execute_command.js

@@ -0,0 +1,31 @@
+export default {
+    type: "function",
+    function: {
+        name: "execute_command",
+        description: "Run a CLI command on the user's system. Tailor the command to the environment, explain what it does, and prefer relative paths or shell-appropriate chaining. Use the cwd parameter only when directed to run in a different directory.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                command: {
+                    type: "string",
+                    description: "Shell command to execute",
+                },
+                cwd: {
+                    type: ["string", "null"],
+                    description: "Optional working directory for the command, relative or absolute",
+                },
+                message: {
+                    type: "string",
+                    description: "A clear, concise one-line description of what the command does, shown to the user for approval (e.g. 'Install project dependencies with npm')",
+                },
+                isDangerous: {
+                    type: "boolean",
+                    description: "Set true when the command is potentially destructive or irreversible — e.g. deletes/overwrites files (rm, mv over existing paths), force-pushes or resets git history, drops/migrates databases, changes system/network/permission state, installs globally, or sends data to external services. Set false for safe read-only or routine commands (ls, cat, build, test, install local deps). The user's selected approval mode may auto-approve only commands marked false.",
+                },
+            },
+            required: ["command"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/fetch_instructions.js

@@ -0,0 +1,20 @@
+export default {
+    type: "function",
+    function: {
+        name: "fetch_instructions",
+        description: "Retrieve detailed instructions for performing a predefined task, such as creating an MCP server or creating a mode.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Task identifier to fetch instructions for",
+                    enum: ["create_mcp_server", "create_mode"],
+                },
+            },
+            required: ["task"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/file_edit.js

@@ -0,0 +1,31 @@
+export default {
+    type: "function",
+    function: {
+        name: "file_edit",
+        description: "Make exactly ONE text replacement in ONE file. DO NOT call this tool multiple times in sequence — if you have 2 or more edits, you MUST use multi_file_edit instead. Provide the current text (`old_string`) and the desired text (`new_string`). By default only a single uniquely matched occurrence is replaced; set `replace_all` to true to update every matching occurrence. old_string and new_string cannot be the same.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Absolute path to the file to modify (e.g., /Users/username/project/src/file.ts)",
+                },
+                old_string: {
+                    type: "string",
+                    description: "Exact text to replace. Provide enough context for a unique match. Use an empty string to replace the entire file.",
+                },
+                new_string: {
+                    type: "string",
+                    description: "Replacement text. This will be inserted in place of the matched section. Can be an empty string to delete the match.",
+                },
+                replace_all: {
+                    type: "boolean",
+                    description: "Set to true to replace every occurrence of the matched text. Defaults to false (replace a single uniquely identified occurrence).",
+                },
+            },
+            required: ["file_path", "old_string", "new_string"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/file_write.js

@@ -0,0 +1,27 @@
+export default {
+    type: "function",
+    function: {
+        name: "file_write",
+        description: "Create a new file that does not exists yet or overwrite a file with all the new content. Use this tool to write new files or completely rewrite existing files. The tool will create missing directories automatically. For partial edits to existing files, you will only use file_edit tool instead.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Absolute path to the file to write (e.g., /Users/username/project/src/file.ts)",
+                },
+                content: {
+                    type: "string",
+                    description: "Full content to write to the file. For new files, this is the complete file content. For existing files, this will replace the entire file content. Use actual newlines for line breaks; JSON escape sequences are handled automatically.",
+                },
+                line_count: {
+                    type: "integer",
+                    description: "Total number of lines in the content, counting blank lines. Used to verify content completeness.",
+                },
+            },
+            required: ["file_path", "content", "line_count"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/generate_image.js

@@ -0,0 +1,27 @@
+export default {
+    type: "function",
+    function: {
+        name: "generate_image",
+        description: "Create a new image or edit an existing one using OpenRouter image models. Provide a prompt describing the desired output, choose where to save the image in the current workspace, and optionally supply an input image to transform.",
+        strict: true,
+        parameters: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Text description of the image to generate or the edits to apply",
+                },
+                path: {
+                    type: "string",
+                    description: "Filesystem path (relative to the workspace) where the resulting image should be saved",
+                },
+                image: {
+                    type: ["string", "null"],
+                    description: "Optional path (relative to the workspace) to an existing image to edit; supports PNG, JPG, JPEG, GIF, and WEBP",
+                },
+            },
+            required: ["prompt", "path"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/tools/schemas/index.js

@@ -0,0 +1,29 @@
+import fileEdit from "./file_edit.js";
+import multiFileEdit from "./multi_file_edit.js";
+import fileWrite from "./file_write.js";
+import askFollowupQuestion from "./ask_followup_question.js";
+import attemptCompletion from "./attempt_completion.js";
+import executeCommand from "./execute_command.js";
+import listFiles from "./list_files.js";
+import { read_file_single } from "./read_file.js";
+import searchFiles from "./search_files.js";
+import updateTodoList from "./update_todo_list.js";
+import webFetch from "./web_fetch.js";
+import webSearch from "./web_search.js";
+// Native tool schemas ported verbatim from the Orbital extension (native-tools).
+// Tools that depend on IDE-only services (codebase_search, lsp, use_skill,
+// check_past_chat_memories, browser_action, …) are not active in the CLI.
+export const nativeTools = [
+    fileEdit,
+    multiFileEdit,
+    fileWrite,
+    askFollowupQuestion,
+    attemptCompletion,
+    executeCommand,
+    listFiles,
+    read_file_single,
+    searchFiles,
+    updateTodoList,
+    webFetch,
+    webSearch,
+];