macha-ai 0.1.0

package/bin/macha.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/App.js

@@ -0,0 +1,134 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { Header } from "./components/Header.js";
+import { MessageList } from "./components/MessageList.js";
+import { Input } from "./components/Input.js";
+import { FileTree } from "./components/FileTree.js";
+import { Settings } from "./components/Settings.js";
+import { streamChat, generateId, } from "./ai/client.js";
+import { getConfig } from "./config/index.js";
+export function App({ workingDir, initialPrompt }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [screen, setScreen] = useState("chat");
+    const [messages, setMessages] = useState([]);
+    const [streamingText, setStreamingText] = useState("");
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [config, setConfig] = useState(getConfig());
+    const abortRef = useRef(false);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            if (isStreaming) {
+                abortRef.current = true;
+            }
+            else {
+                exit();
+            }
+        }
+        if (key.tab) {
+            setScreen((s) => (s === "chat" ? "settings" : "chat"));
+        }
+    });
+    const handleSend = useCallback(async (text) => {
+        if (isStreaming)
+            return;
+        const userMessage = {
+            id: generateId(),
+            role: "user",
+            content: text,
+            timestamp: new Date(),
+        };
+        setMessages((prev) => [...prev, userMessage]);
+        setIsStreaming(true);
+        setStreamingText("");
+        abortRef.current = false;
+        const assistantId = generateId();
+        let fullText = "";
+        const toolCalls = [];
+        const pendingToolCalls = new Map();
+        try {
+            const allMessages = [...messages, userMessage];
+            const stream = streamChat(allMessages, workingDir);
+            for await (const event of stream) {
+                if (abortRef.current)
+                    break;
+                if (event.type === "text_delta") {
+                    fullText += event.delta || "";
+                    setStreamingText(fullText);
+                }
+                else if (event.type === "tool_call" && event.toolCall) {
+                    const tc = event.toolCall;
+                    if (!tc.result) {
+                        pendingToolCalls.set(tc.id, { ...tc });
+                        setStreamingText(fullText);
+                    }
+                    else {
+                        const updated = { ...tc };
+                        pendingToolCalls.delete(tc.id);
+                        const idx = toolCalls.findIndex((t) => t.id === tc.id);
+                        if (idx >= 0) {
+                            toolCalls[idx] = updated;
+                        }
+                        else {
+                            toolCalls.push(updated);
+                        }
+                        setMessages((prev) => {
+                            const existing = prev.find((m) => m.id === assistantId);
+                            if (existing) {
+                                return prev.map((m) => m.id === assistantId
+                                    ? { ...m, content: fullText, toolCalls: [...toolCalls] }
+                                    : m);
+                            }
+                            else {
+                                const assistantMsg = {
+                                    id: assistantId,
+                                    role: "assistant",
+                                    content: fullText,
+                                    toolCalls: [...toolCalls],
+                                    timestamp: new Date(),
+                                };
+                                return [...prev, assistantMsg];
+                            }
+                        });
+                    }
+                }
+                else if (event.type === "done" || event.type === "error") {
+                    if (event.type === "error") {
+                        fullText += `\n\nError: ${event.error}`;
+                    }
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            const e = err;
+            fullText += `\n\nError: ${e.message || String(err)}`;
+        }
+        setMessages((prev) => {
+            const existing = prev.find((m) => m.id === assistantId);
+            const finalMsg = {
+                id: assistantId,
+                role: "assistant",
+                content: fullText || "(no response)",
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                timestamp: new Date(),
+            };
+            if (existing) {
+                return prev.map((m) => (m.id === assistantId ? finalMsg : m));
+            }
+            return [...prev, finalMsg];
+        });
+        setStreamingText("");
+        setIsStreaming(false);
+    }, [messages, workingDir, isStreaming]);
+    const sentInitial = useRef(false);
+    if (initialPrompt && !sentInitial.current) {
+        sentInitial.current = true;
+        setTimeout(() => handleSend(initialPrompt), 100);
+    }
+    const termWidth = stdout.columns || 120;
+    const sidebarWidth = Math.min(30, Math.floor(termWidth * 0.22));
+    const showSidebar = config.showFileTree && termWidth > 90;
+    return (_jsxs(Box, { flexDirection: "column", height: process.stdout.rows || 40, children: [_jsx(Header, { config: config, workingDir: workingDir, mcpCount: config.mcpServers.filter((s) => s.enabled).length, screen: screen, isStreaming: isStreaming }), _jsxs(Box, { flexGrow: 1, flexDirection: "row", gap: 0, children: [showSidebar && screen === "chat" && (_jsx(Box, { flexDirection: "column", width: sidebarWidth, borderStyle: "single", borderColor: "gray", paddingX: 1, marginRight: 0, children: _jsx(FileTree, { workingDir: workingDir }) })), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: screen === "chat" ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, overflowY: "hidden", children: _jsx(MessageList, { messages: messages, streamingText: streamingText, isStreaming: isStreaming }) }), _jsx(Input, { onSubmit: handleSend, onTabPress: () => setScreen("settings"), onClearChat: () => setMessages([]), isStreaming: isStreaming })] })) : (_jsx(Settings, { onClose: () => setScreen("chat"), onConfigChange: () => setConfig(getConfig()) })) })] }), _jsxs(Box, { paddingX: 1, justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: "gray", dimColor: true, children: ["Ctrl+C: ", isStreaming ? "stop" : "quit"] }), _jsx(Text, { color: "gray", dimColor: true, children: "Tab: settings" }), _jsx(Text, { color: "gray", dimColor: true, children: "Ctrl+L: clear chat" }), _jsx(Text, { color: "gray", dimColor: true, children: "\u2191\u2193: history" })] }), _jsx(Text, { color: "gray", dimColor: true, children: "macha v0.1.0" })] })] }));
+}

package/dist/ai/client.js

@@ -0,0 +1,150 @@
+import OpenAI from "openai";
+import { getConfig } from "../config/index.js";
+import { TOOL_DEFINITIONS, executeTool } from "./tools.js";
+function createClient() {
+    const config = getConfig();
+    return new OpenAI({
+        apiKey: config.apiKey || "no-key",
+        baseURL: config.baseURL,
+        dangerouslyAllowBrowser: false,
+    });
+}
+function buildApiMessages(systemPrompt, messages) {
+    const result = [
+        { role: "system", content: systemPrompt },
+    ];
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            result.push({ role: "user", content: msg.content });
+        }
+        else if (msg.role === "assistant") {
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                result.push({
+                    role: "assistant",
+                    content: msg.content || null,
+                    tool_calls: msg.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.args },
+                    })),
+                });
+                for (const tc of msg.toolCalls) {
+                    if (tc.result) {
+                        const toolMsg = {
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: tc.result.error
+                                ? `Error: ${tc.result.error}`
+                                : tc.result.output || "(no output)",
+                        };
+                        result.push(toolMsg);
+                    }
+                }
+            }
+            else {
+                result.push({ role: "assistant", content: msg.content });
+            }
+        }
+    }
+    return result;
+}
+export async function* streamChat(messages, workingDir) {
+    const config = getConfig();
+    const client = createClient();
+    const MAX_TOOL_ROUNDS = 10;
+    const apiMessages = buildApiMessages(config.systemPrompt, messages);
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+        try {
+            const stream = await client.chat.completions.create({
+                model: config.model,
+                messages: apiMessages,
+                tools: TOOL_DEFINITIONS,
+                tool_choice: "auto",
+                max_tokens: config.maxTokens,
+                temperature: config.temperature,
+                stream: true,
+            });
+            let currentText = "";
+            const pendingToolCalls = {};
+            let finishReason = null;
+            for await (const chunk of stream) {
+                const choice = chunk.choices[0];
+                if (!choice)
+                    continue;
+                const delta = choice.delta;
+                if (delta?.content) {
+                    currentText += delta.content;
+                    yield { type: "text_delta", delta: delta.content };
+                }
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = String(tc.index);
+                        if (!pendingToolCalls[idx]) {
+                            pendingToolCalls[idx] = {
+                                id: tc.id || `call_${idx}_${round}`,
+                                name: tc.function?.name || "",
+                                args: "",
+                            };
+                        }
+                        if (tc.id)
+                            pendingToolCalls[idx].id = tc.id;
+                        if (tc.function?.name)
+                            pendingToolCalls[idx].name = tc.function.name;
+                        if (tc.function?.arguments)
+                            pendingToolCalls[idx].args += tc.function.arguments;
+                    }
+                }
+                if (choice.finish_reason) {
+                    finishReason = choice.finish_reason;
+                }
+            }
+            if (finishReason !== "tool_calls" || Object.keys(pendingToolCalls).length === 0) {
+                yield { type: "done" };
+                return;
+            }
+            apiMessages.push({
+                role: "assistant",
+                content: currentText || null,
+                tool_calls: Object.values(pendingToolCalls).map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.args },
+                })),
+            });
+            const toolResultMessages = [];
+            for (const tc of Object.values(pendingToolCalls)) {
+                let parsedArgs = {};
+                try {
+                    parsedArgs = JSON.parse(tc.args);
+                }
+                catch {
+                    parsedArgs = {};
+                }
+                const startEvent = { type: "tool_call", id: tc.id, name: tc.name, args: tc.args };
+                yield { type: "tool_call", toolCall: startEvent };
+                const result = await executeTool(tc.name, parsedArgs, workingDir);
+                yield { type: "tool_call", toolCall: { ...startEvent, result } };
+                toolResultMessages.push({
+                    role: "tool",
+                    tool_call_id: tc.id,
+                    content: result.error
+                        ? `Error: ${result.error}`
+                        : result.output || "(no output)",
+                });
+            }
+            apiMessages.push(...toolResultMessages);
+        }
+        catch (err) {
+            const e = err;
+            yield { type: "error", error: e.message || String(err) };
+            return;
+        }
+    }
+    yield {
+        type: "error",
+        error: "Reached maximum tool-call iterations without a final response.",
+    };
+}
+export function generateId() {
+    return Math.random().toString(36).slice(2, 11);
+}

package/dist/ai/tools.js

@@ -0,0 +1,313 @@
+import fs from "fs/promises";
+import path from "path";
+import { execa } from "execa";
+import fg from "fast-glob";
+export const TOOL_DEFINITIONS = [
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the contents of a file in the working directory. Use to inspect code, configs, or any text file.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Relative path to the file from the working directory",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Create or overwrite a file with the given content. Creates parent directories if needed.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Relative path to the file from the working directory",
+                    },
+                    content: {
+                        type: "string",
+                        description: "Full content to write to the file",
+                    },
+                },
+                required: ["path", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_files",
+            description: "List files and directories in a path. Shows the file tree of the project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Relative path to list (default: '.' for working directory)",
+                    },
+                    depth: {
+                        type: "number",
+                        description: "How deep to recurse (default: 2, max: 5)",
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "execute_command",
+            description: "Execute a shell command in the working directory. Use for running scripts, installing packages, running tests, etc.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "Shell command to execute",
+                    },
+                    timeout: {
+                        type: "number",
+                        description: "Timeout in milliseconds (default: 30000)",
+                    },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "search_files",
+            description: "Search for text content across files in the project. Returns file paths and matching line numbers.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Text or regex pattern to search for",
+                    },
+                    glob: {
+                        type: "string",
+                        description: "Glob pattern to filter files (e.g. '**/*.ts', '**/*.py'). Default: all files",
+                    },
+                    case_sensitive: {
+                        type: "boolean",
+                        description: "Whether search is case sensitive (default: false)",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "delete_file",
+            description: "Delete a file from the working directory.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Relative path to the file to delete",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "move_file",
+            description: "Move or rename a file within the working directory.",
+            parameters: {
+                type: "object",
+                properties: {
+                    from: {
+                        type: "string",
+                        description: "Source file path (relative)",
+                    },
+                    to: {
+                        type: "string",
+                        description: "Destination file path (relative)",
+                    },
+                },
+                required: ["from", "to"],
+            },
+        },
+    },
+];
+function safePath(workingDir, filePath) {
+    const base = path.resolve(workingDir);
+    const resolved = path.resolve(base, filePath);
+    const rel = path.relative(base, resolved);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`Path traversal denied: ${filePath} escapes working directory`);
+    }
+    return resolved;
+}
+export async function executeTool(name, args, workingDir) {
+    try {
+        switch (name) {
+            case "read_file": {
+                const filePath = safePath(workingDir, args.path);
+                const content = await fs.readFile(filePath, "utf-8");
+                const lines = content.split("\n");
+                const preview = lines.length > 500
+                    ? lines.slice(0, 500).join("\n") +
+                        `\n\n... (${lines.length - 500} more lines)`
+                    : content;
+                return { success: true, output: preview };
+            }
+            case "write_file": {
+                const filePath = safePath(workingDir, args.path);
+                await fs.mkdir(path.dirname(filePath), { recursive: true });
+                await fs.writeFile(filePath, args.content, "utf-8");
+                return {
+                    success: true,
+                    output: `Written ${args.content.length} bytes to ${args.path}`,
+                };
+            }
+            case "list_files": {
+                const dirPath = args.path
+                    ? safePath(workingDir, args.path)
+                    : workingDir;
+                const maxDepth = Math.min(args.depth || 2, 5);
+                const patterns = Array.from({ length: maxDepth }, (_, i) => `${"*/".repeat(i + 1)}*`);
+                const files = await fg([...patterns, "*"], {
+                    cwd: dirPath,
+                    dot: false,
+                    ignore: [
+                        "node_modules/**",
+                        ".git/**",
+                        "dist/**",
+                        ".next/**",
+                        "__pycache__/**",
+                        "*.pyc",
+                    ],
+                    onlyFiles: false,
+                    markDirectories: true,
+                });
+                files.sort();
+                const output = files.slice(0, 200).join("\n");
+                return {
+                    success: true,
+                    output: output || "(empty directory)",
+                };
+            }
+            case "execute_command": {
+                const timeout = args.timeout || 30000;
+                const cmd = args.command;
+                try {
+                    const result = await execa("sh", ["-c", cmd], {
+                        cwd: workingDir,
+                        timeout,
+                        all: true,
+                        reject: false,
+                    });
+                    const out = result.all || result.stdout || result.stderr || "";
+                    const truncated = out.length > 8000 ? out.slice(0, 8000) + "\n... (truncated)" : out;
+                    return {
+                        success: result.exitCode === 0,
+                        output: truncated ||
+                            `(exit ${result.exitCode}${result.exitCode !== 0 ? " — no output" : ""})`,
+                    };
+                }
+                catch (err) {
+                    const e = err;
+                    return {
+                        success: false,
+                        output: e.all || "",
+                        error: e.message || "Command failed",
+                    };
+                }
+            }
+            case "search_files": {
+                const query = args.query;
+                const globPat = args.glob || "**/*";
+                const caseSensitive = args.case_sensitive || false;
+                if (globPat.includes("..")) {
+                    return { success: false, output: "", error: "Glob pattern must not contain '..'" };
+                }
+                const files = await fg(globPat, {
+                    cwd: workingDir,
+                    ignore: [
+                        "node_modules/**",
+                        ".git/**",
+                        "dist/**",
+                        ".next/**",
+                        "*.lock",
+                    ],
+                    onlyFiles: true,
+                });
+                const results = [];
+                const regex = new RegExp(query, caseSensitive ? "g" : "gi");
+                for (const file of files.slice(0, 200)) {
+                    let resolvedFilePath;
+                    try {
+                        resolvedFilePath = safePath(workingDir, file);
+                    }
+                    catch {
+                        continue;
+                    }
+                    try {
+                        const content = await fs.readFile(resolvedFilePath, "utf-8");
+                        const lines = content.split("\n");
+                        const matches = [];
+                        lines.forEach((line, i) => {
+                            if (regex.test(line)) {
+                                matches.push(`  L${i + 1}: ${line.trim()}`);
+                            }
+                            regex.lastIndex = 0;
+                        });
+                        if (matches.length > 0) {
+                            results.push(`${file}:\n${matches.slice(0, 5).join("\n")}`);
+                        }
+                    }
+                    catch {
+                    }
+                    if (results.length >= 20)
+                        break;
+                }
+                return {
+                    success: true,
+                    output: results.length > 0
+                        ? results.join("\n\n")
+                        : `No matches found for "${query}"`,
+                };
+            }
+            case "delete_file": {
+                const filePath = safePath(workingDir, args.path);
+                await fs.unlink(filePath);
+                return { success: true, output: `Deleted ${args.path}` };
+            }
+            case "move_file": {
+                const from = safePath(workingDir, args.from);
+                const to = safePath(workingDir, args.to);
+                await fs.mkdir(path.dirname(to), { recursive: true });
+                await fs.rename(from, to);
+                return { success: true, output: `Moved ${args.from} → ${args.to}` };
+            }
+            default:
+                return { success: false, output: "", error: `Unknown tool: ${name}` };
+        }
+    }
+    catch (err) {
+        const e = err;
+        return {
+            success: false,
+            output: "",
+            error: e.message || String(err),
+        };
+    }
+}