@sean.holung/minicode 0.1.0

package/dist/src/tools/search.js

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { resolveWorkspacePath } from "../safety/guardrails.js";
+import { expectNonEmptyString } from "./helpers.js";
+function runCommand(command, args, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            if (timedOut) {
+                reject(new Error(`Search command timed out after ${timeoutMs} ms.`));
+                return;
+            }
+            resolve({
+                stdout,
+                stderr,
+                code,
+            });
+        });
+    });
+}
+function getOptionalString(input, key) {
+    const value = input[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Input "${key}" must be a non-empty string.`);
+    }
+    return value;
+}
+export function createSearchTool(config) {
+    return {
+        name: "search",
+        description: "Search file contents using ripgrep. Use when you don't know the symbol name. When results show a function/class name, use read_symbol next (not read_file).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Regex pattern to search for.",
+                },
+                path: {
+                    type: "string",
+                    description: "Optional path to search under, relative to workspace root.",
+                },
+                include: {
+                    type: "string",
+                    description: "Optional glob include filter, e.g. *.ts",
+                },
+            },
+            required: ["pattern"],
+            additionalProperties: false,
+        },
+        execute: async (input) => {
+            const maxOutputChars = 12_000;
+            const pattern = expectNonEmptyString(input, "pattern");
+            const requestedPath = getOptionalString(input, "path") ?? ".";
+            const include = getOptionalString(input, "include");
+            const targetPath = resolveWorkspacePath(requestedPath, config.workspaceRoot);
+            const relativeTarget = path.relative(config.workspaceRoot, targetPath) || ".";
+            const rgArgs = [
+                "--line-number",
+                "--color",
+                "never",
+                "--no-heading",
+                "--binary-files",
+                "without-match",
+                "--glob",
+                "!.minicode/**",
+                "--glob",
+                "!node_modules/**",
+                "--glob",
+                "!package-lock.json",
+                "--glob",
+                "!yarn.lock",
+                "--glob",
+                "!pnpm-lock.yaml",
+                "--glob",
+                "!*.min.js",
+                "-m",
+                "50",
+            ];
+            if (include) {
+                rgArgs.push("--glob", include);
+            }
+            rgArgs.push(pattern, relativeTarget);
+            try {
+                const result = await runCommand("rg", rgArgs, config.workspaceRoot, config.commandTimeoutMs);
+                if (result.code === 1 || result.stdout.trim().length === 0) {
+                    return "No matches found.";
+                }
+                if (result.code !== 0) {
+                    throw new Error(result.stderr || "ripgrep search failed.");
+                }
+                const output = result.stdout.trimEnd();
+                if (output.length > maxOutputChars) {
+                    return `${output.slice(0, maxOutputChars)}\n\n[... output truncated, ${output.length - maxOutputChars} more chars ...]`;
+                }
+                return output;
+            }
+            catch (error) {
+                const commandError = error;
+                if (commandError.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+            // Minimal fallback for systems without rg installed.
+            const grepArgs = [
+                "-RIn",
+                "--exclude-dir=.minicode",
+                "--exclude-dir=node_modules",
+                "--exclude-dir=.git",
+                "--exclude=package-lock.json",
+                "--exclude=yarn.lock",
+                "--exclude=pnpm-lock.yaml",
+                "-m",
+                "50",
+                pattern,
+                relativeTarget,
+            ];
+            const fallbackResult = await runCommand("grep", grepArgs, config.workspaceRoot, config.commandTimeoutMs);
+            if (fallbackResult.code === 1 || fallbackResult.stdout.trim().length === 0) {
+                return "No matches found.";
+            }
+            if (fallbackResult.code !== 0) {
+                throw new Error(fallbackResult.stderr || "grep search failed.");
+            }
+            const fallbackOutput = fallbackResult.stdout.trimEnd();
+            if (fallbackOutput.length > maxOutputChars) {
+                return `${fallbackOutput.slice(0, maxOutputChars)}\n\n[... output truncated, ${fallbackOutput.length - maxOutputChars} more chars ...]`;
+            }
+            return fallbackOutput;
+        },
+    };
+}

package/dist/src/tools/write-file.js

@@ -0,0 +1,44 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWorkspacePath } from "../safety/guardrails.js";
+import { expectNonEmptyString } from "./helpers.js";
+function expectString(input, key) {
+    const value = input[key];
+    if (typeof value !== "string") {
+        throw new Error(`Input "${key}" must be a string.`);
+    }
+    return value;
+}
+export function createWriteFileTool(config, projectIndex) {
+    return {
+        name: "write_file",
+        description: "Create or overwrite a file with the provided content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Path to the file relative to workspace root.",
+                },
+                content: {
+                    type: "string",
+                    description: "The full file content to write.",
+                },
+            },
+            required: ["path", "content"],
+            additionalProperties: false,
+        },
+        execute: async (input) => {
+            const requestedPath = expectNonEmptyString(input, "path");
+            const content = expectString(input, "content");
+            const filePath = resolveWorkspacePath(requestedPath, config.workspaceRoot);
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, content, "utf8");
+            if (projectIndex) {
+                const relPath = path.relative(config.workspaceRoot, filePath);
+                projectIndex.reindexFile(relPath, content);
+            }
+            return `Wrote ${content.length} characters to "${requestedPath}".`;
+        },
+    };
+}

package/dist/src/ui/app.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState, useEffect, useCallback } from "react";
+import { render, Box, Text } from "ink";
+import { HeaderBar } from "./components/header-bar.js";
+import { ActivityPane } from "./components/activity-pane.js";
+import { InputComposer } from "./components/input-composer.js";
+function AppInner({ store, onRunTurn, onCtrlC }) {
+    const [state, setState] = useState(store.getState());
+    useEffect(() => {
+        const unsub = store.subscribe(() => {
+            setState(store.getState());
+        });
+        return unsub;
+    }, [store]);
+    const handleSubmit = useCallback((input) => {
+        onRunTurn(input);
+    }, [onRunTurn]);
+    const disabled = state.phase !== "idle" && state.phase !== "loading";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ActivityPane, { items: state.items }), _jsx(HeaderBar, { model: state.model, step: state.step, maxSteps: state.maxSteps, inputTokens: state.inputTokens, outputTokens: state.outputTokens, workspaceRoot: state.workspaceRoot, indexStatus: state.indexStatus }), _jsx(InputComposer, { onSubmit: handleSubmit, disabled: disabled, ...(onCtrlC && { onCtrlC }) }), state.errorMessage && (_jsx(Box, { paddingX: 1, children: _jsx(Box, { borderStyle: "single", borderColor: "red", paddingX: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", state.errorMessage] }) }) }))] }));
+}
+export function runInkApp(store, onRunTurn, onCtrlC) {
+    process.stdout.write("\x1b[2J\x1b[H");
+    const instance = render(React.createElement(AppInner, {
+        store,
+        onRunTurn,
+        ...(onCtrlC && { onCtrlC }),
+    }), { exitOnCtrlC: false });
+    return {
+        waitUntilExit: () => instance.waitUntilExit(),
+    };
+}

package/dist/src/ui/cli-ink.js

@@ -0,0 +1,168 @@
+import process from "node:process";
+import { CodingAgent } from "../agent/agent.js";
+import { formatConfigForDisplay, loadAgentConfig } from "../agent/config.js";
+import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";
+import { buildProjectIndex } from "../indexer/project-index.js";
+import { createModelClient } from "../model/client.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { UiStore } from "./state/ui-store.js";
+import { runInkApp } from "./app.js";
+export async function runInkCli(verbose, initialTask) {
+    const store = new UiStore();
+    store.setPhase("loading");
+    const config = await loadAgentConfig();
+    const modelClient = createModelClient(config);
+    let projectIndex;
+    let indexStatus = "building...";
+    try {
+        const cacheDir = getWorkspaceCacheDir(config.workspaceRoot);
+        const fileHashes = await computeFileHashes(config.workspaceRoot);
+        const cached = await loadIndex(cacheDir, fileHashes);
+        if (cached) {
+            projectIndex = cached;
+            indexStatus = "ready (cached)";
+        }
+        else {
+            projectIndex = await buildProjectIndex(config.workspaceRoot);
+            await saveIndex(projectIndex, cacheDir, fileHashes);
+            indexStatus = "ready";
+        }
+    }
+    catch {
+        projectIndex = undefined;
+        indexStatus = "unavailable (degraded)";
+    }
+    store.setConfig({
+        model: config.model,
+        workspaceRoot: config.workspaceRoot,
+        maxSteps: config.maxSteps,
+        indexStatus,
+    });
+    store.setPhase("idle");
+    const toolRegistry = ToolRegistry.createDefault(config, projectIndex);
+    const agent = new CodingAgent({
+        config,
+        modelClient,
+        toolRegistry,
+        verbose,
+        ...(projectIndex !== undefined ? { projectIndex } : {}),
+        ...(verbose
+            ? {
+                onProgress: (msg) => store.addItem({ type: "system", content: msg }),
+            }
+            : {}),
+        onUiUpdate: (event) => {
+            switch (event.type) {
+                case "streaming_chunk":
+                    store.appendToStreamingContent(event.content);
+                    break;
+                case "step":
+                    store.setStep(event.step);
+                    break;
+                case "thinking":
+                    store.addItem({ type: "thinking", content: event.content });
+                    break;
+                case "tool_call_start":
+                    store.addItem({
+                        type: "tool_call",
+                        name: event.name,
+                        input: event.input,
+                        state: "running",
+                    });
+                    store.setPhase("tool_running");
+                    break;
+                case "tool_call_end":
+                    store.updateLastToolCall({
+                        state: "success",
+                        elapsedMs: event.elapsedMs,
+                    });
+                    store.addItem({
+                        type: "tool_result",
+                        name: event.name,
+                        content: event.result,
+                        elapsedMs: event.elapsedMs,
+                    });
+                    store.setPhase("model_wait");
+                    break;
+            }
+        },
+    });
+    let turnAbortController = null;
+    const handleCtrlC = (inkExit) => {
+        if (turnAbortController) {
+            turnAbortController.abort();
+        }
+        else if (inkExit) {
+            inkExit();
+        }
+        else {
+            process.exit(0);
+        }
+    };
+    process.on("SIGINT", () => handleCtrlC());
+    const onCtrlC = (exit) => handleCtrlC(exit);
+    const onRunTurn = async (input) => {
+        const trimmed = input.trim();
+        if (trimmed.length === 0)
+            return;
+        store.setError(null);
+        if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
+            process.exit(0);
+        }
+        if (trimmed === "/help") {
+            store.addItem({
+                type: "system",
+                content: 'Commands: "/help", "/config", "/exit". Start with --verbose or -v for detailed logs.',
+            });
+            return;
+        }
+        if (trimmed === "/config") {
+            store.addItem({
+                type: "system",
+                content: formatConfigForDisplay(config),
+            });
+            return;
+        }
+        store.addItem({ type: "user", content: trimmed });
+        store.setPhase("sending");
+        store.setStep(0);
+        turnAbortController = new AbortController();
+        try {
+            const { text, usage, streamed } = await agent.runTurn(trimmed, {
+                signal: turnAbortController.signal,
+            });
+            if (!streamed) {
+                store.addItem({ type: "assistant", content: text });
+            }
+            if (usage) {
+                store.setTokenUsage(usage.inputTokens, usage.outputTokens);
+                store.addItem({
+                    type: "token_usage",
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                });
+            }
+            store.setPhase("idle");
+            store.setStep(0);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                store.addItem({ type: "system", content: "Cancelled" });
+            }
+            else {
+                const message = error instanceof Error ? error.message : "Unknown runtime failure";
+                store.setError(message);
+            }
+            store.setPhase("idle");
+            store.setStep(0);
+        }
+        finally {
+            turnAbortController = null;
+        }
+    };
+    const { waitUntilExit } = runInkApp(store, onRunTurn, onCtrlC);
+    if (initialTask && initialTask.trim().length > 0) {
+        await onRunTurn(initialTask);
+    }
+    await waitUntilExit();
+}

package/dist/src/ui/components/activity-pane.js

@@ -0,0 +1,35 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, Static } from "ink";
+import { c } from "../theme.js";
+import { ToolTimelineItem } from "./tool-timeline-item.js";
+const MAX_TOOL_OUTPUT_PREVIEW = 200;
+function ActivityItemRow({ item }) {
+    switch (item.type) {
+        case "user":
+            return (_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [c.blue("You:"), " "] }), _jsx(Text, { children: item.content })] }));
+        case "assistant":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [c.cyan("Agent:"), " "] }), _jsx(Text, { children: item.content })] }));
+        case "thinking":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [c.magenta("Thinking:"), " "] }), _jsx(Text, { dimColor: true, children: item.content })] }));
+        case "tool_call":
+            return _jsx(ToolTimelineItem, { item: item });
+        case "tool_result": {
+            const preview = item.content.length > MAX_TOOL_OUTPUT_PREVIEW
+                ? item.content.slice(0, MAX_TOOL_OUTPUT_PREVIEW) +
+                    "\n[... truncated ...]"
+                : item.content;
+            return (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: preview }) }));
+        }
+        case "token_usage":
+            return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["tokens: ", item.inputTokens, " in, ", item.outputTokens, " out"] }) }));
+        case "system":
+            return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: item.content }) }));
+        default:
+            return _jsx(Box, {});
+    }
+}
+export function ActivityPane({ items }) {
+    const completedItems = items.length > 0 ? items.slice(0, -1) : [];
+    const lastItem = items.length > 0 ? items[items.length - 1] : undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: completedItems, children: (item, index) => (_jsx(Box, { children: _jsx(ActivityItemRow, { item: item }) }, `item-${index}`)) }), lastItem && (_jsx(Box, { children: _jsx(ActivityItemRow, { item: lastItem }) }, "last-item"))] }));
+}

package/dist/src/ui/components/header-bar.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { c } from "../theme.js";
+export function HeaderBar({ model, step, maxSteps, inputTokens, outputTokens, workspaceRoot, indexStatus, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: c.cyan("minicode") }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("model:"), " "] }), _jsx(Text, { children: model || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("steps:"), " "] }), _jsxs(Text, { children: [step, "/", maxSteps] }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("tokens:"), " "] }), _jsxs(Text, { children: [inputTokens, " in / ", outputTokens, " out"] })] }), _jsxs(Box, { children: [_jsxs(Text, { children: [c.dim("cwd:"), " "] }), _jsx(Text, { children: workspaceRoot || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("index:"), " "] }), _jsx(Text, { children: indexStatus || "—" })] })] }));
+}

package/dist/src/ui/components/input-composer.js

@@ -0,0 +1,46 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { c } from "../theme.js";
+export function InputComposer({ onSubmit, disabled = false, onCtrlC, }) {
+    const [value, setValue] = useState("");
+    const { exit } = useApp();
+    const handleSubmit = useCallback(() => {
+        const trimmed = value.trim();
+        if (trimmed.length > 0 && !disabled) {
+            onSubmit(trimmed);
+            setValue("");
+        }
+    }, [value, disabled, onSubmit]);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            if (onCtrlC) {
+                onCtrlC(exit);
+            }
+            else {
+                exit();
+            }
+            return;
+        }
+        if (key.ctrl && input === "l") {
+            setValue("");
+            return;
+        }
+        if (key.escape) {
+            setValue("");
+            return;
+        }
+        if (key.return) {
+            handleSubmit();
+            return;
+        }
+        if (!disabled && (key.backspace || key.delete || input === "\x7f")) {
+            setValue((v) => v.slice(0, -1));
+            return;
+        }
+        if (!disabled && !key.ctrl && !key.meta && input) {
+            setValue((v) => v + input);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [c.dim("Input:"), " "] }), _jsx(Text, { children: value }), _jsx(Text, { children: disabled ? "" : "_" })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "[Enter send] [Ctrl+C cancel/quit] [Esc clear]" }) })] }));
+}

package/dist/src/ui/components/tool-timeline-item.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { c } from "../theme.js";
+function formatInput(input, maxLen = 60) {
+    const s = JSON.stringify(input);
+    return s.length > maxLen ? s.slice(0, maxLen) + "..." : s;
+}
+export function ToolTimelineItem({ item }) {
+    const { name, input, state, elapsedMs } = item;
+    const argsStr = formatInput(input);
+    let icon;
+    let colorFn;
+    switch (state) {
+        case "running":
+        case "queued":
+            icon = "▶";
+            colorFn = c.cyan;
+            break;
+        case "success":
+            icon = "✓";
+            colorFn = c.green;
+            break;
+        case "error":
+            icon = "✗";
+            colorFn = c.red;
+            break;
+        case "cancelled":
+            icon = "—";
+            colorFn = c.dim;
+            break;
+        default:
+            icon = "?";
+            colorFn = c.dim;
+    }
+    const timeStr = elapsedMs !== undefined ? ` (${elapsedMs}ms)` : "";
+    return (_jsxs(Box, { children: [_jsx(Text, { children: colorFn(`  ${icon} `) }), _jsx(Text, { children: colorFn(`${name}(${argsStr})${timeStr}`) })] }));
+}

package/dist/src/ui/events.js

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

package/dist/src/ui/state/ui-store.js

@@ -0,0 +1,89 @@
+const DEFAULT_STATE = {
+    phase: "idle",
+    step: 0,
+    maxSteps: 50,
+    inputTokens: 0,
+    outputTokens: 0,
+    model: "",
+    workspaceRoot: "",
+    indexStatus: "",
+    items: [],
+    errorMessage: null,
+};
+export class UiStore {
+    state = { ...DEFAULT_STATE };
+    listeners = new Set();
+    getState() {
+        return { ...this.state };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+    update(partial) {
+        this.state = { ...this.state, ...partial };
+        this.notify();
+    }
+    setConfig(config) {
+        this.update(config);
+    }
+    setPhase(phase) {
+        this.update({ phase });
+    }
+    setStep(step) {
+        this.update({ step });
+    }
+    setTokenUsage(inputTokens, outputTokens) {
+        this.update({ inputTokens, outputTokens });
+    }
+    addItem(item) {
+        this.update({
+            items: [...this.state.items, item],
+        });
+    }
+    updateLastToolCall(update) {
+        const items = [...this.state.items];
+        for (let i = items.length - 1; i >= 0; i--) {
+            const it = items[i];
+            if (it && it.type === "tool_call") {
+                items[i] = { ...it, ...update };
+                this.update({ items });
+                return;
+            }
+        }
+    }
+    appendToStreamingContent(chunk) {
+        const items = [...this.state.items];
+        const last = items[items.length - 1];
+        if (last?.type === "assistant") {
+            items[items.length - 1] = {
+                ...last,
+                content: last.content + chunk,
+            };
+        }
+        else {
+            items.push({ type: "assistant", content: chunk });
+        }
+        this.update({ items });
+    }
+    setError(message) {
+        this.update({
+            errorMessage: message,
+            ...(message !== null ? { phase: "error" } : { phase: "idle" }),
+        });
+    }
+    clearAll() {
+        this.update({ items: [] });
+    }
+    reset() {
+        this.state = { ...DEFAULT_STATE };
+        this.notify();
+    }
+}

package/dist/src/ui/theme.js

@@ -0,0 +1,23 @@
+import pc from "picocolors";
+const noColor = process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "";
+export const c = noColor
+    ? {
+        dim: (s) => s,
+        cyan: (s) => s,
+        green: (s) => s,
+        yellow: (s) => s,
+        red: (s) => s,
+        blue: (s) => s,
+        magenta: (s) => s,
+        bold: (s) => s,
+    }
+    : {
+        dim: pc.dim,
+        cyan: pc.cyan,
+        green: pc.green,
+        yellow: pc.yellow,
+        red: pc.red,
+        blue: pc.blue,
+        magenta: pc.magenta,
+        bold: pc.bold,
+    };