multiarena 0.1.0

package/dist/tools/registry.js

@@ -0,0 +1,37 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(handler) {
+        this.tools.set(handler.definition.name, handler);
+    }
+    getDefinitions() {
+        return Array.from(this.tools.values()).map((h) => h.definition);
+    }
+    async execute(name, args, worktreePath) {
+        const handler = this.tools.get(name);
+        if (!handler) {
+            return `Error: unknown tool "${name}"`;
+        }
+        try {
+            return await handler.execute(args, worktreePath);
+        }
+        catch (err) {
+            return `Error executing ${name}: ${err.message}`;
+        }
+    }
+}
+import { readFileTool } from "./builtin/readFile.js";
+import { grepTool } from "./builtin/grep.js";
+import { bashTool } from "./builtin/bash.js";
+import { globTool } from "./builtin/glob.js";
+import { writeFileTool } from "./builtin/writeFile.js";
+import { editFileTool } from "./builtin/editFile.js";
+export function createDefaultRegistry() {
+    const registry = new ToolRegistry();
+    registry.register(readFileTool);
+    registry.register(grepTool);
+    registry.register(bashTool);
+    registry.register(globTool);
+    registry.register(writeFileTool);
+    registry.register(editFileTool);
+    return registry;
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDef } from "../provider/types.js";
+export interface ToolHandler {
+    definition: ToolDef;
+    execute(args: Record<string, unknown>, worktreePath: string): Promise<string>;
+}
+export type PermissionDecision = "allow" | "deny" | "allow_always" | "deny_always";
+export interface PermissionEntry {
+    toolName: string;
+    args: Record<string, unknown>;
+    decision: "allow_always" | "deny_always";
+}

package/dist/tools/types.js

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

package/dist/ui/app.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const App: React.FC<{
+    sessionId?: string;
+}>;

package/dist/ui/app.js

@@ -0,0 +1,343 @@
+import React, { useState, useCallback, useEffect, useRef } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { StatusBar } from "./components/StatusBar.js";
+import { OutputArea } from "./components/OutputArea.js";
+import { InputBar } from "./components/InputBar.js";
+import { Session } from "../core/session.js";
+import { loadConfig, validateConfig } from "../config/loader.js";
+import { createDefaultRegistry } from "../tools/registry.js";
+import { PermissionManager } from "../tools/permission.js";
+import { runTurn } from "../core/turn.js";
+import { WorktreeManager } from "../isolation/worktree.js";
+import { saveSession, loadSession } from "../persistence/session.js";
+const SYSTEM_PROMPT = "You are a helpful AI coding assistant. Be concise.";
+// App-level (module-scoped) tool registry and permission manager.
+// Created once and shared across all submissions.
+const toolRegistry = createDefaultRegistry();
+const permissionManager = new PermissionManager();
+export const App = ({ sessionId: initialSessionId }) => {
+    const config = loadConfig();
+    const configWarnings = validateConfig(config);
+    const { exit } = useApp();
+    // Generate or reuse session ID
+    const [sessionId] = useState(() => initialSessionId ?? Date.now().toString(36));
+    // Load saved session or create fresh one
+    const [session] = useState(() => {
+        if (initialSessionId) {
+            const saved = loadSession(initialSessionId);
+            if (saved) {
+                const snapshot = {
+                    models: saved.models.map((m) => ({
+                        name: m.name,
+                        provider: config.models[m.name]?.provider ?? "unknown",
+                        messages: m.messages,
+                        muted: false,
+                        buffer: "",
+                        usage: { input: 0, output: 0 },
+                        contextLimit: 128000,
+                    })),
+                    targetMode: saved.lastTarget === "broadcast"
+                        ? { type: "broadcast" }
+                        : { type: "directed", modelName: saved.lastTarget },
+                    worktreeBase: process.cwd(),
+                };
+                return new Session(config, process.cwd(), snapshot);
+            }
+        }
+        return new Session(config, process.cwd());
+    });
+    const [input, setInput] = useState("");
+    const [scrollOffsets, setScrollOffsets] = useState({});
+    const [modelStates, setModelStates] = useState(() => session.models);
+    const [comparisonModel, setComparisonModel] = useState(null);
+    const activeScrollModel = session.targetMode.type === "directed" ? session.targetMode.modelName : null;
+    const adjustScroll = useCallback((delta) => {
+        const modelName = activeScrollModel;
+        if (!modelName)
+            return;
+        setScrollOffsets((prev) => ({
+            ...prev,
+            [modelName]: Math.max(0, (prev[modelName] ?? 0) + delta),
+        }));
+    }, [activeScrollModel]);
+    // Input history
+    const inputHistoryRef = useRef([]);
+    const historyIdxRef = useRef(-1);
+    const handleInputChange = useCallback((value) => {
+        // Reset history navigation when user starts typing
+        if (historyIdxRef.current !== -1) {
+            historyIdxRef.current = -1;
+        }
+        setInput(value);
+    }, []);
+    // Track whether a shortcut key was just handled so we can clear the input
+    // bar in a post-render effect (avoids ink-text-input re-populating it).
+    const shortcutHandledRef = useRef(false);
+    // ── Save helper (used by handleSubmit and quit) ──────────────────
+    const saveCurrentSession = useCallback(() => {
+        const lastTarget = session.targetMode.type === "broadcast"
+            ? "broadcast"
+            : session.targetMode.modelName;
+        saveSession({
+            id: sessionId,
+            timestamp: new Date().toISOString(),
+            models: session.models.map((m) => ({
+                name: m.name,
+                messages: m.messages.map((msg) => ({
+                    role: msg.role,
+                    content: msg.content,
+                    tool_call_id: msg.tool_call_id,
+                })),
+                buffer: m.buffer,
+            })),
+            lastTarget,
+        });
+    }, [session, sessionId]);
+    const targetPrefix = session.targetMode.type === "broadcast"
+        ? "all"
+        : session.targetMode.modelName;
+    const activeModelName = session.targetMode.type === "broadcast" ? null : session.targetMode.modelName;
+    // Save session on process exit (Ctrl+C, kill, etc.)
+    useEffect(() => {
+        const onExit = () => {
+            try {
+                saveCurrentSession();
+            }
+            catch {
+                // Best-effort save
+            }
+        };
+        process.on("exit", onExit);
+        return () => {
+            process.off("exit", onExit);
+        };
+    }, [saveCurrentSession]);
+    // Clean up orphaned worktrees from prior crashes on startup
+    useEffect(() => {
+        const wm = new WorktreeManager(process.cwd());
+        wm.sweepOrphans().catch(() => { });
+    }, []);
+    // Clear the input bar whenever a shortcut was handled (runs after the render
+    // batch so it overrides any concurrent setInput from ink-text-input).
+    useEffect(() => {
+        if (shortcutHandledRef.current) {
+            shortcutHandledRef.current = false;
+            setInput("");
+        }
+    });
+    // Keyboard input: Tab cycling, scrolling, and single-key shortcuts.
+    // Single-key shortcuts (d/m/r) only fire when the input bar is empty so they
+    // don't interfere with message typing.
+    useInput((inputValue, key) => {
+        if (key.tab) {
+            session.cycleTarget();
+            setComparisonModel(null);
+            setModelStates([...session.models]);
+            return;
+        }
+        // Escape dismisses comparison mode
+        if (key.escape) {
+            if (comparisonModel) {
+                setComparisonModel(null);
+                shortcutHandledRef.current = true;
+                return;
+            }
+        }
+        if (key.upArrow) {
+            if (input.length === 0) {
+                const history = inputHistoryRef.current;
+                if (history.length === 0)
+                    return;
+                const idx = historyIdxRef.current === -1 ? history.length - 1 : Math.max(0, historyIdxRef.current - 1);
+                historyIdxRef.current = idx;
+                setInput(history[idx]);
+            }
+            else {
+                adjustScroll(-1);
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (input.length === 0) {
+                const history = inputHistoryRef.current;
+                if (historyIdxRef.current === -1)
+                    return;
+                const idx = historyIdxRef.current + 1;
+                if (idx >= history.length) {
+                    historyIdxRef.current = -1;
+                    setInput("");
+                }
+                else {
+                    historyIdxRef.current = idx;
+                    setInput(history[idx]);
+                }
+            }
+            else {
+                adjustScroll(1);
+            }
+            return;
+        }
+        // Single-key shortcuts — only active when the input bar is empty
+        // so they don't collide with normal message typing.
+        if (input.length > 0)
+            return;
+        if (key.ctrl || key.meta)
+            return;
+        // 'd' — toggle comparison mode (current model vs next unmuted model)
+        if (inputValue === "d") {
+            if (comparisonModel) {
+                setComparisonModel(null);
+            }
+            else {
+                const unmuted = session.models.filter((m) => !m.muted);
+                const baseName = session.targetMode.type === "directed"
+                    ? session.targetMode.modelName
+                    : unmuted[0]?.name;
+                if (baseName && unmuted.length >= 2) {
+                    const idx = unmuted.findIndex((m) => m.name === baseName);
+                    const next = unmuted[(idx + 1) % unmuted.length];
+                    if (next && next.name !== baseName) {
+                        setComparisonModel(next.name);
+                    }
+                }
+            }
+            shortcutHandledRef.current = true;
+            return;
+        }
+        // 'm' — mute/unmute the current directed model
+        if (inputValue === "m") {
+            if (session.targetMode.type === "directed") {
+                session.toggleMute(session.targetMode.modelName);
+                setModelStates([...session.models]);
+                setComparisonModel(null);
+            }
+            shortcutHandledRef.current = true;
+            return;
+        }
+        // 'r' — reset the current directed model's context (clear history & buffer)
+        if (inputValue === "r") {
+            if (session.targetMode.type === "directed") {
+                session.resetModel(session.targetMode.modelName);
+                setModelStates([...session.models]);
+            }
+            shortcutHandledRef.current = true;
+            return;
+        }
+        // 'q' — quit (save session and exit)
+        if (inputValue === "q") {
+            saveCurrentSession();
+            exit();
+            return;
+        }
+    });
+    const handleSubmit = useCallback(async (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        // Add to input history
+        inputHistoryRef.current.push(trimmed);
+        historyIdxRef.current = -1;
+        setInput("");
+        if (activeScrollModel) {
+            setScrollOffsets((prev) => ({ ...prev, [activeScrollModel]: 0 }));
+        }
+        setComparisonModel(null);
+        // ── Worktree setup ──────────────────────────────────────────
+        const taskId = Date.now().toString(36);
+        const worktreeManager = new WorktreeManager(process.cwd());
+        const modelNames = session.models
+            .filter((m) => !m.muted)
+            .map((m) => m.name);
+        await worktreeManager.setup(taskId, modelNames);
+        // Add user message to target models
+        const targets = session.addUserMessage(trimmed);
+        setModelStates([...session.models]);
+        // Mark targets as streaming, clear buffers
+        for (const t of targets) {
+            t.isStreaming = true;
+            t.buffer = "";
+        }
+        setModelStates([...session.models]);
+        // Launch concurrent turns for all target models
+        await Promise.all(targets.map(async (m) => {
+            const mc = config.models[m.name];
+            if (!mc) {
+                m.buffer = `[Error: No config for model "${m.name}"]`;
+                m.isStreaming = false;
+                setModelStates([...session.models]);
+                return;
+            }
+            const worktreePath = worktreeManager.getWorktreePath(m.name) ?? process.cwd();
+            const stream = runTurn({
+                modelName: m.name,
+                config: mc,
+                messages: m.messages,
+                systemPrompt: SYSTEM_PROMPT,
+                tools: toolRegistry.getDefinitions(),
+                registry: toolRegistry,
+                permission: permissionManager,
+                worktreePath,
+            });
+            for await (const event of stream) {
+                if (event.type === "text") {
+                    m.buffer += event.content;
+                }
+                else if (event.type === "done") {
+                    m.usage.input += event.usage.input;
+                    m.usage.output += event.usage.output;
+                    m.isStreaming = false;
+                }
+                else if (event.type === "error") {
+                    m.buffer += `\n[Error: ${event.message}]`;
+                    m.isStreaming = false;
+                }
+                setModelStates([...session.models]);
+            }
+        }));
+        // ── Worktree cleanup (keep none by default) ─────────────────
+        await worktreeManager.cleanup(taskId);
+        // ── Auto-save session ─────────────────────────────────────
+        saveCurrentSession();
+    }, [session, config, sessionId, saveCurrentSession]);
+    const terminalWidth = process.stdout.columns ?? 80;
+    const contextUsages = {};
+    for (const m of modelStates) {
+        contextUsages[m.name] = session.getContextUsage(m.name);
+    }
+    // ── No models configured: show startup guide ──────────────────
+    if (modelStates.length === 0) {
+        const example = `[models.claude]
+provider = "anthropic"
+model = "claude-sonnet-4-6"
+api_key = "\${ANTHROPIC_API_KEY}"
+
+[models.gpt]
+provider = "openai"
+model = "gpt-4o"
+api_key = "\${OPENAI_API_KEY}"
+
+[defaults]
+active = ["claude", "gpt"]
+broadcast = true`;
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "Arena \u2014 Multi-Model AI Coding Assistant"),
+            React.createElement(Text, null, " "),
+            React.createElement(Text, null,
+                "No models configured. Create a ",
+                React.createElement(Text, { color: "yellow" }, ".arenarc"),
+                " file in your project root or home directory:"),
+            React.createElement(Text, null, " "),
+            React.createElement(Text, { color: "gray" }, example),
+            React.createElement(Text, null, " "),
+            React.createElement(Text, { dimColor: true }, "Supported providers: anthropic, openai, google, ollama")));
+    }
+    return (React.createElement(Box, { flexDirection: "column", width: "100%" },
+        React.createElement(StatusBar, { models: modelStates, activeModelName: activeModelName, contextUsages: contextUsages }),
+        configWarnings.length > 0 && (React.createElement(Box, { flexDirection: "column" }, configWarnings.map((w, i) => (React.createElement(Text, { key: i, color: "yellow" },
+            "\u26A0 ",
+            w.message))))),
+        React.createElement(Text, null, "─".repeat(terminalWidth)),
+        React.createElement(OutputArea, { models: modelStates, targetMode: session.targetMode, scrollOffsets: scrollOffsets, comparisonModel: comparisonModel }),
+        React.createElement(Text, null, "─".repeat(terminalWidth)),
+        React.createElement(InputBar, { prefix: targetPrefix, value: input, onChange: handleInputChange, onSubmit: handleSubmit })));
+};

package/dist/ui/components/BroadcastSummary.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { ModelState } from "../../core/types.js";
+interface Props {
+    models: ModelState[];
+}
+export declare const BroadcastSummary: React.FC<Props>;
+export {};

package/dist/ui/components/BroadcastSummary.js

@@ -0,0 +1,18 @@
+import React from "react";
+import { Box, Text } from "ink";
+const PANEL_LINES = 4;
+export const BroadcastSummary = ({ models }) => {
+    const activeModels = models.filter((m) => !m.muted);
+    return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 }, activeModels.map((m) => {
+        const lines = m.buffer.split("\n").slice(0, PANEL_LINES);
+        const totalLines = m.buffer.split("\n").length;
+        return (React.createElement(Box, { key: m.name, flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "gray", marginRight: 1 },
+            React.createElement(Text, { bold: true }, m.name),
+            lines.map((line, i) => (React.createElement(Text, { key: i, wrap: "truncate" }, line || " "))),
+            totalLines === 0 && (React.createElement(Text, { dimColor: true }, "Waiting...")),
+            React.createElement(Text, { dimColor: true },
+                totalLines,
+                " lines \u00B7 ",
+                m.isStreaming ? "streaming..." : "done")));
+    })));
+};

package/dist/ui/components/InputBar.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface Props {
+    prefix: string;
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+}
+export declare const InputBar: React.FC<Props>;
+export {};

package/dist/ui/components/InputBar.js

@@ -0,0 +1,11 @@
+import React from "react";
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+export const InputBar = ({ prefix, value, onChange, onSubmit }) => (React.createElement(Box, { height: 1, flexDirection: "row" },
+    React.createElement(Box, { marginRight: 1 },
+        React.createElement(Text, { color: "green" },
+            "[",
+            prefix,
+            "]")),
+    React.createElement(Text, null, "> "),
+    React.createElement(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit })));

package/dist/ui/components/ModelDetail.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ModelState } from "../../core/types.js";
+interface Props {
+    model: ModelState;
+    scrollOffset: number;
+}
+export declare const ModelDetail: React.FC<Props>;
+export {};

package/dist/ui/components/ModelDetail.js

@@ -0,0 +1,13 @@
+import React from "react";
+import { Box, Text } from "ink";
+export const ModelDetail = ({ model, scrollOffset }) => {
+    const allLines = model.buffer.split("\n");
+    const visibleLines = allLines.slice(scrollOffset);
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        visibleLines.length === 0 && !model.isStreaming && (React.createElement(Text, { dimColor: true }, "No output yet")),
+        visibleLines.map((line, i) => {
+            const isError = /^\[?(?:Error|error)[:\]]/.test(line);
+            return (React.createElement(Text, { key: scrollOffset + i, color: isError ? "red" : undefined }, line || " "));
+        }),
+        model.isStreaming && React.createElement(Text, { color: "gray" }, "\u258B")));
+};

package/dist/ui/components/OutputArea.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { ModelState } from "../../core/types.js";
+interface Props {
+    models: ModelState[];
+    targetMode: {
+        type: "broadcast";
+    } | {
+        type: "directed";
+        modelName: string;
+    };
+    scrollOffsets: Record<string, number>;
+    comparisonModel?: string | null;
+}
+export declare const OutputArea: React.FC<Props>;
+export {};

package/dist/ui/components/OutputArea.js

@@ -0,0 +1,29 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { BroadcastSummary } from "./BroadcastSummary.js";
+import { ModelDetail } from "./ModelDetail.js";
+export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel, }) => {
+    if (targetMode.type === "broadcast") {
+        return React.createElement(BroadcastSummary, { models: models });
+    }
+    const activeModel = models.find((m) => m.name === targetMode.modelName);
+    if (!activeModel) {
+        return (React.createElement(Box, { flexGrow: 1 },
+            React.createElement(Text, null, "No model selected")));
+    }
+    // ── Comparison mode: two models side by side ──────────────────
+    if (comparisonModel) {
+        const compModel = models.find((m) => m.name === comparisonModel);
+        if (!compModel) {
+            return React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 });
+        }
+        return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 },
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1, marginRight: 1 },
+                React.createElement(Text, { bold: true }, activeModel.name),
+                React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 })),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(Text, { bold: true }, compModel.name),
+                React.createElement(ModelDetail, { model: compModel, scrollOffset: scrollOffsets[compModel.name] ?? 0 }))));
+    }
+    return React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 });
+};

package/dist/ui/components/StatusBar.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { ModelState } from "../../core/types.js";
+interface Props {
+    models: ModelState[];
+    activeModelName: string | null;
+    contextUsages: Record<string, number>;
+}
+export declare const StatusBar: React.FC<Props>;
+export {};

package/dist/ui/components/StatusBar.js

@@ -0,0 +1,51 @@
+import React from "react";
+import { Box, Text } from "ink";
+function renderBar(ratio) {
+    const blocks = 10;
+    const filled = Math.round(ratio * blocks);
+    return "█".repeat(filled) + "░".repeat(blocks - filled);
+}
+function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}K`;
+    return String(n);
+}
+function barColor(ratio) {
+    if (ratio > 0.9)
+        return "red";
+    if (ratio > 0.7)
+        return "yellow";
+    return "green";
+}
+export const StatusBar = ({ models, activeModelName, contextUsages }) => (React.createElement(Box, { flexDirection: "column" },
+    React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {
+        const isActive = activeModelName === m.name;
+        const hasNew = m.buffer.length > 0 && !isActive;
+        const color = isActive ? "green" : "white";
+        return (React.createElement(Box, { key: m.name, marginRight: 1 },
+            React.createElement(Text, { color: color, bold: isActive }, m.name),
+            hasNew && React.createElement(Text, { color: "yellow" }, " \u25CF"),
+            m.muted && React.createElement(Text, { color: "gray" }, " [muted]")));
+    })),
+    React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {
+        const usage = contextUsages[m.name] ?? 0;
+        const pct = Math.round(usage * 100);
+        const color = barColor(usage);
+        const used = m.usage.input + m.usage.output;
+        return (React.createElement(Box, { key: m.name, marginRight: 1 },
+            React.createElement(Text, { dimColor: true },
+                formatTokens(used),
+                "/",
+                formatTokens(m.contextLimit),
+                " "),
+            React.createElement(Text, { color: color },
+                renderBar(usage),
+                " ",
+                pct,
+                "%"),
+            usage > 0.9 && React.createElement(Text, { color: "red" }, " \u26A0")));
+    })),
+    React.createElement(Box, { height: 1, flexDirection: "row" },
+        React.createElement(Text, { dimColor: true }, "Tab:switch  d:compare  m:mute  r:reset  q:quit  \u2191\u2193:scroll/history  Esc:cancel"))));

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "multiarena",
+  "version": "0.1.0",
+  "description": "Terminal-native multi-model AI coding assistant — chat with multiple LLMs side by side",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "multiarena": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "keywords": [
+    "ai",
+    "llm",
+    "coding-assistant",
+    "terminal",
+    "cli",
+    "claude",
+    "gpt",
+    "gemini",
+    "ollama",
+    "multi-model"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timgunnar/arena"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.0",
+    "@google/generative-ai": "^0.21.0",
+    "@iarna/toml": "^2.2.5",
+    "ink": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "openai": "^4.50.0",
+    "react": "^18.2.0",
+    "simple-git": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.19",
+    "@types/react": "^18.2.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
+    "tsx": "^4.15.0",
+    "typescript": "^5.5.0",
+    "vitest": "^1.6.0"
+  }
+}