@devang0907/agent-dev 0.1.0

package/dist/providers/types.d.ts

@@ -0,0 +1,60 @@
+export type ProviderId = "openai" | "groq" | "gemini" | "free";
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high";
+export type Theme = "dark" | "light";
+export interface Model {
+    provider: ProviderId;
+    id: string;
+    name: string;
+}
+export type MessageRole = "user" | "assistant" | "tool" | "system";
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ChatMessage {
+    role: MessageRole;
+    content: string;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+    name?: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export interface ChatContext {
+    messages: ChatMessage[];
+    tools: ToolDefinition[];
+    systemPrompt?: string;
+    thinkingLevel?: ThinkingLevel;
+    signal?: AbortSignal;
+}
+export type StreamEvent = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "tool_call_delta";
+    index: number;
+    id?: string;
+    name?: string;
+    argumentsDelta?: string;
+} | {
+    type: "done";
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+} | {
+    type: "error";
+    message: string;
+};
+export interface StreamResult {
+    content: string;
+    toolCalls: ToolCall[];
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}

package/dist/providers/types.js

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

package/dist/session/manager.d.ts

@@ -0,0 +1,25 @@
+import type { ChatMessage, Model } from "../providers/types.js";
+export interface SessionEntry {
+    type: "message" | "model_change";
+    id: string;
+    timestamp: string;
+    data: ChatMessage | {
+        provider: string;
+        modelId: string;
+    };
+}
+export declare class SessionManager {
+    readonly sessionId: string;
+    readonly sessionPath: string;
+    private messages;
+    constructor(sessionId?: string, cwd?: string);
+    private load;
+    getMessages(): ChatMessage[];
+    appendMessage(msg: ChatMessage): void;
+    appendMessages(msgs: ChatMessage[]): void;
+    appendModelChange(model: Model): void;
+    private appendEntry;
+    clear(): void;
+    saveAsLast(): void;
+    static loadLast(): SessionManager | undefined;
+}

package/dist/session/manager.js

@@ -0,0 +1,85 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, appendFileSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { SESSIONS_DIR, LAST_SESSION_PATH } from "../config/paths.js";
+export class SessionManager {
+    sessionId;
+    sessionPath;
+    messages = [];
+    constructor(sessionId, cwd) {
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+        if (sessionId) {
+            this.sessionId = sessionId;
+            this.sessionPath = join(SESSIONS_DIR, `${sessionId}.jsonl`);
+            this.load();
+        }
+        else {
+            const hash = createHash("sha256").update(cwd ?? process.cwd()).digest("hex").slice(0, 12);
+            this.sessionId = `${hash}-${Date.now()}`;
+            this.sessionPath = join(SESSIONS_DIR, `${this.sessionId}.jsonl`);
+        }
+    }
+    load() {
+        if (!existsSync(this.sessionPath))
+            return;
+        const lines = readFileSync(this.sessionPath, "utf-8").split("\n").filter(Boolean);
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === "message") {
+                    this.messages.push(entry.data);
+                }
+            }
+            catch {
+                // skip bad lines
+            }
+        }
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    appendMessage(msg) {
+        this.messages.push(msg);
+        this.appendEntry({
+            type: "message",
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            data: msg,
+        });
+    }
+    appendMessages(msgs) {
+        for (const msg of msgs) {
+            this.appendMessage(msg);
+        }
+    }
+    appendModelChange(model) {
+        this.appendEntry({
+            type: "model_change",
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            data: { provider: model.provider, modelId: model.id },
+        });
+    }
+    appendEntry(entry) {
+        appendFileSync(this.sessionPath, JSON.stringify(entry) + "\n", "utf-8");
+    }
+    clear() {
+        this.messages = [];
+        writeFileSync(this.sessionPath, "", "utf-8");
+    }
+    saveAsLast() {
+        writeFileSync(LAST_SESSION_PATH, JSON.stringify({ sessionId: this.sessionId, path: this.sessionPath }), "utf-8");
+    }
+    static loadLast() {
+        if (!existsSync(LAST_SESSION_PATH))
+            return undefined;
+        try {
+            const { sessionId } = JSON.parse(readFileSync(LAST_SESSION_PATH, "utf-8"));
+            return new SessionManager(sessionId);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/ui/App.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { AgentSession } from "../agent/session.js";
+export interface DisplayMessage {
+    role: "user" | "assistant" | "tool";
+    content: string;
+    toolName?: string;
+}
+interface AppProps {
+    session: AgentSession;
+    workdir: string;
+    onQuit: () => void;
+}
+export declare function App({ session, workdir, onQuit }: AppProps): React.JSX.Element;
+export {};

package/dist/ui/App.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { ChatView } from "./ChatView.js";
+import { Editor } from "./Editor.js";
+import { Footer } from "./Footer.js";
+import { ModelSelector } from "./ModelSelector.js";
+import { SettingsView } from "./SettingsView.js";
+import { getTheme } from "./theme.js";
+import { saveSettings } from "../config/settings.js";
+export function App({ session, workdir, onQuit }) {
+    const { exit } = useApp();
+    const [displayMessages, setDisplayMessages] = useState(() => session.getMessages().map((m) => ({
+        role: m.role === "tool" ? "tool" : m.role === "user" ? "user" : "assistant",
+        content: m.content,
+        toolName: m.name,
+    })));
+    const [streamingText, setStreamingText] = useState("");
+    const [overlay, setOverlay] = useState("none");
+    const [modelFilter, setModelFilter] = useState();
+    const [settings, setSettings] = useState(session.getSettings());
+    const [model, setModel] = useState(session.getModel());
+    const [running, setRunning] = useState(false);
+    const streamingRef = useRef("");
+    const theme = getTheme(settings.theme);
+    useEffect(() => {
+        const handler = (event) => {
+            switch (event.type) {
+                case "user_message":
+                    setDisplayMessages((prev) => [...prev, { role: "user", content: event.content }]);
+                    setRunning(true);
+                    streamingRef.current = "";
+                    setStreamingText("");
+                    break;
+                case "message_start":
+                    streamingRef.current = "";
+                    setStreamingText("");
+                    break;
+                case "text_delta":
+                    streamingRef.current += event.delta;
+                    setStreamingText(streamingRef.current);
+                    break;
+                case "tool_call":
+                    const partial = streamingRef.current;
+                    if (partial) {
+                        setDisplayMessages((prev) => [...prev, { role: "assistant", content: partial }]);
+                        streamingRef.current = "";
+                        setStreamingText("");
+                    }
+                    break;
+                case "tool_result":
+                    setDisplayMessages((prev) => [
+                        ...prev,
+                        { role: "tool", content: event.result, toolName: event.name },
+                    ]);
+                    break;
+                case "turn_end":
+                    const final = streamingRef.current;
+                    if (final) {
+                        setDisplayMessages((prev) => [...prev, { role: "assistant", content: final }]);
+                    }
+                    streamingRef.current = "";
+                    setStreamingText("");
+                    setRunning(false);
+                    break;
+                case "error":
+                    setDisplayMessages((prev) => [
+                        ...prev,
+                        { role: "assistant", content: `Error: ${event.message}` },
+                    ]);
+                    streamingRef.current = "";
+                    setStreamingText("");
+                    setRunning(false);
+                    break;
+                case "model_changed":
+                    setModel(event.model);
+                    break;
+            }
+        };
+        session.on("event", handler);
+        return () => {
+            session.off("event", handler);
+        };
+    }, [session]);
+    useInput((_, key) => {
+        if (overlay !== "none")
+            return;
+        if (key.escape && running) {
+            session.abort();
+        }
+    });
+    const handleSubmit = useCallback(async (value) => {
+        if (value === "/quit") {
+            onQuit();
+            exit();
+            return;
+        }
+        if (value === "/new") {
+            session.newSession();
+            setDisplayMessages([]);
+            setStreamingText("");
+            return;
+        }
+        if (value === "/settings") {
+            setOverlay("settings");
+            return;
+        }
+        if (value.startsWith("/model")) {
+            const parts = value.split(/\s+/);
+            setModelFilter(parts[1] ?? undefined);
+            setOverlay("model");
+            return;
+        }
+        if (running)
+            return;
+        await session.prompt(value);
+    }, [session, running, onQuit, exit]);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: theme.header, bold: true, children: "agent-dev" }), _jsx(Text, { color: theme.muted, children: " \u2014 /model /settings /new /quit | Esc abort" })] }), _jsx(ChatView, { messages: displayMessages, theme: theme, streamingText: streamingText }), _jsx(Footer, { workdir: workdir, model: model, theme: theme, running: running }), overlay === "none" && (_jsx(Editor, { theme: theme, disabled: running, onSubmit: handleSubmit })), overlay === "model" && (_jsx(ModelSelector, { theme: theme, settings: settings, filter: modelFilter, onSelect: (m) => {
+                    session.setModel(m);
+                    setModel(m);
+                    setOverlay("none");
+                    setModelFilter(undefined);
+                }, onClose: () => {
+                    setOverlay("none");
+                    setModelFilter(undefined);
+                } })), overlay === "settings" && (_jsx(SettingsView, { theme: theme, settings: settings, onUpdate: (s) => {
+                    session.updateSettings(s);
+                    setSettings(s);
+                    saveSettings(s);
+                }, onClose: () => setOverlay("none") }))] }));
+}

package/dist/ui/ChatView.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { DisplayMessage } from "./App.js";
+import type { ThemeColors } from "./theme.js";
+interface ChatViewProps {
+    messages: DisplayMessage[];
+    theme: ThemeColors;
+    streamingText?: string;
+}
+export declare function ChatView({ messages, theme, streamingText }: ChatViewProps): React.JSX.Element;
+export {};

package/dist/ui/ChatView.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function ChatView({ messages, theme, streamingText }) {
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, marginBottom: 1, children: [messages.length === 0 && !streamingText && (_jsx(Text, { color: theme.muted, children: "Type a message or /model to select a provider. /settings for options." })), messages.map((msg, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [msg.role === "user" && (_jsxs(Text, { color: theme.user, bold: true, children: ["You: ", msg.content] })), msg.role === "assistant" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.assistant, bold: true, children: "Assistant:" }), _jsx(Text, { color: theme.assistant, children: msg.content || "" })] })), msg.role === "tool" && (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { color: theme.tool, children: ["[", msg.toolName, "] ", msg.content.slice(0, 200), msg.content.length > 200 ? "..." : ""] }) }))] }, i))), streamingText && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.assistant, bold: true, children: "Assistant:" }), _jsx(Text, { color: theme.assistant, children: streamingText })] }))] }));
+}

package/dist/ui/Editor.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { ThemeColors } from "./theme.js";
+interface EditorProps {
+    theme: ThemeColors;
+    disabled?: boolean;
+    onSubmit: (value: string) => void;
+    filterHint?: string;
+}
+export declare function Editor({ theme, disabled, onSubmit, filterHint }: EditorProps): React.JSX.Element;
+export {};

package/dist/ui/Editor.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+const SLASH_COMMANDS = ["/model", "/settings", "/new", "/quit"];
+export function Editor({ theme, disabled, onSubmit, filterHint }) {
+    const [value, setValue] = useState(filterHint ?? "");
+    const [suggestions, setSuggestions] = useState([]);
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        if (key.return) {
+            const trimmed = value.trim();
+            if (trimmed)
+                onSubmit(trimmed);
+            setValue("");
+            setSuggestions([]);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setValue((v) => v.slice(0, -1));
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            const newVal = value + input;
+            setValue(newVal);
+            if (newVal.startsWith("/")) {
+                setSuggestions(SLASH_COMMANDS.filter((c) => c.startsWith(newVal)));
+            }
+            else {
+                setSuggestions([]);
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, children: [suggestions.length > 0 && (_jsx(Text, { color: theme.muted, children: suggestions.join("  ") })), _jsxs(Text, { children: [_jsx(Text, { color: theme.accent, children: "> " }), _jsx(Text, { children: value }), _jsx(Text, { color: theme.muted, children: "\u2588" })] })] }));
+}

package/dist/ui/Footer.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { Model } from "../providers/types.js";
+import type { ThemeColors } from "./theme.js";
+interface FooterProps {
+    workdir: string;
+    model: Model;
+    theme: ThemeColors;
+    running: boolean;
+}
+export declare function Footer({ workdir, model, theme, running }: FooterProps): React.JSX.Element;
+export {};

package/dist/ui/Footer.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { modelRef } from "../config/models.js";
+export function Footer({ workdir, model, theme, running }) {
+    return (_jsx(Box, { borderStyle: "single", borderColor: theme.border, paddingX: 1, children: _jsxs(Text, { color: theme.muted, children: [workdir, " | ", modelRef(model), " ", running ? "| working..." : ""] }) }));
+}

package/dist/ui/ModelSelector.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { Model } from "../providers/types.js";
+import type { ThemeColors } from "./theme.js";
+import type { Settings } from "../config/settings.js";
+interface ModelSelectorProps {
+    theme: ThemeColors;
+    settings: Settings;
+    filter?: string;
+    onSelect: (model: Model) => void;
+    onClose: () => void;
+}
+export declare function ModelSelector({ theme, settings, filter, onSelect, onClose }: ModelSelectorProps): React.JSX.Element;
+export {};

package/dist/ui/ModelSelector.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { ALL_MODELS, modelRef, PROVIDER_LABELS } from "../config/models.js";
+import { hasProviderAuth } from "../providers/registry.js";
+function fuzzyMatch(text, query) {
+    if (!query)
+        return true;
+    const lower = text.toLowerCase();
+    const q = query.toLowerCase();
+    return lower.includes(q) || modelRef({ provider: "openai", id: text, name: text }).includes(q);
+}
+export function ModelSelector({ theme, settings, filter, onSelect, onClose }) {
+    const filtered = ALL_MODELS.filter((m) => {
+        const label = `${PROVIDER_LABELS[m.provider]} ${m.name} ${modelRef(m)}`;
+        return fuzzyMatch(label, filter ?? "");
+    });
+    const [index, setIndex] = useState(0);
+    const safeIndex = Math.min(index, Math.max(0, filtered.length - 1));
+    useInput((input, key) => {
+        if (key.escape) {
+            onClose();
+            return;
+        }
+        if (key.upArrow)
+            setIndex((i) => Math.max(0, i - 1));
+        if (key.downArrow)
+            setIndex((i) => Math.min(filtered.length - 1, i + 1));
+        if (key.return && filtered[safeIndex]) {
+            onSelect(filtered[safeIndex]);
+        }
+        if (input && !key.ctrl) {
+            // typing not used in overlay mode
+        }
+    });
+    const providers = ["openai", "groq", "gemini", "free"];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: theme.accent, padding: 1, children: [_jsx(Text, { color: theme.header, bold: true, children: "/model \u2014 select provider & model (Esc to close)" }), filter && _jsxs(Text, { color: theme.muted, children: ["Filter: ", filter] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [filtered.length === 0 && _jsx(Text, { color: theme.muted, children: "No models match" }), filtered.map((m, i) => {
+                        const hasKey = hasProviderAuth(m.provider, settings);
+                        const selected = i === safeIndex;
+                        return (_jsxs(Text, { color: selected ? theme.accent : theme.assistant, children: [selected ? "> " : "  ", "[", PROVIDER_LABELS[m.provider], "] ", m.name, !hasKey ? " (no key)" : ""] }, modelRef(m)));
+                    })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Providers: ", providers.map((p) => `${PROVIDER_LABELS[p]}${hasProviderAuth(p, settings) ? "" : " (no key)"}`).join(" | ")] }) })] }));
+}

package/dist/ui/SettingsView.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { ThemeColors } from "./theme.js";
+import type { Settings } from "../config/settings.js";
+interface SettingsViewProps {
+    theme: ThemeColors;
+    settings: Settings;
+    onUpdate: (settings: Settings) => void;
+    onClose: () => void;
+}
+export declare function SettingsView({ theme, settings, onUpdate, onClose }: SettingsViewProps): React.JSX.Element;
+export {};

package/dist/ui/SettingsView.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { PROVIDER_ENV_VARS } from "../providers/registry.js";
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const THEMES = ["dark", "light"];
+export function SettingsView({ theme, settings, onUpdate, onClose }) {
+    const [index, setIndex] = useState(0);
+    const items = ["thinkingLevel", "theme", "envKeys"];
+    useInput((_, key) => {
+        if (key.escape)
+            onClose();
+        if (key.upArrow)
+            setIndex((i) => Math.max(0, i - 1));
+        if (key.downArrow)
+            setIndex((i) => Math.min(items.length - 1, i + 1));
+        if (key.return) {
+            const item = items[index];
+            if (item === "thinkingLevel") {
+                const cur = THINKING_LEVELS.indexOf(settings.thinkingLevel);
+                const next = THINKING_LEVELS[(cur + 1) % THINKING_LEVELS.length];
+                onUpdate({ ...settings, thinkingLevel: next });
+            }
+            else if (item === "theme") {
+                const cur = THEMES.indexOf(settings.theme);
+                const next = THEMES[(cur + 1) % THEMES.length];
+                onUpdate({ ...settings, theme: next });
+            }
+        }
+    });
+    const providers = ["openai", "groq", "gemini", "free"];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: theme.accent, padding: 1, children: [_jsx(Text, { color: theme.header, bold: true, children: "/settings (Enter to cycle, Esc to close)" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: index === 0 ? theme.accent : theme.assistant, children: [index === 0 ? "> " : "  ", "Thinking level: ", settings.thinkingLevel] }), _jsxs(Text, { color: index === 1 ? theme.accent : theme.assistant, children: [index === 1 ? "> " : "  ", "Theme: ", settings.theme] }), _jsxs(Text, { color: index === 2 ? theme.accent : theme.muted, children: [index === 2 ? "> " : "  ", "API keys (env vars):"] }), providers.map((p) => {
+                        const vars = PROVIDER_ENV_VARS[p];
+                        const set = vars.some((v) => process.env[v]);
+                        return (_jsxs(Text, { color: theme.muted, children: ["    ", p, ": ", vars.join(" or "), " \u2014 ", set ? "set" : "not set"] }, p));
+                    })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Set OPENAI_API_KEY, GROQ_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY" }) })] }));
+}

package/dist/ui/theme.d.ts

@@ -0,0 +1,13 @@
+import type { Theme } from "../providers/types.js";
+export interface ThemeColors {
+    user: string;
+    assistant: string;
+    tool: string;
+    border: string;
+    muted: string;
+    accent: string;
+    error: string;
+    header: string;
+}
+export declare const themes: Record<Theme, ThemeColors>;
+export declare function getTheme(theme: Theme): ThemeColors;

package/dist/ui/theme.js

@@ -0,0 +1,25 @@
+export const themes = {
+    dark: {
+        user: "cyan",
+        assistant: "white",
+        tool: "yellow",
+        border: "gray",
+        muted: "gray",
+        accent: "green",
+        error: "red",
+        header: "blue",
+    },
+    light: {
+        user: "blue",
+        assistant: "black",
+        tool: "yellow",
+        border: "gray",
+        muted: "gray",
+        accent: "green",
+        error: "red",
+        header: "blue",
+    },
+};
+export function getTheme(theme) {
+    return themes[theme];
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@devang0907/agent-dev",
+  "version": "0.1.0",
+  "description": "Minimal pi-like terminal coding agent with Ink UI",
+  "type": "module",
+  "license": "MIT",
+  "author": "Devang Rakholiya <rakholiyadevang@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Devang0907/agent-dev.git"
+  },
+  "keywords": ["ai", "agent", "cli", "ink", "coding-agent"],
+  "files": ["dist", "README.md"],
+  "bin": {
+    "agent": "dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "publish:public": "npm publish --access public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@google/genai": "^1.0.0",
+    "chalk": "^5.4.1",
+    "ink": "^5.2.0",
+    "openai": "^4.85.0",
+    "react": "^18.3.1",
+    "typebox": "^1.0.27"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "@types/react": "^18.3.18",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  }
+}