@axeai/axe 0.0.1-beta

package/README.md

@@ -0,0 +1,53 @@
+# axe
+
+AI-powered TUI code assistant. Talk to your codebase from the terminal.
+
+![axe demo](public/image.png)
+
+## Install
+
+```bash
+bun install -g axe-cli
+```
+
+Or run directly:
+```bash
+bunx axe-cli
+```
+
+## Features
+
+- **Multi-provider** - Google, OpenAI, Anthropic, Groq, xAI, DeepSeek, Qwen, Kimi, MiniMax
+- **File system access** - Read, write, search files via MCP
+- **Shell commands** - Run terminal commands through AI
+- **Per-directory sessions** - Chat history tied to your project
+- **Lightweight** - Built with Bun + Ink
+- **Ralph Loop** - Continuous autonomy for complex tasks (experimental)
+
+## Commands
+
+| Command | Action |
+|---------|--------|
+| `/provider` | Switch AI provider |
+| `/model` | Switch model |
+| `/agent` | Switch agent type (Standard vs Ralph Loop) |
+| `/history` | View chat sessions |
+| `/clear` | Clear chat |
+
+## Config
+
+API keys stored in `~/.axe/config.json`:
+
+```json
+{
+  "provider": "google",
+  "model": "gemini-2.5-flash",
+  "keys": {
+    "google": "your-api-key"
+  }
+}
+```
+
+## License
+
+MIT

package/bin/axe.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/index.tsx";

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@axeai/axe",
+  "version": "0.0.1-beta",
+  "description": "AI-powered TUI code editor with MCP filesystem access",
+  "module": "src/index.tsx",
+  "type": "module",
+  "bin": {
+    "axe": "bin/axe.js"
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "tui",
+    "code-editor",
+    "mcp",
+    "gemini",
+    "openai",
+    "anthropic"
+  ],
+  "author": "iamanishx",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iamanishx/axe.git"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "bun-types": "^1.3.5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.1",
+    "@ai-sdk/google": "^3.0.1",
+    "@ai-sdk/groq": "^3.0.1",
+    "@ai-sdk/mcp": "^1.0.1",
+    "@ai-sdk/openai": "^3.0.1",
+    "@ai-sdk/openai-compatible": "^2.0.1",
+    "@ai-sdk/xai": "^3.0.1",
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "ai": "^6.0.3",
+    "ai-sdk-provider-gemini-cli": "^2.0.0",
+    "dotenv": "^17.2.3",
+    "ink": "^6.6.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "install": "^0.13.0",
+    "ralph-loop-agent": "^0.0.3",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "zod": "^4.2.1"
+  }
+}

package/src/app.tsx

@@ -0,0 +1,400 @@
+import React, { useState, useEffect, useCallback } from "react";
+import { Box, Text, useInput, Static } from "ink";
+import { Header } from "./ui/header";
+import { MessageComponent } from "./ui/message";
+import { InputArea } from "./ui/input-area";
+import { SessionPicker } from "./ui/session-picker";
+import {
+    getRecentMessages,
+    getCurrentDirSessions,
+    getOtherDirSessions,
+    getSessionMessages,
+    getSessionId,
+    createNewSession,
+    setSessionId,
+    type Message,
+    type Session,
+} from "./lib/db";
+import { runAgentStream } from "./lib/agent";
+import { loadConfig, setProvider, type ProviderName } from "./lib/config";
+import { PROVIDER_MODELS } from "./lib/provider";
+import { triggerRerender } from "./index";
+
+type View = "session_picker" | "chat" | "history" | "provider" | "model" | "agent";
+
+type AppProps = {
+    skipInitialLoad?: boolean;
+};
+
+export const App = ({ skipInitialLoad = false }: AppProps) => {
+    const [messages, setMessages] = useState<Message[]>([]);
+    const [streamingContent, setStreamingContent] = useState("");
+    const [thinking, setThinking] = useState<string | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const [view, setView] = useState<View>("session_picker");
+    const [currentDirSessions, setCurrentDirSessions] = useState<Session[]>([]);
+    const [otherDirSessions, setOtherDirSessions] = useState<Session[]>([]);
+    const [selectedIdx, setSelectedIdx] = useState(0);
+    const [config, setConfig] = useState(loadConfig());
+    const [agentType, setAgentType] = useState<"tool-loop" | "ralph-loop">("tool-loop");
+
+    useEffect(() => {
+        if (skipInitialLoad) {
+            setView("chat");
+            return;
+        }
+
+        const sessions = getCurrentDirSessions();
+        setCurrentDirSessions(sessions);
+
+        if (sessions.length === 0) {
+            createNewSession();
+            setView("chat");
+        } else {
+            setView("session_picker");
+        }
+    }, [skipInitialLoad]);
+
+    const providers = Object.keys(PROVIDER_MODELS) as ProviderName[];
+    const currentModels = PROVIDER_MODELS[config.provider] || [];
+
+    const handleSessionSelect = (session: Session | null) => {
+        if (session === null) {
+            createNewSession();
+            setMessages([]);
+        } else {
+            setSessionId(session.id);
+            const msgs = getSessionMessages(session.id, 100);
+            setMessages(msgs);
+        }
+        setView("chat");
+    };
+
+    const handleSessionNavigate = (direction: "up" | "down") => {
+        const totalItems = currentDirSessions.length + 1;
+        if (direction === "up") {
+            setSelectedIdx((p) => Math.max(0, p - 1));
+        } else {
+            setSelectedIdx((p) => Math.min(totalItems - 1, p + 1));
+        }
+    };
+
+    useInput((input, key) => {
+        if (view === "history") {
+            if (key.escape || input === "q") {
+                setView("chat");
+                return;
+            }
+            const allSessions = [...currentDirSessions, ...otherDirSessions];
+            if (key.upArrow) setSelectedIdx((p) => Math.max(0, p - 1));
+            if (key.downArrow) setSelectedIdx((p) => Math.min(allSessions.length - 1, p + 1));
+            if (key.return && allSessions[selectedIdx]) {
+                const session = allSessions[selectedIdx];
+                const msgs = getSessionMessages(session.id, 1000);
+                setMessages(msgs);
+                setView("chat");
+            }
+            return;
+        }
+
+        if (view === "provider") {
+            if (key.escape || input === "q") {
+                setView("chat");
+                return;
+            }
+            if (key.upArrow) setSelectedIdx((p) => Math.max(0, p - 1));
+            if (key.downArrow) setSelectedIdx((p) => Math.min(providers.length - 1, p + 1));
+            if (key.return) {
+                const newProvider = providers[selectedIdx];
+                const defaultModel = PROVIDER_MODELS[newProvider][0];
+                setProvider(newProvider, defaultModel);
+                setConfig(loadConfig());
+                setView("chat");
+            }
+            return;
+        }
+
+        if (view === "model") {
+            if (key.escape || input === "q") {
+                setView("chat");
+                return;
+            }
+            if (key.upArrow) setSelectedIdx((p) => Math.max(0, p - 1));
+            if (key.downArrow) setSelectedIdx((p) => Math.min(currentModels.length - 1, p + 1));
+            if (key.return) {
+                const newModel = currentModels[selectedIdx];
+                setProvider(config.provider, newModel);
+                setConfig(loadConfig());
+                setView("chat");
+            }
+            return;
+        }
+    }, { isActive: view !== "chat" && view !== "session_picker" });
+
+    useInput((input, key) => {
+        if (view === "agent") {
+            if (key.escape || input === "q") {
+                setView("chat");
+                return;
+            }
+            if (key.upArrow) setSelectedIdx((p) => Math.max(0, p - 1));
+            if (key.downArrow) setSelectedIdx((p) => Math.min(agentTypes.length - 1, p + 1));
+            if (key.return) {
+                const newAgentType = agentTypes[selectedIdx] as "tool-loop" | "ralph-loop";
+                setAgentType(newAgentType);
+                setMessages(prev => [...prev, {
+                    id: Date.now(),
+                    session_id: getSessionId(),
+                    role: "assistant",
+                    content: `Switched agent to ${newAgentType === "tool-loop" ? "Tool Loop" : "Ralph Loop"}`,
+                    created_at: new Date().toISOString(),
+                }]);
+                setView("chat");
+            }
+            return;
+        }
+    }, { isActive: view === "agent" });
+
+    const agentTypes = ["tool-loop", "ralph-loop"];
+
+    const handleInput = useCallback(async (input: string) => {
+        const cmd = input.toLowerCase().trim();
+
+        if (cmd === "/history") {
+            setCurrentDirSessions(getCurrentDirSessions());
+            setOtherDirSessions(getOtherDirSessions());
+            setSelectedIdx(0);
+            setView("history");
+            return;
+        }
+
+        if (cmd === "/provider") {
+            setSelectedIdx(providers.indexOf(config.provider));
+            setView("provider");
+            return;
+        }
+
+        if (cmd === "/model") {
+            setSelectedIdx(currentModels.indexOf(config.model));
+            setView("model");
+            return;
+        }
+
+        if (cmd === "/agent") {
+            setSelectedIdx(agentTypes.indexOf(agentType));
+            setView("agent");
+            return;
+        }
+
+        if (cmd === "/clear" || cmd === "/new") {
+            if (cmd === "/new") {
+                createNewSession();
+            }
+            triggerRerender();
+            return;
+        }
+
+        setIsLoading(true);
+        setError(null);
+
+        const currentSessionId = getSessionId();
+
+        const userMsg: Message = {
+            id: Date.now(),
+            session_id: currentSessionId,
+            role: "user",
+            content: input,
+            created_at: new Date().toISOString(),
+        };
+
+        setMessages((prev) => {
+            const newHistory = [...prev, userMsg];
+
+            (async () => {
+                try {
+                    const agentHistory = newHistory.slice(-50).map((m) => ({
+                        role: m.role as "user" | "assistant",
+                        content: m.content,
+                    }));
+
+                    const fileRefs = input.match(/@([a-zA-Z0-9_./-]+)/g);
+                    let finalInput = input;
+
+                    if (fileRefs && fileRefs.length > 0) {
+                        const files = fileRefs.map(ref => ref.substring(1)).join(", ");
+                        finalInput = `${input}\n\n[System Note: The user referenced the following files: ${files}. Please read them if necessary to answer the query.]`;
+                    }
+
+                    const stream = runAgentStream(finalInput, agentHistory, agentType);
+
+                    let accumulatedContent = "";
+
+                    for await (const event of stream) {
+                        if (event.type === "text") {
+                            accumulatedContent += event.content;
+                            setStreamingContent(accumulatedContent);
+                        } else if (event.type === "thinking") {
+                            setThinking(event.content);
+                        }
+                    }
+
+                    const aiMsg: Message = {
+                        id: Date.now() + 1,
+                        session_id: currentSessionId,
+                        role: "assistant",
+                        content: accumulatedContent,
+                        created_at: new Date().toISOString(),
+                    };
+
+                    setMessages((p) => [...p, aiMsg]);
+                } catch (e: any) {
+                    setError(e.message);
+                } finally {
+                    setIsLoading(false);
+                    setStreamingContent("");
+                    setThinking(null);
+                }
+            })();
+
+            return newHistory;
+        });
+    }, [providers, config.provider, currentModels, config.model, agentType]);
+
+    if (view === "session_picker") {
+        return (
+            <SessionPicker
+                currentDirSessions={currentDirSessions}
+                selectedIndex={selectedIdx}
+                onSelect={handleSessionSelect}
+                onNavigate={handleSessionNavigate}
+            />
+        );
+    }
+
+    if (view === "provider") {
+        return (
+            <Box flexDirection="column" paddingX={2} paddingY={1}>
+                <Text color="cyan" bold>⚙️  Select Provider</Text>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Box flexDirection="column" marginY={1}>
+                    {providers.map((p, i) => (
+                        <Text key={p} color={i === selectedIdx ? "green" : "white"} bold={i === selectedIdx}>
+                            {i === selectedIdx ? "▸ " : "  "}{p} {p === config.provider ? <Text dimColor>(current)</Text> : ""}
+                        </Text>
+                    ))}
+                </Box>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Text dimColor><Text color="gray">↑↓</Text> Navigate  <Text color="gray">Enter</Text> Select  <Text color="gray">q</Text> Back</Text>
+            </Box>
+        );
+    }
+
+    if (view === "model") {
+        return (
+            <Box flexDirection="column" paddingX={2} paddingY={1}>
+                <Text color="cyan" bold>🤖 Select Model <Text dimColor>({config.provider})</Text></Text>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Box flexDirection="column" marginY={1}>
+                    {currentModels.map((m, i) => (
+                        <Text key={m} color={i === selectedIdx ? "green" : "white"} bold={i === selectedIdx}>
+                            {i === selectedIdx ? "▸ " : "  "}{m} {m === config.model ? <Text dimColor>(current)</Text> : ""}
+                        </Text>
+                    ))}
+                </Box>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Text dimColor><Text color="gray">↑↓</Text> Navigate  <Text color="gray">Enter</Text> Select  <Text color="gray">q</Text> Back</Text>
+            </Box>
+        );
+    }
+
+    if (view === "agent") {
+        return (
+            <Box flexDirection="column" paddingX={2} paddingY={1}>
+                <Text color="cyan" bold>🕵️ Select Agent</Text>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Box flexDirection="column" marginY={1}>
+                    {agentTypes.map((t, i) => (
+                        <Text key={t} color={i === selectedIdx ? "green" : "white"} bold={i === selectedIdx}>
+                            {i === selectedIdx ? "▸ " : "  "}{t === "tool-loop" ? "Tool Loop (Standard)" : "Ralph Loop (Continuous)"} {t === agentType ? <Text dimColor>(current)</Text> : ""}
+                        </Text>
+                    ))}
+                </Box>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Text dimColor><Text color="gray">↑↓</Text> Navigate  <Text color="gray">Enter</Text> Select  <Text color="gray">q</Text> Back</Text>
+            </Box>
+        );
+    }
+
+    if (view === "history") {
+        const allSessions = [...currentDirSessions, ...otherDirSessions];
+        return (
+            <Box flexDirection="column" paddingX={2} paddingY={1}>
+                <Text color="cyan" bold>📚 Session History</Text>
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+
+                <Box flexDirection="column" marginY={1}>
+                    <Text bold color="yellow">📂 Current Directory</Text>
+                    {currentDirSessions.length === 0 ? (
+                        <Text dimColor>  No sessions</Text>
+                    ) : (
+                        currentDirSessions.map((s, i) => (
+                            <Text key={s.id} color={i === selectedIdx ? "green" : "white"} bold={i === selectedIdx}>
+                                {i === selectedIdx ? "▸ " : "  "}💬 {s.name || "Session"} <Text dimColor>({s.message_count} msgs)</Text>
+                            </Text>
+                        ))
+                    )}
+                </Box>
+
+                {otherDirSessions.length > 0 && (
+                    <Box flexDirection="column" marginY={1}>
+                        <Text bold color="blue">📁 Other Directories</Text>
+                        {otherDirSessions.map((s, i) => {
+                            const idx = currentDirSessions.length + i;
+                            return (
+                                <Text key={s.id} color={idx === selectedIdx ? "green" : "white"} bold={idx === selectedIdx}>
+                                    {idx === selectedIdx ? "▸ " : "  "}📍 {s.path} <Text dimColor>({s.message_count} msgs)</Text>
+                                </Text>
+                            );
+                        })}
+                    </Box>
+                )}
+
+                <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+                <Text dimColor><Text color="gray">↑↓</Text> Navigate  <Text color="gray">Enter</Text> Load  <Text color="gray">q</Text> Back</Text>
+            </Box>
+        );
+    }
+
+    return (
+        <Box flexDirection="column">
+            <Header provider={config.provider} model={config.model} />
+
+            <Static items={messages}>
+                {(msg) => (
+                    <Box key={msg.id} paddingX={1}>
+                        <MessageComponent
+                            role={msg.role}
+                            content={msg.content}
+                        />
+                    </Box>
+                )}
+            </Static>
+
+            {isLoading && (
+                <Box paddingX={1}>
+                    <MessageComponent
+                        role="assistant"
+                        content={streamingContent}
+                        thinking={thinking || undefined}
+                    />
+                </Box>
+            )}
+
+            <Box flexDirection="column" paddingX={1}>
+                {error && <Text color="red">❌ Error: {error}</Text>}
+                <InputArea onSubmit={handleInput} isLoading={isLoading} />
+            </Box>
+        </Box>
+    );
+};

package/src/index.tsx

@@ -0,0 +1,27 @@
+import React from "react";
+import { render } from "ink";
+import { App } from "./app";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+let skipInitialMessages = false;
+
+export const triggerRerender = () => {
+    skipInitialMessages = true;
+    console.clear(); 
+    rerenderFn?.(<App skipInitialLoad={true} />);
+};
+
+export const shouldSkipInitialMessages = () => {
+    const skip = skipInitialMessages;
+    skipInitialMessages = false;
+    return skip;
+};
+
+let rerenderFn: ((node: React.ReactNode) => void) | null = null;
+
+const { rerender, waitUntilExit } = render(<App skipInitialLoad={false} />);
+rerenderFn = rerender;
+
+waitUntilExit();

package/src/lib/agent.ts

@@ -0,0 +1,108 @@
+import { ToolLoopAgent, stepCountIs } from "ai";
+import { saveMessage } from "./db.js";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { shellTool } from "../tools/shell.js";
+import { getModel } from "./provider.js";
+import { loadConfig } from "./config.js";
+import { systemprompt } from "./prompt.js";
+import { RalphLoopAgent, iterationCountIs } from 'ralph-loop-agent';
+
+export type AgentMessage = {
+    role: "user" | "assistant";
+    content: string;
+};
+
+export type StreamEvent =
+    | { type: "text"; content: string }
+    | { type: "thinking"; content: string };
+
+export async function* runAgentStream(prompt: string, history: AgentMessage[], agentType: "tool-loop" | "ralph-loop" = "tool-loop"): AsyncGenerator<StreamEvent> {
+    let fsClient: any = null;
+    let searchClient: any = null;
+
+    try {
+        const config = loadConfig();
+        const model = getModel(config.provider, config.model);
+
+        fsClient = await createMCPClient({
+            transport: new StdioClientTransport({
+                command: "npx",
+                args: ["-y", "@modelcontextprotocol/server-filesystem", process.cwd()],
+            }),
+        });
+
+        searchClient = await createMCPClient({
+            transport: new StdioClientTransport({
+                command: "uvx",
+                args: ["duckduckgo-mcp-server"],
+            }),
+        });
+
+        const fsTools = await fsClient.tools();
+        const searchTools = await searchClient.tools();
+
+        const tools = {
+            ...fsTools,
+            ...searchTools,
+            shell: shellTool,
+        };
+
+        const messages: Array<{ role: "user" | "assistant"; content: string }> = [
+            ...history.map((h) => ({ role: h.role, content: h.content })),
+            { role: "user" as const, content: prompt },
+        ];
+
+        let result;
+
+        if (agentType === "ralph-loop") {
+            const myAgent = new RalphLoopAgent({
+                model: model,
+                instructions: systemprompt,
+                tools: tools,
+                stopWhen: iterationCountIs(10),
+                verifyCompletion: async () => ({ complete: true }),
+            });
+            result = await myAgent.stream({ messages } as any);
+        } else {
+            const myAgent = new ToolLoopAgent({
+                model: model,
+                instructions: systemprompt,
+                tools: tools,
+                stopWhen: stepCountIs(100),
+            });
+            result = await myAgent.stream({ messages });
+        }
+
+        saveMessage("user", prompt);
+        let fullText = "";
+
+        for await (const part of result.fullStream) {
+            if (part.type === "text-delta") {
+                const content = part.text;
+                fullText += content;
+                yield { type: "text", content };
+            } else if (part.type === "tool-call") {
+                yield { type: "thinking", content: `Using tool: ${part.toolName}` };
+            }
+        }
+
+        saveMessage("assistant", fullText);
+    } catch (error: any) {
+        if (error.name === 'AbortError' || 
+            error.message?.includes('CancelledError') ||
+            error.message?.includes('KeyboardInterrupt') ||
+            error.code === 'ABORT_ERR') {
+            return;
+        }
+        
+        yield { type: "text", content: `Error: ${error.message}` };
+    } finally {
+        try {
+            if (fsClient) await fsClient.close?.();
+        } catch {}
+        try {
+            if (searchClient) await searchClient.close?.();
+        } catch {}
+    }
+}