multiarena 0.1.0

package/dist/config/loader.d.ts

@@ -0,0 +1,6 @@
+import { ArenaConfig } from "./types.js";
+export interface ConfigWarning {
+    message: string;
+}
+export declare function validateConfig(config: ArenaConfig): ConfigWarning[];
+export declare function loadConfig(): ArenaConfig;

package/dist/config/loader.js

@@ -0,0 +1,69 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import TOML from "@iarna/toml";
+import { DEFAULT_CONFIG } from "./types.js";
+function resolveEnvVars(value) {
+    return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "");
+}
+function resolveConfig(raw) {
+    const walk = (obj) => {
+        if (typeof obj === "string")
+            return resolveEnvVars(obj);
+        if (Array.isArray(obj))
+            return obj.map(walk);
+        if (obj && typeof obj === "object") {
+            const result = {};
+            for (const [k, v] of Object.entries(obj)) {
+                result[k] = walk(v);
+            }
+            return result;
+        }
+        return obj;
+    };
+    return walk(raw);
+}
+export function validateConfig(config) {
+    const warnings = [];
+    for (const name of config.defaults.active) {
+        const mc = config.models[name];
+        if (!mc) {
+            warnings.push({
+                message: `Model "${name}" is in defaults.active but has no [models.${name}] config section`,
+            });
+            continue;
+        }
+        if (!mc.provider) {
+            warnings.push({
+                message: `Model "${name}" has no provider set`,
+            });
+        }
+        if (!mc.api_key && mc.provider !== "ollama") {
+            warnings.push({
+                message: `Model "${name}" (${mc.provider}) has no api_key — set it or the \${ENV_VAR} may be missing`,
+            });
+        }
+    }
+    return warnings;
+}
+export function loadConfig() {
+    const candidates = [
+        path.join(process.cwd(), ".arenarc"),
+        path.join(os.homedir(), ".arenarc"),
+    ];
+    let resolved = {};
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            const raw = TOML.parse(fs.readFileSync(p, "utf-8"));
+            resolved = resolveConfig(raw);
+            break;
+        }
+    }
+    return {
+        models: resolved.models ?? {},
+        defaults: {
+            active: resolved.defaults?.active ?? DEFAULT_CONFIG.defaults?.active ?? [],
+            broadcast: resolved.defaults?.broadcast ?? DEFAULT_CONFIG.defaults?.broadcast ?? true,
+        },
+    };
+}

package/dist/config/types.d.ts

@@ -0,0 +1,15 @@
+export interface ModelConfig {
+    provider: "anthropic" | "openai" | "google" | "ollama";
+    model: string;
+    api_key?: string;
+    endpoint?: string;
+    context_limit?: number;
+}
+export interface ArenaConfig {
+    models: Record<string, ModelConfig>;
+    defaults: {
+        active: string[];
+        broadcast: boolean;
+    };
+}
+export declare const DEFAULT_CONFIG: Partial<ArenaConfig>;

package/dist/config/types.js

@@ -0,0 +1,6 @@
+export const DEFAULT_CONFIG = {
+    defaults: {
+        active: [],
+        broadcast: true,
+    },
+};

package/dist/core/session.d.ts

@@ -0,0 +1,40 @@
+import { Message } from "../provider/types.js";
+import { ModelState, TargetMode } from "./types.js";
+import { ArenaConfig } from "../config/types.js";
+export interface SessionSnapshot {
+    models: Array<{
+        name: string;
+        provider: string;
+        messages: Message[];
+        muted: boolean;
+        buffer: string;
+        usage: {
+            input: number;
+            output: number;
+        };
+        contextLimit: number;
+    }>;
+    targetMode: TargetMode;
+    worktreeBase: string;
+}
+export declare class Session {
+    private state;
+    constructor(config: ArenaConfig, worktreeBase: string, snapshot?: SessionSnapshot);
+    get models(): ModelState[];
+    get targetMode(): TargetMode;
+    /** Add a user message to the target model(s). Returns affected models. */
+    addUserMessage(content: string): ModelState[];
+    /** Append assistant response to a model's history */
+    addAssistantMessage(modelName: string, content: string): void;
+    /** Append tool result to a model's history */
+    addToolResult(modelName: string, toolCallId: string, result: string): void;
+    /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
+    cycleTarget(): TargetMode;
+    jumpToModel(modelName: string): void;
+    jumpToBroadcast(): void;
+    toggleMute(modelName: string): boolean;
+    resetModel(modelName: string): void;
+    getContextUsage(modelName: string): number;
+    toJSON(): SessionSnapshot;
+    private findModel;
+}

package/dist/core/session.js

@@ -0,0 +1,155 @@
+export class Session {
+    state;
+    constructor(config, worktreeBase, snapshot) {
+        if (snapshot) {
+            this.state = {
+                models: snapshot.models.map((m) => ({
+                    ...m,
+                    isStreaming: false,
+                    buffer: "",
+                })),
+                targetMode: snapshot.targetMode,
+                worktreeBase: snapshot.worktreeBase,
+            };
+        }
+        else {
+            const models = (config.defaults.active ?? []).map((name) => {
+                const mc = config.models[name];
+                return {
+                    name,
+                    provider: mc?.provider ?? "unknown",
+                    messages: [],
+                    muted: false,
+                    buffer: "",
+                    isStreaming: false,
+                    usage: { input: 0, output: 0 },
+                    contextLimit: contextLimitForModel(mc?.model ?? "", mc?.context_limit),
+                };
+            });
+            this.state = {
+                models,
+                targetMode: { type: "broadcast" },
+                worktreeBase,
+            };
+        }
+    }
+    get models() {
+        return this.state.models;
+    }
+    get targetMode() {
+        return this.state.targetMode;
+    }
+    /** Add a user message to the target model(s). Returns affected models. */
+    addUserMessage(content) {
+        if (this.state.targetMode.type === "broadcast") {
+            for (const m of this.state.models) {
+                if (!m.muted) {
+                    m.messages.push({ role: "user", content });
+                }
+            }
+            return this.state.models.filter((m) => !m.muted);
+        }
+        else {
+            const target = this.findModel(this.state.targetMode.modelName);
+            if (target) {
+                target.messages.push({ role: "user", content });
+            }
+            return target ? [target] : [];
+        }
+    }
+    /** Append assistant response to a model's history */
+    addAssistantMessage(modelName, content) {
+        const m = this.findModel(modelName);
+        if (m) {
+            m.messages.push({ role: "assistant", content });
+        }
+    }
+    /** Append tool result to a model's history */
+    addToolResult(modelName, toolCallId, result) {
+        const m = this.findModel(modelName);
+        if (m) {
+            m.messages.push({ role: "tool", content: result, tool_call_id: toolCallId });
+        }
+    }
+    /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
+    cycleTarget() {
+        const current = this.state.targetMode;
+        if (current.type === "broadcast") {
+            const first = this.state.models[0];
+            this.state.targetMode = first
+                ? { type: "directed", modelName: first.name }
+                : current;
+        }
+        else {
+            const idx = this.state.models.findIndex((m) => m.name === current.modelName);
+            const next = this.state.models[idx + 1];
+            this.state.targetMode = next
+                ? { type: "directed", modelName: next.name }
+                : { type: "broadcast" };
+        }
+        return this.state.targetMode;
+    }
+    jumpToModel(modelName) {
+        const exists = this.state.models.some((m) => m.name === modelName);
+        if (exists) {
+            this.state.targetMode = { type: "directed", modelName };
+        }
+    }
+    jumpToBroadcast() {
+        this.state.targetMode = { type: "broadcast" };
+    }
+    toggleMute(modelName) {
+        const m = this.findModel(modelName);
+        if (m)
+            m.muted = !m.muted;
+        return m?.muted ?? false;
+    }
+    resetModel(modelName) {
+        const m = this.findModel(modelName);
+        if (m) {
+            m.messages = [];
+            m.buffer = "";
+            m.usage = { input: 0, output: 0 };
+        }
+    }
+    getContextUsage(modelName) {
+        const m = this.findModel(modelName);
+        if (!m || m.contextLimit <= 0)
+            return 0;
+        const totalTokens = m.usage.input + m.usage.output;
+        return Math.min(1, totalTokens / m.contextLimit);
+    }
+    toJSON() {
+        return {
+            models: this.state.models.map((m) => ({
+                name: m.name,
+                provider: m.provider,
+                messages: [...m.messages],
+                muted: m.muted,
+                buffer: m.buffer,
+                usage: { ...m.usage },
+                contextLimit: m.contextLimit,
+            })),
+            targetMode: this.state.targetMode,
+            worktreeBase: this.state.worktreeBase,
+        };
+    }
+    findModel(name) {
+        return this.state.models.find((m) => m.name === name);
+    }
+}
+function contextLimitForModel(model, explicit) {
+    if (explicit && explicit > 0)
+        return explicit;
+    if (model.includes("claude"))
+        return 200000;
+    if (model.includes("gpt-4"))
+        return 128000;
+    if (model.includes("gpt-3.5"))
+        return 16384;
+    if (model.includes("gemini"))
+        return 1048576;
+    if (model.includes("deepseek"))
+        return 128000;
+    return 128000;
+}

package/dist/core/turn.d.ts

@@ -0,0 +1,31 @@
+import type { StreamEvent, Message, ToolDef } from "../provider/types.js";
+import type { ModelConfig } from "../config/types.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { PermissionManager } from "../tools/permission.js";
+export interface TurnContext {
+    modelName: string;
+    config: ModelConfig;
+    messages: Message[];
+    systemPrompt: string;
+    tools: ToolDef[];
+    registry: ToolRegistry;
+    permission: PermissionManager;
+    worktreePath: string;
+}
+export interface TurnResult {
+    /** The final assistant text (excluding tool result annotations). */
+    text: string;
+    /** Whether the turn ended with an error. */
+    error: boolean;
+}
+/**
+ * Run a single model turn with tool-call looping.
+ *
+ * Yields StreamEvents for real-time UI rendering. Tool calls are intercepted,
+ * executed, and their results are fed back to the model via ctx.messages so
+ * the conversation can continue.
+ *
+ * After the turn completes, all messages (assistant, tool calls, tool results)
+ * have been pushed into ctx.messages — the caller only needs to persist.
+ */
+export declare function runTurn(ctx: TurnContext): AsyncGenerator<StreamEvent>;

package/dist/core/turn.js

@@ -0,0 +1,112 @@
+import { createProvider } from "../provider/provider.js";
+const MAX_TOOL_ROUNDS = 10;
+/**
+ * Run a single model turn with tool-call looping.
+ *
+ * Yields StreamEvents for real-time UI rendering. Tool calls are intercepted,
+ * executed, and their results are fed back to the model via ctx.messages so
+ * the conversation can continue.
+ *
+ * After the turn completes, all messages (assistant, tool calls, tool results)
+ * have been pushed into ctx.messages — the caller only needs to persist.
+ */
+export async function* runTurn(ctx) {
+    const allText = [];
+    let provider = null;
+    try {
+        for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+            provider = createProvider(ctx.config);
+            const request = {
+                messages: [...ctx.messages],
+                tools: ctx.tools.length > 0 ? ctx.tools : undefined,
+                system: ctx.systemPrompt,
+                model: ctx.config.model,
+            };
+            const pendingToolCalls = [];
+            let hasToolCall = false;
+            let roundText = "";
+            let lastUsage = { input: 0, output: 0 };
+            for await (const event of provider.chat(request)) {
+                switch (event.type) {
+                    case "text":
+                        roundText += event.content;
+                        allText.push(event.content);
+                        yield event;
+                        break;
+                    case "tool_call":
+                        hasToolCall = true;
+                        pendingToolCalls.push({
+                            id: event.id,
+                            name: event.name,
+                            arguments: event.args,
+                        });
+                        break;
+                    case "error":
+                        yield event;
+                        return;
+                    case "done":
+                        lastUsage = event.usage;
+                        break;
+                }
+            }
+            // No tool calls — this round is the final answer
+            if (!hasToolCall) {
+                if (roundText) {
+                    ctx.messages.push({ role: "assistant", content: roundText });
+                }
+                yield { type: "done", usage: lastUsage };
+                return;
+            }
+            // Record assistant message with any text + tool calls
+            ctx.messages.push({
+                role: "assistant",
+                content: roundText,
+                tool_calls: pendingToolCalls,
+            });
+            // Execute tools and feed results back
+            for (const tc of pendingToolCalls) {
+                const toolLabel = `\n[Tool: ${tc.name}]\n`;
+                allText.push(toolLabel);
+                yield { type: "text", content: toolLabel };
+                let args;
+                try {
+                    args = JSON.parse(tc.arguments);
+                }
+                catch {
+                    const errMsg = `Failed to parse tool arguments: ${tc.arguments}`;
+                    ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
+                    allText.push(errMsg + "\n");
+                    yield { type: "text", content: errMsg + "\n" };
+                    continue;
+                }
+                const decision = ctx.permission.check(tc.name, args);
+                if (decision === "deny" || decision === "deny_always") {
+                    const errMsg = `Permission denied for tool: ${tc.name}`;
+                    ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
+                    allText.push(errMsg + "\n");
+                    yield { type: "text", content: errMsg + "\n" };
+                    continue;
+                }
+                let result;
+                try {
+                    result = await ctx.registry.execute(tc.name, args, ctx.worktreePath);
+                }
+                catch (err) {
+                    result = `Error executing ${tc.name}: ${err.message}`;
+                }
+                ctx.messages.push({ role: "tool", content: result, tool_call_id: tc.id });
+                allText.push(result + "\n");
+                yield { type: "text", content: result + "\n" };
+            }
+            // Loop continues — model sees tool results via ctx.messages
+        }
+        // Exceeded max rounds
+        yield {
+            type: "error",
+            message: `Exceeded maximum tool rounds (${MAX_TOOL_ROUNDS})`,
+        };
+    }
+    finally {
+        provider?.abort();
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,25 @@
+import { Message } from "../provider/types.js";
+export type TargetMode = {
+    type: "broadcast";
+} | {
+    type: "directed";
+    modelName: string;
+};
+export interface ModelState {
+    name: string;
+    provider: string;
+    messages: Message[];
+    muted: boolean;
+    buffer: string;
+    isStreaming: boolean;
+    usage: {
+        input: number;
+        output: number;
+    };
+    contextLimit: number;
+}
+export interface SessionState {
+    models: ModelState[];
+    targetMode: TargetMode;
+    worktreeBase: string;
+}

package/dist/core/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import React from "react";
+import { render } from "ink";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { App } from "./ui/app.js";
+import { listSessions } from "./persistence/session.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => {
+    try {
+        const pkgPath = path.join(__dirname, "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.1.0";
+    }
+    catch {
+        return "0.1.0";
+    }
+})();
+const HELP = `Arena — Multi-Model AI Coding Assistant
+
+Usage:
+  arena [options]
+
+Options:
+  --new              Start a new session (default)
+  --resume <id>      Resume a saved session
+  --list             List saved sessions
+  --help             Show this help
+  --version          Show version`;
+function parseArgs() {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        return { listOnly: false, showHelp: true, showVersion: false };
+    }
+    if (args.includes("--version") || args.includes("-v")) {
+        return { listOnly: false, showHelp: false, showVersion: true };
+    }
+    const resumeIdx = args.indexOf("--resume");
+    if (resumeIdx >= 0 && args[resumeIdx + 1]) {
+        return {
+            sessionId: args[resumeIdx + 1],
+            listOnly: false,
+            showHelp: false,
+            showVersion: false,
+        };
+    }
+    if (args.includes("--list") || args.includes("--list-sessions")) {
+        return { listOnly: true, showHelp: false, showVersion: false };
+    }
+    return { listOnly: false, showHelp: false, showVersion: false };
+}
+const { sessionId, listOnly, showHelp, showVersion } = parseArgs();
+if (showHelp) {
+    console.log(HELP);
+    process.exit(0);
+}
+if (showVersion) {
+    console.log(`arena v${PKG_VERSION}`);
+    process.exit(0);
+}
+if (listOnly) {
+    const sessions = listSessions();
+    if (sessions.length === 0) {
+        console.log("No saved sessions.");
+    }
+    else {
+        console.log("Saved sessions:");
+        for (const s of sessions) {
+            const models = s.models.map((m) => m.name).join(", ");
+            console.log(`  ${s.id}  ${s.timestamp}  [${models}]`);
+        }
+    }
+    process.exit(0);
+}
+render(React.createElement(App, { sessionId }));

package/dist/isolation/worktree.d.ts

@@ -0,0 +1,11 @@
+export declare class WorktreeManager {
+    private git;
+    private worktrees;
+    constructor(repoPath: string);
+    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    sweepOrphans(): Promise<number>;
+    setup(taskId: string, modelNames: string[]): Promise<Map<string, string>>;
+    getWorktreePath(modelName: string): string | undefined;
+    getDiff(modelName: string): Promise<string>;
+    cleanup(taskId: string, keepModel?: string): Promise<void>;
+}

package/dist/isolation/worktree.js

@@ -0,0 +1,117 @@
+import { simpleGit } from "simple-git";
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+export class WorktreeManager {
+    git;
+    worktrees = new Map();
+    constructor(repoPath) {
+        this.git = simpleGit(repoPath);
+    }
+    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    async sweepOrphans() {
+        let cleaned = 0;
+        // Parse registered worktrees from `git worktree list --porcelain`
+        const registeredPaths = new Set();
+        const registeredBranches = new Set();
+        try {
+            const raw = await this.git.raw(["worktree", "list", "--porcelain"]);
+            let currentPath = null;
+            for (const line of raw.split("\n")) {
+                if (line.startsWith("worktree ")) {
+                    currentPath = line.slice("worktree ".length);
+                    registeredPaths.add(currentPath);
+                }
+                else if (line.startsWith("branch ") && currentPath) {
+                    // branch line looks like "branch refs/heads/arena/..."
+                    const ref = line.slice("branch ".length);
+                    const branchName = ref.replace("refs/heads/", "");
+                    registeredBranches.add(branchName);
+                }
+            }
+        }
+        catch {
+            return cleaned;
+        }
+        // Remove orphaned arena branches (branch exists but no worktree)
+        const branches = await this.git.branchLocal();
+        for (const branch of branches.all) {
+            if (!branch.startsWith("arena/"))
+                continue;
+            if (!registeredBranches.has(branch)) {
+                await this.git.deleteLocalBranch(branch, true).catch(() => { });
+                cleaned++;
+            }
+        }
+        // Remove orphaned worktree directories (dir exists but not registered)
+        const arenaDir = path.join(os.tmpdir(), "arena-worktrees");
+        if (fs.existsSync(arenaDir)) {
+            let entries = [];
+            try {
+                entries = fs.readdirSync(arenaDir);
+            }
+            catch { /* ignore */ }
+            for (const entry of entries) {
+                const fullPath = path.join(arenaDir, entry);
+                if (!registeredPaths.has(fullPath)) {
+                    try {
+                        // Try git worktree remove first, then force delete
+                        await this.git.raw(["worktree", "remove", fullPath, "--force"]).catch(() => { });
+                        fs.rmSync(fullPath, { recursive: true, force: true });
+                        cleaned++;
+                    }
+                    catch { /* best effort */ }
+                }
+            }
+        }
+        return cleaned;
+    }
+    async setup(taskId, modelNames) {
+        const baseName = `arena/${taskId}`;
+        for (const name of modelNames) {
+            const branchName = `${baseName}-${name}`;
+            const worktreePath = path.join(os.tmpdir(), "arena-worktrees", `${taskId}-${name}`);
+            // Ensure the parent directory exists; git worktree add creates the leaf directory
+            fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+            // Remove leftover directory from a previous run that wasn't cleaned up
+            if (fs.existsSync(worktreePath)) {
+                await this.git.raw(["worktree", "remove", worktreePath, "--force"]).catch(() => {
+                    fs.rmSync(worktreePath, { recursive: true, force: true });
+                });
+            }
+            // Clean up any leftover branch from previous runs
+            await this.git.deleteLocalBranch(branchName, true).catch(() => { });
+            // Create the branch and add the worktree
+            await this.git.branch([branchName]);
+            await this.git.raw(["worktree", "add", worktreePath, branchName]);
+            this.worktrees.set(name, worktreePath);
+        }
+        return this.worktrees;
+    }
+    getWorktreePath(modelName) {
+        return this.worktrees.get(modelName);
+    }
+    async getDiff(modelName) {
+        const wt = this.worktrees.get(modelName);
+        if (!wt)
+            return "";
+        const wtGit = simpleGit(wt);
+        return await wtGit.diff();
+    }
+    async cleanup(taskId, keepModel) {
+        for (const [modelName, wtPath] of this.worktrees) {
+            if (modelName === keepModel)
+                continue;
+            try {
+                await this.git.raw(["worktree", "remove", wtPath, "--force"]);
+            }
+            catch {
+                fs.rmSync(wtPath, { recursive: true, force: true });
+            }
+            await this.git
+                .deleteLocalBranch(`arena/${taskId}-${modelName}`, true)
+                .catch(() => { });
+            this.worktrees.delete(modelName);
+        }
+    }
+}