multiarena 0.1.0

package/dist/provider/adapters/openai.js

@@ -0,0 +1,167 @@
+import OpenAI from "openai";
+const DEFAULT_MODEL = "gpt-4o";
+const DEFAULT_TIMEOUT_MS = 120_000;
+export class OpenAIProvider {
+    client;
+    activeController = null;
+    constructor(apiKey, baseURL) {
+        this.client = new OpenAI({ apiKey, baseURL, timeout: DEFAULT_TIMEOUT_MS, maxRetries: 2 });
+    }
+    async *chat(request) {
+        const abortController = new AbortController();
+        this.activeController = abortController;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        try {
+            const stream = await this.client.chat.completions.create({
+                model: request.model || DEFAULT_MODEL,
+                messages: this.convertMessages(request.messages, request.system),
+                tools: this.convertTools(request.tools),
+                stream: true,
+                stream_options: { include_usage: true },
+            }, { signal: abortController.signal });
+            // Track pending tool calls across stream chunks
+            const pendingToolCalls = new Map();
+            let doneYielded = false;
+            for await (const chunk of stream) {
+                // Token usage chunk (when stream_options.include_usage is true)
+                if (chunk.usage) {
+                    inputTokens = chunk.usage.prompt_tokens;
+                    outputTokens = chunk.usage.completion_tokens;
+                    continue;
+                }
+                const choice = chunk.choices?.[0];
+                if (!choice)
+                    continue;
+                const delta = choice.delta;
+                // Accumulate tool call deltas
+                if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index;
+                        const existing = pendingToolCalls.get(idx) ?? {
+                            id: "",
+                            name: "",
+                            args: "",
+                        };
+                        if (tc.id)
+                            existing.id = tc.id;
+                        if (tc.function?.name)
+                            existing.name += tc.function.name;
+                        if (tc.function?.arguments)
+                            existing.args += tc.function.arguments;
+                        pendingToolCalls.set(idx, existing);
+                    }
+                }
+                // Text delta
+                if (delta.content) {
+                    yield { type: "text", content: delta.content };
+                }
+                // On finish_reason === "tool_calls", emit all pending tool_calls
+                if (choice.finish_reason === "tool_calls") {
+                    for (const [, tc] of pendingToolCalls) {
+                        yield {
+                            type: "tool_call",
+                            id: tc.id,
+                            name: tc.name,
+                            args: tc.args,
+                        };
+                    }
+                    pendingToolCalls.clear();
+                    yield {
+                        type: "done",
+                        usage: { input: inputTokens, output: outputTokens },
+                    };
+                    doneYielded = true;
+                }
+                // handle stop
+                if (choice.finish_reason === "stop") {
+                    yield {
+                        type: "done",
+                        usage: { input: inputTokens, output: outputTokens },
+                    };
+                    doneYielded = true;
+                }
+            }
+            // Ensure done is always yielded (e.g. when stream ends on usage chunk)
+            if (!doneYielded) {
+                yield {
+                    type: "done",
+                    usage: { input: inputTokens, output: outputTokens },
+                };
+            }
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (error.name === "AbortError" || error.name === "APIUserAbortError")) {
+                return; // Aborted silently
+            }
+            yield {
+                type: "error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            this.activeController = null;
+        }
+    }
+    abort() {
+        this.activeController?.abort();
+    }
+    // ── Message conversion ──────────────────────────────────────────────
+    convertMessages(messages, system) {
+        const result = [];
+        // Prepend system message if provided
+        if (system) {
+            result.push({ role: "system", content: system });
+        }
+        for (const msg of messages) {
+            switch (msg.role) {
+                case "user":
+                    result.push({ role: "user", content: msg.content });
+                    break;
+                case "assistant": {
+                    const toolCalls = msg.tool_calls?.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: {
+                            name: tc.name,
+                            arguments: tc.arguments,
+                        },
+                    }));
+                    if (toolCalls && toolCalls.length > 0) {
+                        result.push({
+                            role: "assistant",
+                            content: msg.content || null,
+                            tool_calls: toolCalls,
+                        });
+                    }
+                    else {
+                        result.push({ role: "assistant", content: msg.content });
+                    }
+                    break;
+                }
+                case "tool":
+                    result.push({
+                        role: "tool",
+                        tool_call_id: msg.tool_call_id ?? "",
+                        content: msg.content,
+                    });
+                    break;
+            }
+        }
+        return result;
+    }
+    // ── Tool conversion ─────────────────────────────────────────────────
+    convertTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return tools.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+}

package/dist/provider/provider.d.ts

@@ -0,0 +1,7 @@
+import { ChatRequest, StreamEvent } from "./types.js";
+import { ModelConfig } from "../config/types.js";
+export interface Provider {
+    chat(request: ChatRequest): AsyncGenerator<StreamEvent>;
+    abort(): void;
+}
+export declare function createProvider(config: ModelConfig): Provider;

package/dist/provider/provider.js

@@ -0,0 +1,21 @@
+import { AnthropicProvider } from "./adapters/anthropic.js";
+import { OpenAIProvider } from "./adapters/openai.js";
+import { GoogleProvider } from "./adapters/google.js";
+import { OllamaProvider } from "./adapters/ollama.js";
+export function createProvider(config) {
+    const key = config.api_key ?? "";
+    switch (config.provider) {
+        case "anthropic":
+            return new AnthropicProvider(key);
+        case "openai":
+            return new OpenAIProvider(key, config.endpoint);
+        case "google":
+            return new GoogleProvider(key);
+        case "ollama": {
+            const baseURL = config.endpoint?.replace(/\/v1\/?$/, "") ?? "http://localhost:11434";
+            return new OllamaProvider(baseURL);
+        }
+        default:
+            throw new Error(`Unknown provider: ${config.provider}`);
+    }
+}

package/dist/provider/types.d.ts

@@ -0,0 +1,41 @@
+export interface Message {
+    role: "user" | "assistant" | "tool";
+    content: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export interface TokenUsage {
+    input: number;
+    output: number;
+}
+export type StreamEvent = {
+    type: "text";
+    content: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    args: string;
+} | {
+    type: "done";
+    usage: TokenUsage;
+} | {
+    type: "error";
+    message: string;
+};
+export interface ChatRequest {
+    messages: Message[];
+    tools?: ToolDef[];
+    system?: string;
+    model?: string;
+}

package/dist/provider/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/builtin/bash.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const bashTool: ToolHandler;

package/dist/tools/builtin/bash.js

@@ -0,0 +1,34 @@
+import { execSync } from "node:child_process";
+export const bashTool = {
+    definition: {
+        name: "bash",
+        description: "Execute a shell command",
+        parameters: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Shell command to execute" },
+            },
+            required: ["command"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const command = args.command;
+        const dangerous = ["rm -rf /", "sudo ", "mkfs.", "dd if=", "> /dev/sda"];
+        for (const d of dangerous) {
+            if (command.includes(d))
+                return `Blocked: dangerous command pattern "${d}"`;
+        }
+        try {
+            const output = execSync(command, {
+                cwd: worktreePath,
+                encoding: "utf-8",
+                timeout: 30000,
+                maxBuffer: 1024 * 1024,
+            });
+            return output || "(no output)";
+        }
+        catch (err) {
+            return `Command failed (exit ${err.status}): ${err.stderr ?? err.message}`;
+        }
+    },
+};

package/dist/tools/builtin/editFile.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const editFileTool: ToolHandler;

package/dist/tools/builtin/editFile.js

@@ -0,0 +1,40 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const editFileTool = {
+    definition: {
+        name: "editFile",
+        description: "Replace a string in a file with a new string",
+        parameters: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the file to edit" },
+                oldString: { type: "string", description: "Exact text to replace" },
+                newString: { type: "string", description: "Replacement text" },
+                replaceAll: { type: "boolean", description: "Replace all occurrences (default: false)" },
+            },
+            required: ["filePath", "oldString", "newString"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const filePath = path.resolve(worktreePath, args.filePath);
+        if (!fs.existsSync(filePath))
+            return `File not found: ${args.filePath}`;
+        const content = fs.readFileSync(filePath, "utf-8");
+        const oldStr = args.oldString;
+        const newStr = args.newString;
+        const replaceAll = args.replaceAll;
+        if (!content.includes(oldStr)) {
+            return `Error: oldString not found in ${args.filePath}`;
+        }
+        const occurrences = content.split(oldStr).length - 1;
+        if (occurrences > 1 && !replaceAll) {
+            return `Error: oldString appears ${occurrences} times. Use replaceAll: true or provide more context.`;
+        }
+        const result = replaceAll
+            ? content.replaceAll(oldStr, newStr)
+            : content.replace(oldStr, newStr);
+        fs.writeFileSync(filePath, result, "utf-8");
+        const replaced = replaceAll ? occurrences : 1;
+        return `Replaced ${replaced} occurrence(s) in ${args.filePath}`;
+    },
+};

package/dist/tools/builtin/glob.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const globTool: ToolHandler;

package/dist/tools/builtin/glob.js

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+function globToRegex(pattern) {
+    let escaped = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*" && pattern[i + 2] === "/") {
+            escaped += ".*";
+            i += 3;
+            continue;
+        }
+        if (ch === "*" && pattern[i + 1] === "*") {
+            escaped += ".*";
+            i += 2;
+            continue;
+        }
+        if (ch === "*") {
+            escaped += "[^/]*";
+            i++;
+            continue;
+        }
+        if (ch === "?") {
+            escaped += ".";
+            i++;
+            continue;
+        }
+        if (".+^$(){}[]|\\".includes(ch)) {
+            escaped += "\\" + ch;
+        }
+        else {
+            escaped += ch;
+        }
+        i++;
+    }
+    return new RegExp(`^${escaped}$`);
+}
+function collectFiles(dir, base, results) {
+    if (!fs.existsSync(dir))
+        return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            collectFiles(full, base, results);
+        }
+        else if (e.isFile()) {
+            results.push(path.relative(base, full));
+        }
+    }
+}
+export const globTool = {
+    definition: {
+        name: "glob",
+        description: "Find files matching a glob pattern",
+        parameters: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Glob pattern (e.g. **/*.ts, src/**/*.tsx)" },
+                path: { type: "string", description: "Base directory to search in" },
+            },
+            required: ["pattern"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const pattern = args.pattern;
+        const base = path.resolve(worktreePath, args.path ?? ".");
+        const regex = globToRegex(pattern);
+        const files = [];
+        collectFiles(base, base, files);
+        const matches = files
+            .filter((f) => regex.test(f))
+            .sort()
+            .slice(0, 500);
+        return matches.length > 0 ? matches.join("\n") : "No files matched";
+    },
+};

package/dist/tools/builtin/grep.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const grepTool: ToolHandler;

package/dist/tools/builtin/grep.js

@@ -0,0 +1,120 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const MAX_RESULTS = 500;
+export const grepTool = {
+    definition: {
+        name: "grep",
+        description: "Search for a pattern in files using regex",
+        parameters: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Regex pattern to search for" },
+                path: { type: "string", description: "Directory or file to search in" },
+                include: { type: "string", description: "File glob pattern to include" },
+            },
+            required: ["pattern"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const cwd = args.path
+            ? path.resolve(worktreePath, args.path)
+            : worktreePath;
+        const pattern = args.pattern;
+        const include = args.include;
+        // Check if rg is available; use Node.js fallback if not
+        const rgAvailable = (() => {
+            try {
+                execSync("rg --version", { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (rgAvailable) {
+            try {
+                return tryRg(cwd, pattern, include);
+            }
+            catch (err) {
+                // rg found no matches (exit code 1)
+                if (err.status === 1)
+                    return "No matches found";
+                throw err;
+            }
+        }
+        return nodeGrep(cwd, pattern, include);
+    },
+};
+function tryRg(cwd, pattern, include) {
+    const inc = include ? `--glob="${include}"` : "";
+    const result = execSync(`rg -n --no-heading ${inc} "${pattern}" .`, {
+        cwd,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return result || "No matches found";
+}
+function nodeGrep(cwd, pattern, include) {
+    let regex;
+    try {
+        // Don't use 'g' flag — it makes .test() stateful across calls
+        regex = new RegExp(pattern);
+    }
+    catch {
+        return `Error: invalid regex pattern "${pattern}"`;
+    }
+    const includeRegex = include ? globToRegex(include) : null;
+    const results = [];
+    walkDir(cwd, cwd, (filePath) => {
+        if (includeRegex && !includeRegex.test(filePath))
+            return;
+        let content;
+        try {
+            content = fs.readFileSync(path.join(cwd, filePath), "utf-8");
+        }
+        catch {
+            return; // skip binary/unreadable
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length && results.length < MAX_RESULTS; i++) {
+            if (regex.test(lines[i])) {
+                // Normalize path separator for output
+                const displayPath = filePath.replace(/\\/g, "/");
+                results.push(`${displayPath}:${i + 1}:${lines[i].trimEnd()}`);
+            }
+        }
+    });
+    return results.length > 0 ? results.join("\n") : "No matches found";
+}
+function walkDir(base, dir, callback) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(base, fullPath);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git")
+                continue;
+            walkDir(base, fullPath, callback);
+        }
+        else if (entry.isFile()) {
+            // Skip binary-looking files
+            if (entry.name.endsWith(".exe") || entry.name.endsWith(".dll"))
+                continue;
+            callback(relPath);
+        }
+    }
+}
+function globToRegex(glob) {
+    let pattern = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${pattern}$`, "i");
+}

package/dist/tools/builtin/readFile.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const readFileTool: ToolHandler;

package/dist/tools/builtin/readFile.js

@@ -0,0 +1,27 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const readFileTool = {
+    definition: {
+        name: "readFile",
+        description: "Read the contents of a file",
+        parameters: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the file" },
+                offset: { type: "number", description: "Line offset to start reading from" },
+                limit: { type: "number", description: "Maximum number of lines to read" },
+            },
+            required: ["filePath"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const filePath = path.resolve(worktreePath, args.filePath);
+        if (!fs.existsSync(filePath))
+            return `File not found: ${args.filePath}`;
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const offset = args.offset ?? 0;
+        const limit = args.limit ?? lines.length;
+        return lines.slice(offset, offset + limit).join("\n");
+    },
+};

package/dist/tools/builtin/writeFile.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "../types.js";
+export declare const writeFileTool: ToolHandler;

package/dist/tools/builtin/writeFile.js

@@ -0,0 +1,29 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const writeFileTool = {
+    definition: {
+        name: "writeFile",
+        description: "Write content to a file (creates or overwrites)",
+        parameters: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the file to write" },
+                content: { type: "string", description: "Content to write to the file" },
+            },
+            required: ["filePath", "content"],
+        },
+    },
+    async execute(args, worktreePath) {
+        const filePath = path.resolve(worktreePath, args.filePath);
+        // Prevent writing outside the worktree
+        if (!filePath.startsWith(path.resolve(worktreePath))) {
+            return "Error: file path escapes the worktree";
+        }
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, args.content, "utf-8");
+        return `Wrote ${fs.statSync(filePath).size} bytes to ${args.filePath}`;
+    },
+};

package/dist/tools/permission.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionDecision } from "./types.js";
+export declare class PermissionManager {
+    private entries;
+    check(toolName: string, args: Record<string, unknown>): PermissionDecision;
+    remember(toolName: string, args: Record<string, unknown>, decision: "allow_always" | "deny_always"): void;
+    clear(): void;
+}

package/dist/tools/permission.js

@@ -0,0 +1,31 @@
+export class PermissionManager {
+    entries = [];
+    check(toolName, args) {
+        // Hard-coded safety rules
+        if (toolName === "bash") {
+            const cmd = String(args.command ?? "");
+            if (cmd.includes("rm -rf /") || cmd.includes("sudo ")) {
+                return "deny";
+            }
+        }
+        if (toolName === "readFile" || toolName === "grep") {
+            const path = String(args.path ?? args.filePath ?? "");
+            if (path.includes(".env") || path.includes(".git-credentials")) {
+                return "deny";
+            }
+        }
+        // Session memory
+        for (const entry of this.entries) {
+            if (entry.toolName === toolName) {
+                return entry.decision;
+            }
+        }
+        return "allow";
+    }
+    remember(toolName, args, decision) {
+        this.entries.push({ toolName, args, decision });
+    }
+    clear() {
+        this.entries = [];
+    }
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,9 @@
+import type { ToolDef } from "../provider/types.js";
+import type { ToolHandler } from "./types.js";
+export declare class ToolRegistry {
+    private tools;
+    register(handler: ToolHandler): void;
+    getDefinitions(): ToolDef[];
+    execute(name: string, args: Record<string, unknown>, worktreePath: string): Promise<string>;
+}
+export declare function createDefaultRegistry(): ToolRegistry;