micoli 0.0.1

package/README.md

@@ -0,0 +1,49 @@
+# micoli
+
+a mini mini experimental coding agent
+
+## Getting Started
+
+```bash
+export OPENROUTER_API_KEY=your-key-here
+npx micoli
+```
+
+Get your API key at [openrouter.ai/keys](https://openrouter.ai/keys).
+
+### Requirements
+
+- `Node.js`
+- `Docker`
+- `ripgrep`
+
+## Features
+
+```md
+- Coding agent with minimal tools
+  - Read `AGENTS.md`
+  - File tools:
+    - list
+    - find
+    - read
+    - edit
+  - Exec tools:
+    - exec: It runs on Docker container
+  - Web tools:
+    - fetch
+```
+
+## Development
+
+```bash
+npm install
+npm start
+```
+
+## License
+
+MIT
+
+## Support
+
+[https://x.com/jtakahashi0604](https://x.com/jtakahashi0604)

package/dist/index.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Box, render, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { send } from "@/lib/llm";
+import { createExecTools } from "@/tools/exec";
+import { fileTools } from "@/tools/file";
+import { webTools } from "@/tools/web";
+function loadAgentsMd() {
+    try {
+        return readFileSync(resolve(process.cwd(), "AGENTS.md"), "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function App() {
+    const [logs, setLogs] = useState([]);
+    const [history, setHistory] = useState([]);
+    const [input, setInput] = useState("");
+    const [loading, setLoading] = useState(false);
+    const [chatOutput, setChatOutput] = useState("");
+    const [toolOutput, setToolOutput] = useState("");
+    const [status, setStatus] = useState("");
+    const [confirmPrompt, setConfirmPrompt] = useState(null);
+    const [confirmSelected, setConfirmSelected] = useState("yes");
+    const confirmResolveRef = useRef(null);
+    const [charOffset, setCharOffset] = useState(null);
+    const [systemPrompt] = useState(() => loadAgentsMd());
+    useEffect(() => {
+        const cols = process.stdout.columns || 80;
+        const charWidth = 8;
+        const startOffset = Math.max(0, Math.floor((cols - charWidth) / 2));
+        setCharOffset(startOffset);
+        let current = startOffset;
+        const timer = setInterval(() => {
+            current -= 2;
+            if (current <= 0) {
+                current = 0;
+                clearInterval(timer);
+            }
+            setCharOffset(current);
+        }, 50);
+        return () => clearInterval(timer);
+    }, []);
+    const confirmExec = useCallback((command) => {
+        return new Promise((resolve) => {
+            confirmResolveRef.current = resolve;
+            setConfirmPrompt(command);
+            setConfirmSelected("yes");
+        });
+    }, []);
+    useInput((_input, key) => {
+        if (confirmPrompt == null)
+            return;
+        if (key.leftArrow || key.rightArrow) {
+            setConfirmSelected((prev) => (prev === "yes" ? "no" : "yes"));
+        }
+        if (key.return) {
+            const resolve = confirmResolveRef.current;
+            confirmResolveRef.current = null;
+            setConfirmPrompt(null);
+            resolve?.(confirmSelected === "yes");
+        }
+    });
+    const flushChatOutput = useCallback(() => {
+        setChatOutput((prev) => {
+            if (prev !== "") {
+                setLogs((logs) => [...logs, { type: "reasoning", text: prev }]);
+            }
+            return "";
+        });
+    }, []);
+    const flushToolOutput = useCallback(() => {
+        setToolOutput((prev) => {
+            if (prev !== "") {
+                setLogs((logs) => [...logs, { type: "output", text: prev }]);
+            }
+            return "";
+        });
+    }, []);
+    const addLog = useCallback((entry) => {
+        setLogs((prev) => [...prev, entry]);
+    }, []);
+    const historyRef = useRef(history);
+    historyRef.current = history;
+    const setToolOutputRef = useRef(setToolOutput);
+    setToolOutputRef.current = setToolOutput;
+    const tools = useMemo(() => ({
+        ...fileTools,
+        ...createExecTools({
+            onStdout: (chunk) => setToolOutputRef.current((prev) => prev + chunk),
+            onStderr: (chunk) => setToolOutputRef.current((prev) => prev + chunk),
+            confirm: confirmExec,
+        }),
+        ...webTools,
+    }), [confirmExec]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: ignore
+    const handleSubmit = useCallback(async (value) => {
+        if (value.trim() === "" || loading)
+            return;
+        if (value.trim() === "/exit") {
+            process.exit(0);
+        }
+        setInput("");
+        addLog({ type: "user", text: value });
+        setLoading(true);
+        setChatOutput("");
+        setToolOutput("");
+        setStatus("thinking...");
+        try {
+            const userMessage = { role: "user", content: value };
+            const messages = [...historyRef.current, userMessage];
+            const { text, responseMessages } = await send({
+                messages,
+                system: systemPrompt,
+                onReasoningDelta: (delta) => {
+                    setStatus("");
+                    setChatOutput((prev) => prev + delta);
+                },
+                onToolCall: ({ toolName, args }) => {
+                    flushChatOutput();
+                    flushToolOutput();
+                    addLog({
+                        type: "tool",
+                        text: `[tool] ${toolName} ${JSON.stringify(args)}`,
+                    });
+                    setStatus(`running ${toolName}...`);
+                },
+                onToolResult: ({ toolName, result }) => {
+                    flushToolOutput();
+                    addLog({
+                        type: "output",
+                        text: `[${toolName}] ${JSON.stringify(result, null, 2)}`,
+                    });
+                },
+                tools,
+            });
+            flushChatOutput();
+            flushToolOutput();
+            addLog({ type: "assistant", text });
+            setHistory((prev) => [...prev, userMessage, ...responseMessages]);
+        }
+        catch (err) {
+            addLog({
+                type: "error",
+                text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+        finally {
+            setChatOutput("");
+            setToolOutput("");
+            setStatus("");
+            setLoading(false);
+        }
+    }, [loading, addLog, flushChatOutput, flushToolOutput, tools]);
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#8BE9FD", paddingX: 1, children: [logs.length === 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: charOffset ?? 0, children: _jsx(Text, { bold: true, color: "#8BE9FD", children: "█      █\n████████\n██ ██ ██\n████████\n████████" }) }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, color: "#8BE9FD", children: "micoli" })] })) : (
+                    // biome-ignore lint/suspicious/useIterableCallbackReturn: ignore
+                    logs.map((log, i) => {
+                        const key = `${i}`;
+                        switch (log.type) {
+                            case "user":
+                                return (_jsxs(Text, { color: "#50FA7B", children: [">", " ", log.text] }, key));
+                            case "assistant":
+                                return (_jsx(Text, { color: "#F8F8F2", children: log.text }, key));
+                            case "reasoning":
+                                return (_jsx(Text, { color: "#6272A4", dimColor: true, children: log.text }, key));
+                            case "output":
+                                return (_jsx(Text, { color: "#BD93F9", dimColor: true, children: log.text }, key));
+                            case "tool":
+                                return (_jsx(Text, { color: "#F1FA8C", dimColor: true, children: log.text }, key));
+                            case "error":
+                                return (_jsx(Text, { color: "#FF5555", children: log.text }, key));
+                        }
+                    })), chatOutput !== "" && (_jsx(Text, { color: "#6272A4", dimColor: true, children: chatOutput })), toolOutput !== "" && (_jsx(Text, { color: "#BD93F9", dimColor: true, children: toolOutput })), status !== "" && _jsx(Text, { color: "#F1FA8C", children: status })] }), confirmPrompt != null ? (_jsxs(Box, { paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "#FFB86C", children: ["Run command: ", _jsx(Text, { bold: true, children: confirmPrompt })] }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: confirmSelected === "yes" ? "#50FA7B" : "#6272A4", bold: confirmSelected === "yes", children: [confirmSelected === "yes" ? "▸ " : "  ", "yes"] }), _jsxs(Text, { color: confirmSelected === "no" ? "#FF5555" : "#6272A4", bold: confirmSelected === "no", children: [confirmSelected === "no" ? "▸ " : "  ", "no"] })] })] })) : (_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: "#8BE9FD", bold: true, children: [">", " "] }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: "Type a message... (/exit to quit)" })] }))] }));
+}
+render(_jsx(App, {}));

package/dist/lib/llm.js

@@ -0,0 +1,92 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { generateText, stepCountIs, streamText, } from "ai";
+const DEFAULT_MODEL = "openai/gpt-4o-mini";
+export async function send({ apiKey, maxRetries, messages, model, onReasoningDelta, onToolCall, onToolResult, prompt, stopWhen, system, temperature, tools, }) {
+    const resolvedModel = model ?? getDefaultModel({ apiKey });
+    const input = messages ? { messages } : { prompt: prompt ?? "" };
+    if (onReasoningDelta == null) {
+        return generateResult({
+            ...input,
+            maxRetries,
+            model: resolvedModel,
+            onToolCall,
+            onToolResult,
+            stopWhen,
+            system,
+            temperature,
+            tools,
+        });
+    }
+    const result = streamText({
+        ...input,
+        maxRetries,
+        model: resolvedModel,
+        system,
+        onChunk({ chunk }) {
+            if (chunk.type === "reasoning-delta") {
+                onReasoningDelta(chunk.text);
+            }
+            if (chunk.type === "tool-call" && onToolCall) {
+                onToolCall({ toolName: chunk.toolName, args: chunk.input });
+            }
+            if (chunk.type === "tool-result" && onToolResult) {
+                onToolResult({ toolName: chunk.toolName, result: chunk.output });
+            }
+        },
+        stopWhen: stopWhen ?? stepCountIs(10),
+        temperature,
+        tools,
+    });
+    const [reasoningText, text, response] = await Promise.all([
+        result.reasoningText,
+        result.text,
+        result.response,
+    ]);
+    return {
+        text,
+        reasoningText,
+        responseMessages: response.messages,
+    };
+}
+async function generateResult({ maxRetries, messages, model, onToolCall, onToolResult, prompt, stopWhen, system, temperature, tools, }) {
+    const input = messages ? { messages } : { prompt: prompt ?? "" };
+    const { reasoningText, response, text } = await generateText({
+        ...input,
+        maxRetries,
+        model,
+        system,
+        onStepFinish({ toolCalls, toolResults }) {
+            if (onToolCall) {
+                for (const tc of toolCalls) {
+                    onToolCall({ toolName: tc.toolName, args: tc.input });
+                }
+            }
+            if (onToolResult) {
+                for (const tr of toolResults) {
+                    onToolResult({ toolName: tr.toolName, result: tr.output });
+                }
+            }
+        },
+        stopWhen: stopWhen ?? stepCountIs(10),
+        temperature,
+        tools,
+    });
+    return {
+        text,
+        reasoningText,
+        responseMessages: response.messages,
+    };
+}
+function getDefaultModel({ apiKey }) {
+    const openrouter = createOpenRouter({ apiKey: getApiKey({ apiKey }) });
+    return openrouter.chat(DEFAULT_MODEL);
+}
+function getApiKey({ apiKey = process.env.OPENROUTER_API_KEY, }) {
+    if (!apiKey) {
+        throw new Error("OPENROUTER_API_KEY is not set.\n\n" +
+            "Get your API key at https://openrouter.ai/keys and run:\n\n" +
+            "  export OPENROUTER_API_KEY=your-key-here\n" +
+            "  npx micoli\n");
+    }
+    return apiKey;
+}

package/dist/tools/exec.js

@@ -0,0 +1,148 @@
+import { spawn } from "node:child_process";
+import { posix, relative, resolve, sep } from "node:path";
+import { jsonSchema, tool } from "ai";
+const CONTAINER_WORKSPACE_ROOT = "/workspace";
+const DOCKER_IMAGE = "node:lts";
+export async function execCommand({ root = process.cwd(), command, cwd, networkEnabled, onStdout, onStderr, confirm, }) {
+    const { containerCwd, workspaceCwd, workspaceRoot } = resolveExecPaths({
+        cwd,
+        root,
+    });
+    if (confirm) {
+        const approved = await confirm(command);
+        if (!approved) {
+            return {
+                blocked: true,
+                command,
+                cwd: workspaceCwd,
+                stdout: "",
+                stderr: "Execution denied by user.\n",
+                exitCode: 126,
+                success: false,
+            };
+        }
+    }
+    const args = createDockerArgs({
+        command,
+        containerCwd,
+        networkEnabled: networkEnabled ?? false,
+        workspaceRoot,
+    });
+    if (args[0] == null) {
+        throw new Error("Failed to construct Docker command arguments.");
+    }
+    const spawnedProcess = spawn(args[0], args.slice(1), {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const exitCodePromise = new Promise((resolve) => {
+        spawnedProcess.on("close", (code) => resolve(code ?? 1));
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        readAndMirrorStream({
+            stream: spawnedProcess.stdout,
+            write: (chunk) => {
+                if (onStdout)
+                    onStdout(chunk.toString("utf8"));
+                else
+                    process.stdout.write(chunk);
+            },
+        }),
+        readAndMirrorStream({
+            stream: spawnedProcess.stderr,
+            write: (chunk) => {
+                if (onStderr)
+                    onStderr(chunk.toString("utf8"));
+                else
+                    process.stderr.write(chunk);
+            },
+        }),
+        exitCodePromise,
+    ]);
+    return {
+        blocked: false,
+        command,
+        cwd: workspaceCwd,
+        stdout,
+        stderr,
+        exitCode,
+        success: exitCode === 0,
+    };
+}
+async function readAndMirrorStream({ stream, write, }) {
+    if (stream == null) {
+        return "";
+    }
+    const chunks = [];
+    for await (const chunk of stream) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        chunks.push(buf);
+        write(buf);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function createDockerArgs({ command, containerCwd, networkEnabled, workspaceRoot, }) {
+    return [
+        "docker",
+        "run",
+        "--rm",
+        "--interactive=false",
+        ...(networkEnabled ? [] : ["--network", "none"]),
+        "--env",
+        "CI=true",
+        "--volume",
+        `${workspaceRoot}:${CONTAINER_WORKSPACE_ROOT}`,
+        "--workdir",
+        containerCwd,
+        "--entrypoint",
+        "sh",
+        DOCKER_IMAGE,
+        "-lc",
+        command,
+    ];
+}
+function resolveExecPaths({ cwd, root = process.cwd(), }) {
+    const workspaceRoot = resolve(root);
+    const hostCwd = cwd ? resolve(workspaceRoot, cwd) : workspaceRoot;
+    const relativeCwd = relative(workspaceRoot, hostCwd);
+    if (relativeCwd === ".." || relativeCwd.startsWith(`..${sep}`)) {
+        throw new Error("Path must stay inside the current working directory");
+    }
+    const workspaceCwd = relativeCwd || ".";
+    const containerCwd = workspaceCwd === "."
+        ? CONTAINER_WORKSPACE_ROOT
+        : posix.join(CONTAINER_WORKSPACE_ROOT, workspaceCwd.split(sep).join(posix.sep));
+    return {
+        workspaceRoot,
+        workspaceCwd,
+        containerCwd,
+    };
+}
+const execInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        command: {
+            type: "string",
+            description: "Shell command to execute.",
+        },
+        cwd: {
+            type: "string",
+            description: "Working directory relative to the current workspace.",
+        },
+        networkEnabled: {
+            type: "boolean",
+            description: "Whether to allow outbound network access from the Docker sandbox.",
+        },
+    },
+    required: ["command", "networkEnabled"],
+    additionalProperties: false,
+});
+export function createExecTools({ root, onStdout, onStderr, confirm, } = {}) {
+    return {
+        exec: tool({
+            description: "Execute a shell command inside a Docker sandbox.",
+            inputSchema: execInputSchema,
+            execute: async (input) => execCommand({ ...input, root, onStdout, onStderr, confirm }),
+        }),
+    };
+}
+export const execTools = createExecTools();

package/dist/tools/file.js

@@ -0,0 +1,304 @@
+import { spawn } from "node:child_process";
+import { readFile as fsReadFile, writeFile as fsWriteFile, mkdir, } from "node:fs/promises";
+import { dirname, relative, resolve, sep } from "node:path";
+import { jsonSchema, tool } from "ai";
+import { globby } from "globby";
+export function resolveFilePath({ root = process.cwd(), filePath, }) {
+    const workspaceRoot = resolve(root);
+    const targetPath = resolve(workspaceRoot, filePath);
+    const relativePath = relative(workspaceRoot, targetPath);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
+        throw new Error("Path must stay inside the current working directory");
+    }
+    return targetPath;
+}
+export async function listFiles({ path = ".", recursive = true, maxDepth = 3, root = process.cwd(), } = {}) {
+    if (maxDepth < 0) {
+        throw new Error("maxDepth must be greater than or equal to 0");
+    }
+    const targetPath = resolveFilePath({ filePath: path, root });
+    const basePath = toWorkspaceRelativePath({ targetPath, root });
+    const matches = await globby(recursive ? ["**/*"] : ["*"], {
+        cwd: targetPath,
+        deep: recursive ? maxDepth + 1 : 1,
+        expandDirectories: false,
+        markDirectories: true,
+        onlyFiles: false,
+    });
+    const entries = matches
+        .sort((left, right) => left.localeCompare(right))
+        .map((match) => {
+        const isDirectory = match.endsWith("/");
+        const relativePath = joinRelativePath({
+            basePath,
+            entryPath: isDirectory ? match.slice(0, -1) : match,
+        });
+        return {
+            path: relativePath,
+            type: isDirectory ? "directory" : "file",
+        };
+    });
+    return {
+        path: toWorkspaceRelativePath({ targetPath, root }),
+        recursive,
+        maxDepth,
+        entries,
+    };
+}
+export async function findFiles({ path = ".", pattern, glob, ignoreCase = false, maxResults = 100, root = process.cwd(), }) {
+    const targetPath = resolveFilePath({ filePath: path, root });
+    const args = [
+        "--no-heading",
+        "--line-number",
+        "--color",
+        "never",
+        ...(ignoreCase ? ["--ignore-case"] : []),
+        ...(glob ? ["--glob", glob] : []),
+        "--max-count",
+        String(maxResults),
+        "--",
+        pattern,
+        targetPath,
+    ];
+    const { stdout, exitCode } = await spawnRipgrep(args);
+    const matches = [];
+    if (exitCode === 0 && stdout !== "") {
+        for (const line of stdout.split("\n")) {
+            if (line === "")
+                continue;
+            const match = line.match(/^(.+?):(\d+):(.*)$/);
+            if (match == null)
+                continue;
+            matches.push({
+                path: toWorkspaceRelativePath({
+                    targetPath: match[1],
+                    root,
+                }),
+                line: Number(match[2]),
+                content: match[3],
+            });
+        }
+    }
+    const truncated = matches.length >= maxResults;
+    return {
+        pattern,
+        path: toWorkspaceRelativePath({ targetPath, root }),
+        totalMatches: matches.length,
+        truncated,
+        matches,
+    };
+}
+export async function readFile({ path, beginLine = 1, closeLine, root = process.cwd(), }) {
+    if (beginLine < 1) {
+        throw new Error("beginLine must be greater than or equal to 1");
+    }
+    if (closeLine !== undefined && closeLine < beginLine) {
+        throw new Error("closeLine must be greater than or equal to beginLine");
+    }
+    const targetPath = resolveFilePath({ filePath: path, root });
+    const text = await fsReadFile(targetPath, "utf8");
+    const lines = toLines({ content: text });
+    const totalLines = lines.length;
+    const resultBeginLine = totalLines === 0 ? 0 : beginLine;
+    const resultCloseLine = totalLines === 0 ? 0 : Math.min(closeLine ?? totalLines, totalLines);
+    const selectedLines = totalLines === 0
+        ? []
+        : lines.slice(Math.max(resultBeginLine - 1, 0), resultCloseLine);
+    return {
+        path: toWorkspaceRelativePath({ targetPath, root }),
+        totalLines,
+        beginLine: resultBeginLine,
+        closeLine: resultCloseLine,
+        content: selectedLines
+            .map((line, index) => `${resultBeginLine + index}|${line}`)
+            .join("\n"),
+    };
+}
+export async function editFile({ path, content, oldString, newString, root = process.cwd(), }) {
+    const targetPath = resolveFilePath({ filePath: path, root });
+    if (oldString != null && newString != null) {
+        const current = await fsReadFile(targetPath, "utf8");
+        const count = current.split(oldString).length - 1;
+        if (count === 0) {
+            throw new Error("oldString not found in file");
+        }
+        if (count > 1) {
+            throw new Error(`oldString found ${count} times in file — provide more context to make it unique`);
+        }
+        const nextContent = current.replace(oldString, newString);
+        await fsWriteFile(targetPath, nextContent, "utf8");
+        return {
+            path: toWorkspaceRelativePath({ targetPath, root }),
+            operation: "edit",
+            bytesWritten: Buffer.byteLength(nextContent, "utf8"),
+        };
+    }
+    if (content == null) {
+        throw new Error("Either content or oldString/newString must be provided");
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await fsWriteFile(targetPath, content, "utf8");
+    return {
+        path: toWorkspaceRelativePath({ targetPath, root }),
+        operation: "write",
+        bytesWritten: Buffer.byteLength(content, "utf8"),
+    };
+}
+function spawnRipgrep(args) {
+    return new Promise((resolve) => {
+        const proc = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        proc.on("close", (code) => {
+            resolve({
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                exitCode: code ?? 1,
+            });
+        });
+    });
+}
+export function createFileTools({ root } = {}) {
+    return {
+        listFiles: tool({
+            description: "List files and directories.",
+            inputSchema: listFilesInputSchema,
+            execute: async (input) => listFiles({ ...input, root }),
+        }),
+        findFiles: tool({
+            description: "Find files and directories.",
+            inputSchema: findFilesInputSchema,
+            execute: async (input) => findFiles({ ...input, root }),
+        }),
+        readFile: tool({
+            description: "Read a file with optional begin and close lines.",
+            inputSchema: readFileInputSchema,
+            execute: async (input) => readFile({ ...input, root }),
+        }),
+        editFile: tool({
+            description: "Write or edit a file. To create/overwrite, provide content. To edit an existing file, provide oldString and newString for search-and-replace. oldString must match exactly one location in the file.",
+            inputSchema: editFileInputSchema,
+            execute: async (input) => editFile({ ...input, root }),
+        }),
+    };
+}
+function toWorkspaceRelativePath({ targetPath, root, }) {
+    const relativePath = relative(resolve(root), targetPath);
+    return relativePath === "" ? "." : relativePath;
+}
+function joinRelativePath({ basePath, entryPath, }) {
+    if (basePath === ".") {
+        return entryPath;
+    }
+    return `${basePath}/${entryPath}`;
+}
+function toLines({ content }) {
+    if (content === "") {
+        return [];
+    }
+    const lines = content.split(/\r?\n/u);
+    if (content.endsWith("\n") || content.endsWith("\r")) {
+        lines.pop();
+    }
+    return lines;
+}
+const listFilesInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "Directory path relative to the current workspace.",
+        },
+        recursive: {
+            type: "boolean",
+            description: "Whether to include nested files and directories.",
+            default: true,
+        },
+        maxDepth: {
+            type: "integer",
+            description: "Maximum directory depth when recursive is true.",
+            minimum: 0,
+            default: 3,
+        },
+    },
+    additionalProperties: false,
+});
+const findFilesInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "Directory path relative to the current workspace.",
+            default: ".",
+        },
+        pattern: {
+            type: "string",
+            description: "Regex pattern to search for in file contents.",
+        },
+        glob: {
+            type: "string",
+            description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,jsx}").',
+        },
+        ignoreCase: {
+            type: "boolean",
+            description: "Whether to perform case-insensitive matching.",
+            default: false,
+        },
+        maxResults: {
+            type: "integer",
+            description: "Maximum number of matching lines per file.",
+            minimum: 1,
+            default: 100,
+        },
+    },
+    required: ["pattern"],
+    additionalProperties: false,
+});
+const readFileInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "File path relative to the current workspace.",
+        },
+        beginLine: {
+            type: "integer",
+            description: "1-based begin line number, inclusive.",
+            minimum: 1,
+            default: 1,
+        },
+        closeLine: {
+            type: "integer",
+            description: "1-based close line number, inclusive.",
+            minimum: 1,
+        },
+    },
+    required: ["path"],
+    additionalProperties: false,
+});
+const editFileInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "File path relative to the current workspace.",
+        },
+        content: {
+            type: "string",
+            description: "Full file content to write. Use this to create a new file or overwrite an existing file.",
+        },
+        oldString: {
+            type: "string",
+            description: "The exact text to find in the file for search-and-replace editing. Must match exactly one location.",
+        },
+        newString: {
+            type: "string",
+            description: "The replacement text. Used together with oldString.",
+        },
+    },
+    required: ["path"],
+    additionalProperties: false,
+});
+export const fileTools = createFileTools();

package/dist/tools/web.js

@@ -0,0 +1,58 @@
+import { jsonSchema, tool } from "ai";
+export async function fetchPage({ url, maxLength = 50000, headers, }) {
+    if (!/^https?:\/\//i.test(url)) {
+        throw new Error("URL must start with http:// or https://");
+    }
+    const response = await fetch(url, {
+        headers: {
+            "User-Agent": "micoli/1.0",
+            Accept: "text/html,application/xhtml+xml,text/plain,application/json",
+            ...headers,
+        },
+        redirect: "follow",
+        signal: AbortSignal.timeout(30_000),
+    });
+    const contentType = response.headers.get("content-type") ?? "";
+    const text = await response.text();
+    const truncated = text.length > maxLength;
+    const content = truncated ? text.slice(0, maxLength) : text;
+    return {
+        url: response.url,
+        status: response.status,
+        contentType,
+        truncated,
+        content,
+    };
+}
+const fetchPageInputSchema = jsonSchema({
+    type: "object",
+    properties: {
+        url: {
+            type: "string",
+            description: "URL to fetch. Must start with http:// or https://.",
+        },
+        maxLength: {
+            type: "integer",
+            description: "Maximum character length of the returned content.",
+            minimum: 1,
+            default: 50000,
+        },
+        headers: {
+            type: "object",
+            description: "Additional HTTP headers to send with the request.",
+            additionalProperties: { type: "string" },
+        },
+    },
+    required: ["url"],
+    additionalProperties: false,
+});
+export function createWebTools() {
+    return {
+        fetchPage: tool({
+            description: "Fetch a web page and return its content as text. Supports HTML, JSON, and plain text.",
+            inputSchema: fetchPageInputSchema,
+            execute: async (input) => fetchPage(input),
+        }),
+    };
+}
+export const webTools = createWebTools();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "micoli",
+  "version": "0.0.1",
+  "description": "a mini mini experimental coding agent",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andraindrops/micoli.git"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "bin": {
+    "micoli": "./dist/index.js"
+  },
+  "scripts": {
+    "lint": "biome check .",
+    "test": "vitest run",
+    "format": "biome check --fix .",
+    "start": "dotenvx run --env-file=.env -- tsx src/index.tsx",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.6",
+    "@dotenvx/dotenvx": "^1.40.1",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.2.14",
+    "msw": "^2.12.13",
+    "tsx": "^4.19.0",
+    "vitest": "^3.2.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@openrouter/ai-sdk-provider": "^2.3.0",
+    "ai": "^6.0.116",
+    "diff": "^8.0.3",
+    "globby": "^16.1.1",
+    "ink": "^6.8.0",
+    "ink-text-input": "^6.0.0",
+    "outdent": "^0.8.0",
+    "react": "^19.2.4"
+  }
+}