@axeai/axe 0.0.1-beta

package/src/lib/config.ts

@@ -0,0 +1,76 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const CONFIG_DIR = join(homedir(), ".axe");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export type ProviderName =
+    | "google"
+    | "openai"
+    | "anthropic"
+    | "groq"
+    | "xai"
+    | "deepseek"
+    | "qwen"
+    | "kimi"
+    | "gemini"
+    | "minimax";
+
+export type Config = {
+    provider: ProviderName;
+    model: string;
+    keys: Partial<Record<ProviderName, string>>;
+};
+
+const DEFAULT_CONFIG: Config = {
+    provider: "google",
+    model: "gemini-2.5-flash",
+    keys: {},
+};
+
+export function ensureConfigDir(): void {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+
+export function configExists(): boolean {
+    return existsSync(CONFIG_FILE);
+}
+
+export function loadConfig(): Config {
+    ensureConfigDir();
+    if (!configExists()) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    } catch {
+        return DEFAULT_CONFIG;
+    }
+}
+
+export function saveConfig(config: Config): void {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getApiKey(provider: ProviderName): string | undefined {
+    const config = loadConfig();
+    return config.keys[provider];
+}
+
+export function setApiKey(provider: ProviderName, key: string): void {
+    const config = loadConfig();
+    config.keys[provider] = key;
+    saveConfig(config);
+}
+
+export function setProvider(provider: ProviderName, model: string): void {
+    const config = loadConfig();
+    config.provider = provider;
+    config.model = model;
+    saveConfig(config);
+}

package/src/lib/db.ts

@@ -0,0 +1,135 @@
+import { Database } from "bun:sqlite";
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+
+const AXE_DIR = join(homedir(), ".axe");
+if (!existsSync(AXE_DIR)) {
+    mkdirSync(AXE_DIR, { recursive: true });
+}
+
+const DB_PATH = join(AXE_DIR, "chat.db");
+const db = new Database(DB_PATH);
+
+const currentDir = process.cwd();
+
+let currentSessionId = createHash("sha256").update(currentDir).digest("hex").slice(0, 16);
+
+export function getSessionId(): string {
+    return currentSessionId;
+}
+
+export function setSessionId(id: string) {
+    currentSessionId = id;
+}
+
+db.run(`
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    path TEXT NOT NULL,
+    name TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    last_message_at DATETIME
+  )
+`);
+
+db.run(`
+  CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+  )
+`);
+
+db.run(`CREATE INDEX IF NOT EXISTS idx_session ON messages(session_id)`);
+
+function ensureSession(sessionId: string, path: string) {
+    const existing = db.query("SELECT id FROM sessions WHERE id = ?").get(sessionId);
+    if (!existing) {
+        db.run("INSERT INTO sessions (id, path) VALUES (?, ?)", [sessionId, path]);
+    }
+}
+
+export type Message = {
+    id: number;
+    session_id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    created_at: string;
+};
+
+export type Session = {
+    id: string;
+    path: string;
+    name: string | null;
+    message_count: number;
+    last_message_at: string;
+};
+
+export function saveMessage(role: "user" | "assistant" | "system", content: string) {
+    ensureSession(currentSessionId, currentDir);
+    db.run("INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)", [
+        currentSessionId,
+        role,
+        content,
+    ]);
+    db.run("UPDATE sessions SET last_message_at = CURRENT_TIMESTAMP WHERE id = ?", [currentSessionId]);
+}
+
+export function getRecentMessages(limit: number = 50): Message[] {
+    const query = db.query(
+        "SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT ?"
+    );
+    const messages = query.all(currentSessionId, limit) as Message[];
+    return messages.reverse();
+}
+
+export function getCurrentDirSessions(): Session[] {
+    const query = db.query(`
+    SELECT s.id, s.path, s.name, s.last_message_at,
+           (SELECT COUNT(*) FROM messages WHERE session_id = s.id) as message_count
+    FROM sessions s
+    WHERE s.path = ?
+    ORDER BY s.last_message_at DESC
+  `);
+    return query.all(currentDir) as Session[];
+}
+
+export function getOtherDirSessions(): Session[] {
+    const query = db.query(`
+    SELECT s.id, s.path, s.name, s.last_message_at,
+           (SELECT COUNT(*) FROM messages WHERE session_id = s.id) as message_count
+    FROM sessions s
+    WHERE s.path != ?
+    ORDER BY s.last_message_at DESC
+  `);
+    return query.all(currentDir) as Session[];
+}
+
+export function getSessionMessages(sessionId: string, limit: number = 50): Message[] {
+    const query = db.query(
+        "SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT ?"
+    );
+    const messages = query.all(sessionId, limit) as Message[];
+    return messages.reverse();
+}
+
+export function createNewSession(): string {
+    const newId = createHash("sha256")
+        .update(currentDir + Date.now().toString())
+        .digest("hex")
+        .slice(0, 16);
+    
+    // Count existing sessions in this directory to generate a name
+    const countQuery = db.query("SELECT COUNT(*) as count FROM sessions WHERE path = ?");
+    const result = countQuery.get(currentDir) as { count: number };
+    const sessionName = `Session ${result.count + 1}`;
+
+    db.run("INSERT INTO sessions (id, path, name) VALUES (?, ?, ?)", [newId, currentDir, sessionName]);
+    currentSessionId = newId;
+    return newId;
+}

package/src/lib/filesystem.ts

@@ -0,0 +1,83 @@
+import { readdirSync, statSync, readFileSync, existsSync } from "fs";
+import { join, relative } from "path";
+
+const DEFAULT_IGNORE = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".cache",
+    ".vscode",
+    ".idea",
+    ".DS_Store",
+    "bun.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml"
+];
+
+function parseGitIgnore(dir: string): string[] {
+    const gitignorePath = join(dir, ".gitignore");
+    if (!existsSync(gitignorePath)) return [];
+
+    try {
+        const content = readFileSync(gitignorePath, "utf-8");
+        return content
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#"));
+    } catch {
+        return [];
+    }
+}
+
+function isIgnored(path: string, ignorePatterns: string[]): boolean {
+    const fileName = path.split("/").pop() || "";
+    
+    if (DEFAULT_IGNORE.some(pattern => path.includes(pattern))) return true;
+
+    for (const pattern of ignorePatterns) {
+        if (pattern.endsWith("/")) {
+            const dirPattern = pattern.slice(0, -1);
+            if (path.includes(dirPattern)) return true;
+        } else if (pattern.startsWith("*")) {
+            const ext = pattern.slice(1);
+            if (fileName.endsWith(ext)) return true;
+        } else {
+            if (path.includes(pattern)) return true;
+        }
+    }
+    return false;
+}
+
+export function getAllFiles(dir: string = process.cwd()): string[] {
+    const files: string[] = [];
+    const ignorePatterns = parseGitIgnore(dir);
+
+    function walk(currentDir: string) {
+        try {
+            const entries = readdirSync(currentDir);
+
+            for (const entry of entries) {
+                const fullPath = join(currentDir, entry);
+                const relPath = relative(dir, fullPath);
+
+                if (isIgnored(relPath, ignorePatterns)) continue;
+
+                const stat = statSync(fullPath);
+
+                if (stat.isDirectory()) {
+                    walk(fullPath);
+                } else {
+                    files.push(relPath);
+                }
+            }
+        } catch (e) {
+        }
+    }
+
+    walk(dir);
+    return files;
+}

package/src/lib/prompt.ts

@@ -0,0 +1,38 @@
+export const systemprompt = `You are Axe, an advanced AI-powered code editor assistant running directly in the terminal (TUI).
+Your goal is to help the user with coding tasks, debugging, file management, and system operations.
+
+You have access to the following powerful tools:
+- **File System**: Read, write, list, and search files via MCP. Use these to explore the project structure and understand the codebase.
+- **Shell**: Execute terminal commands. Use this to run builds, tests, or system utilities.
+- **Web Search**: Search the web (DuckDuckGo) for documentation, error solutions, or latest library usage.
+- **Fetch Content**: Retrieve content from URLs to get detailed documentation or examples.
+
+ALWAYS create a .agent folder id not there and log all your actions and decisions making md files inside it. before taking any action read the 
+past operations from the log files to understand what has been done already. try to have main central_log.md file which links to other log files so instead of searching
+through multiple files you can just read the central log file to get context. and after every operation update the central log file with new operation details.
+but if the user's query is trivial, you can skip logging for that operation logging mus be related to project operations only not for trivial things like creating hello world file.
+
+**CRITICAL OPERATIONAL RULES:**
+
+1.  **Ask Before Implementing**: NEVER start writing code or creating files without first explaining your plan and getting explicit user confirmation.
+    -   *Exception*: If the user's request is trivial (e.g., "create a hello world file") or explicitly instructs you to proceed immediately.
+    -   *Standard Flow*: Analyze -> Propose Plan -> Wait for "Yes" -> Execute.
+
+2.  **Explore First**: When asked to work on a project, first list files or read relevant files to understand the context. Do not guess file paths or contents.
+
+3.  **Be Concise**: You are in a terminal environment. Keep responses short, clear, and to the point. Avoid excessive Markdown headers or verbosity.
+
+4.  **Safety First**: Be extremely careful with destructive operations (deleting files, overwriting files, running unknown scripts). Always warn the user about potential side effects.
+
+5.  **Tool Usage**:
+    - File system (read, write, list, search files via MCP)
+    - Shell commands (run terminal commands)
+    - Web search (search DuckDuckGo for docs, references, solutions)
+    - Fetch content (grab webpage content for context)
+6.  **Error Handling**: If a tool fails (e.g., file not found, command error), report the error clearly and suggest next steps instead of guessing.
+
+7.  **Clarify Ambiguities**:
+    - If the user's request is ambiguous or lacks detail, ask clarifying questions before proceeding.
+
+Your ultimate goal is to assist the user effectively while ensuring safety, clarity, and precision in all operations.
+If you are unsure about a request, ask clarifying questions. Your primary objective is to be a reliable, safe, and intelligent coding partner.`;

package/src/lib/provider.ts

@@ -0,0 +1,71 @@
+import { google } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { groq } from "@ai-sdk/groq";
+import { anthropic } from "@ai-sdk/anthropic";
+import { xai } from "@ai-sdk/xai";
+import { loadConfig, getApiKey, type ProviderName } from "./config.js";
+import { createGeminiProvider } from 'ai-sdk-provider-gemini-cli';
+
+const OPENAI_COMPATIBLE_URLS: Record<string, string> = {
+    deepseek: "https://api.deepseek.com",
+    qwen: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    kimi: "https://api.moonshot.cn/v1",
+    minimax: "https://api.minimax.chat/v1",
+    openai: "https://api.openai.com/v1",
+};
+
+const gemini = createGeminiProvider({
+  authType: 'oauth-personal',
+});
+
+export function getModel(providerName?: ProviderName, modelName?: string) {
+    const config = loadConfig();
+    const provider = providerName || config.provider;
+    const model = modelName || config.model;
+    const apiKey = getApiKey(provider);
+
+    switch (provider) {
+        case "google":
+            return google(model);
+
+        case "anthropic":
+            return anthropic(model);
+
+        case "groq":
+            return groq(model);
+
+        case "xai":
+            return xai(model);
+
+        case "gemini":
+            return gemini(model);
+            
+        case "openai":
+        case "deepseek":
+        case "qwen":
+        case "kimi":
+        case "minimax": {
+            const openaiClient = createOpenAI({
+                baseURL: OPENAI_COMPATIBLE_URLS[provider],
+                apiKey: apiKey,
+            });
+            return openaiClient(model);
+        }
+
+        default:
+            throw new Error(`Unknown provider: ${provider}`);
+    }
+}
+
+export const PROVIDER_MODELS: Record<ProviderName, string[]> = {
+    google: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash"],
+    openai: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini"],
+    anthropic: ["claude-sonnet-4-20250514", "claude-3-5-haiku-latest", "claude-3-opus-latest"],
+    groq: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768"],
+    xai: ["grok-2", "grok-2-vision", "grok-beta"],
+    deepseek: ["deepseek-chat", "deepseek-reasoner"],
+    qwen: ["qwen-turbo", "qwen-plus", "qwen-max"],
+    kimi: ["moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"],
+    minimax: ["abab6.5-chat", "abab5.5-chat"],
+    gemini: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-pro-preview","gemini-3-flash-preview"],
+};

package/src/tools/shell.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { tool } from "ai";
+
+export const shellTool = tool({
+    description: "Execute a shell command in the terminal",
+    inputSchema: z.object({
+        command: z.string().describe("The shell command to execute"),
+        cwd: z.string().optional().describe("Working directory for the command"),
+    }),
+    execute: async ({ command, cwd }) => {
+        try {
+            const proc = Bun.spawn(["sh", "-c", command], {
+                cwd: cwd || process.cwd(),
+                stdout: "pipe",
+                stderr: "pipe",
+            });
+
+            const stdout = await new Response(proc.stdout).text();
+            const stderr = await new Response(proc.stderr).text();
+            const exitCode = await proc.exited;
+
+            if (exitCode !== 0) {
+                return `Command failed (exit code ${exitCode}):\n${stderr || stdout}`;
+            }
+
+            return stdout || "(no output)";
+        } catch (error: any) {
+            return `Error: ${error.message}`;
+        }
+    },
+});

package/src/ui/autocomplete.tsx

@@ -0,0 +1,22 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+type AutocompleteProps = {
+    items: string[];
+    selectedIndex: number;
+};
+
+export const Autocomplete: React.FC<AutocompleteProps> = ({ items, selectedIndex }) => {
+    if (items.length === 0) return null;
+
+    return (
+        <Box flexDirection="column" borderStyle="round" borderColor="blue" paddingX={1}>
+            {items.map((item, index) => (
+                <Text key={item} color={index === selectedIndex ? "green" : "gray"}>
+                    {index === selectedIndex ? "> " : "  "}
+                    {item}
+                </Text>
+            ))}
+        </Box>
+    );
+};

package/src/ui/header.tsx

@@ -0,0 +1,25 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+type HeaderProps = {
+    provider: string;
+    model: string;
+};
+
+export const Header: React.FC<HeaderProps> = ({ provider, model }) => {
+    const cwd = process.cwd();
+    const dirName = cwd.split("/").pop() || cwd;
+
+    return (
+        <Box flexDirection="column" paddingX={1} marginBottom={1}>
+            <Box>
+                <Text color="cyan" bold>AXE</Text>
+                <Text dimColor> • </Text>
+                <Text color="yellow">{dirName}</Text>
+                <Text dimColor> • </Text>
+                <Text color="magenta">{provider}/{model}</Text>
+            </Box>
+            <Text dimColor>━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━</Text>
+        </Box>
+    );
+};

package/src/ui/input-area.tsx

@@ -0,0 +1,121 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { Autocomplete } from "./autocomplete";
+import { getAllFiles } from "../lib/filesystem";
+
+type InputAreaProps = {
+    onSubmit: (value: string) => void;
+    isLoading: boolean;
+};
+
+export const InputArea: React.FC<InputAreaProps> = React.memo(({ onSubmit, isLoading }) => {
+    const [query, setQuery] = useState("");
+    const [showSuggestions, setShowSuggestions] = useState(false);
+    const [filteredFiles, setFilteredFiles] = useState<string[]>([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [allFiles, setAllFiles] = useState<string[]>([]);
+
+    useEffect(() => {
+        setAllFiles(getAllFiles());
+    }, []);
+
+    const handleChange = (value: string) => {
+        setQuery(value);
+
+        const lastWord = value.split(/\s+/).pop() || "";
+        if (lastWord.startsWith("@")) {
+            const searchTerm = lastWord.slice(1).toLowerCase();
+            const matches = allFiles
+                .filter((f) => f.toLowerCase().includes(searchTerm))
+                .slice(0, 5);
+
+            setFilteredFiles(matches);
+            setShowSuggestions(matches.length > 0);
+            setSelectedIndex(0);
+        } else {
+            setShowSuggestions(false);
+        }
+    };
+
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+        }
+
+        if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(filteredFiles.length - 1, prev + 1));
+        }
+
+        if (key.return || key.tab) {
+            if (filteredFiles[selectedIndex]) {
+                const parts = query.split(/\s+/);
+                parts.pop();
+                const newQuery = [...parts, `@${filteredFiles[selectedIndex]} `].join(" ");
+                setQuery(newQuery);
+                setShowSuggestions(false);
+            }
+        }
+
+        if (key.escape) {
+            setShowSuggestions(false);
+        }
+    }, { isActive: showSuggestions });
+
+    const handleSubmit = (value: string) => {
+        if (showSuggestions) {
+            return;
+        }
+
+        if (isLoading || !value.trim()) return;
+        onSubmit(value);
+        setQuery("");
+    };
+
+    return (
+        <Box flexDirection="column">
+            {showSuggestions && (
+                <Autocomplete items={filteredFiles} selectedIndex={selectedIndex} />
+            )}
+
+            {/* Input Box */}
+            <Box
+                borderStyle="round"
+                borderColor={isLoading ? "yellow" : "green"}
+                paddingX={1}
+            >
+                {isLoading ? (
+                    <Box>
+                        <Text color="yellow">
+                            <Spinner type="dots" />
+                        </Text>
+                        <Text color="yellow"> Thinking...</Text>
+                    </Box>
+                ) : (
+                    <Box>
+                        <Text color="green" bold>❯ </Text>
+                        <TextInput
+                            value={query}
+                            onChange={handleChange}
+                            onSubmit={handleSubmit}
+                            placeholder="Ask anything... (@ to reference files)"
+                        />
+                    </Box>
+                )}
+            </Box>
+
+            {/* Commands hint */}
+            <Box paddingX={1} marginTop={1}>
+                <Text dimColor>
+                    <Text color="gray">/new</Text> <Text dimColor>•</Text>{" "}
+                    <Text color="gray">/clear</Text> <Text dimColor>•</Text>{" "}
+                    <Text color="gray">/history</Text> <Text dimColor>•</Text>{" "}
+                    <Text color="gray">/provider</Text> <Text dimColor>•</Text>{" "}
+                    <Text color="gray">/model</Text> <Text dimColor>•</Text>{" "}
+                    <Text color="gray">/agent</Text>
+                </Text>
+            </Box>
+        </Box>
+    );
+});

package/src/ui/layout.tsx

@@ -0,0 +1,28 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+type LayoutProps = {
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    children: React.ReactNode;
+};
+
+export const Layout: React.FC<LayoutProps> = ({ header, footer, children }) => {
+    return (
+        <Box flexDirection="column">
+            {header && (
+                <Box borderStyle="single" borderColor="blue" paddingX={1}>
+                    {header}
+                </Box>
+            )}
+
+            <Box flexDirection="column" paddingX={1}>
+                {children}
+            </Box>
+
+            <Box flexDirection="column" paddingX={1}>
+                {footer}
+            </Box>
+        </Box>
+    );
+};

package/src/ui/message.tsx

@@ -0,0 +1,38 @@
+import React from "react";
+import { Text, Box } from "ink";
+
+type MessageProps = {
+    role: "user" | "assistant" | "system";
+    content: string;
+    thinking?: string;
+};
+
+export const MessageComponent: React.FC<MessageProps> = React.memo(({ role, content, thinking }) => {
+    const isUser = role === "user";
+
+    return (
+        <Box flexDirection="column" marginBottom={1}>
+            {/* Message Header */}
+            <Box>
+                <Text color={isUser ? "green" : "cyan"} bold>
+                    {isUser ? "> You" : "| AXE"}
+                </Text>
+            </Box>
+
+            {/* Message Content */}
+            <Box paddingLeft={3} flexDirection="column">
+                {/* Thinking indicator */}
+                {thinking && (
+                    <Box marginBottom={1}>
+                        <Text color="yellow" dimColor>
+                            💭 {thinking}
+                        </Text>
+                    </Box>
+                )}
+
+                {/* Main content */}
+                <Text wrap="wrap">{content}</Text>
+            </Box>
+        </Box>
+    );
+});