@vietor/easy-agent 0.2.1 → 0.3.1

package/dist/tools/glob.js

@@ -1,7 +1,7 @@
 import { resolveCwd, runRgLines } from "../util/ripgrep.js";
 const DESCRIPTION = [
     "List files under a directory, optionally filtered by a glob pattern (e.g. **/*.ts); omit pattern to list every file.",
-    "Skips node_modules and .git.",
+    "Includes hidden files (e.g. .env, .gitignore); skips node_modules and .git.",
     "Returns paths relative to the root, one per line.",
 ].join(" ");
 export const globTool = {
@@ -15,14 +15,14 @@ export const globTool = {
         },
         required: [],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const cwd = resolveCwd(args.path);
         const rgArgs = ["--files"];
         const pattern = args.pattern;
         if (pattern)
             rgArgs.push("-g", pattern);
         rgArgs.push(".");
-        const files = await runRgLines(rgArgs, cwd);
+        const files = await runRgLines(rgArgs, cwd, ctx.signal);
         return files.length ? files.join("\n") : "(no matches)";
     },
     summaryArg: ["pattern", "path"],

package/dist/tools/grep.js

@@ -1,9 +1,9 @@
 import { resolveCwd, runRgLines } from "../util/ripgrep.js";
-const MAX_MATCHES = 200;
+const DEFAULT_HEAD_LIMIT = 200;
 const DESCRIPTION = [
     "Search file contents under a directory recursively for a regex pattern (RE2 syntax).",
-    "Skips node_modules and .git.",
-    "Returns matching lines as path:line: content, capped at 200 matches.",
+    "Includes hidden files (e.g. .env, .gitignore); skips node_modules and .git.",
+    "By default returns matching lines as path:line:content, capped at 200 lines; use output_mode, head_limit, and context options to control output.",
 ].join(" ");
 export const grepTool = {
     name: "Grep",
@@ -13,23 +13,60 @@ export const grepTool = {
         properties: {
             pattern: { type: "string" },
             path: { type: "string", description: "root directory, defaults to cwd" },
+            glob: { type: "string", description: "glob pattern to filter files (e.g. *.ts)" },
+            type: { type: "string", description: "file type to search (e.g. ts, js, py, rust, go)" },
+            output_mode: {
+                type: "string",
+                enum: ["content", "files_with_matches", "count"],
+                description: "content (default, matching lines), files_with_matches (file paths only), count (match counts per file)",
+            },
+            ignore_case: { type: "boolean", description: "case-insensitive match" },
+            before: { type: "number", description: "lines to show before each match" },
+            after: { type: "number", description: "lines to show after each match" },
+            context: { type: "number", description: "lines to show before and after each match" },
+            only_matching: { type: "boolean", description: "print only the matched (non-empty) parts" },
+            multiline: { type: "boolean", description: "allow patterns to span newlines" },
+            head_limit: { type: "number", description: "max output lines (default 200)" },
         },
         required: ["pattern"],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const cwd = resolveCwd(args.path);
-        const rgArgs = [
-            "--line-number",
-            "--with-filename",
-            "--no-heading",
-            args.pattern,
-            ".",
-        ];
-        const lines = await runRgLines(rgArgs, cwd);
+        const rgArgs = ["--line-number", "--with-filename", "--no-heading"];
+        if (args.ignore_case)
+            rgArgs.push("-i");
+        if (args.only_matching)
+            rgArgs.push("-o");
+        if (args.multiline)
+            rgArgs.push("-U", "--multiline-dotall");
+        const context = args.context;
+        if (context)
+            rgArgs.push("-C", String(context));
+        else {
+            const before = args.before;
+            const after = args.after;
+            if (before)
+                rgArgs.push("-B", String(before));
+            if (after)
+                rgArgs.push("-A", String(after));
+        }
+        if (args.glob)
+            rgArgs.push("-g", args.glob);
+        if (args.type)
+            rgArgs.push("-t", args.type);
+        const output_mode = args.output_mode || "content";
+        if (output_mode === "files_with_matches")
+            rgArgs.push("-l");
+        else if (output_mode === "count")
+            rgArgs.push("-c");
+        rgArgs.push(args.pattern, ".");
+        const lines = await runRgLines(rgArgs, cwd, ctx.signal);
         if (!lines.length)
             return "(no matches)";
-        if (lines.length > MAX_MATCHES)
-            return lines.slice(0, MAX_MATCHES).join("\n") + "\n(truncated)";
+        const headLimit = args.head_limit || DEFAULT_HEAD_LIMIT;
+        if (lines.length > headLimit) {
+            return lines.slice(0, headLimit).join("\n") + `\n(${lines.length - headLimit} more matches, truncated)`;
+        }
         return lines.join("\n");
     },
     summaryArg: ["pattern", "path"],

package/dist/tools/registry.js

@@ -5,6 +5,7 @@ import { fileEditTool } from "./file_edit.js";
 import { globTool } from "./glob.js";
 import { grepTool } from "./grep.js";
 import { webFetchTool } from "./web_fetch.js";
+import { askUserTool } from "./ask_user.js";
 export class ToolRegistry {
     tools = new Map();
     register(tool) {
@@ -20,12 +21,12 @@ export class ToolRegistry {
             },
         }));
     }
-    async execute(name, args) {
+    async execute(name, args, ctx) {
         const tool = this.tools.get(name);
         if (!tool)
             return { content: `Error: unknown tool ${name}`, isError: true };
         try {
-            const r = await tool.execute(args);
+            const r = await tool.execute(args, ctx);
             return typeof r === "string" ? { content: r } : r;
         }
         catch (e) {
@@ -46,6 +47,6 @@ export class ToolRegistry {
     }
 }
 export function registerBuiltinTools(tools) {
-    for (const t of [shellTool, fileReadTool, fileWriteTool, fileEditTool, globTool, grepTool, webFetchTool])
+    for (const t of [shellTool, fileReadTool, fileWriteTool, fileEditTool, globTool, grepTool, webFetchTool, askUserTool])
         tools.register(t);
 }

package/dist/tools/shell.js

@@ -22,9 +22,9 @@ export const shellTool = {
         properties: { command: { type: "string" } },
         required: ["command"],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const command = args.command;
-        const r = await runProcess(shell, [...shellArgs, commandPrefix + command]);
+        const r = await runProcess(shell, [...shellArgs, commandPrefix + command], {}, ctx.signal);
         if (r.status === 0 && !r.error) {
             return r.stdout || "(no output)";
         }

package/dist/tools/web_fetch.js

@@ -76,7 +76,7 @@ function htmlToMarkdown(html) {
     return turndown.turndown(html);
 }
 function mimeFrom(contentType) {
-    return contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+    return contentType.split(";", 1)[0].trim().toLowerCase();
 }
 function isTextualMime(mime) {
     return (!mime ||
@@ -110,7 +110,7 @@ export const webFetchTool = {
         },
         required: ["url"],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const url = args.url;
         const format = (args.format || "markdown").toLowerCase();
         let res;
@@ -120,6 +120,7 @@ export const webFetchTool = {
                     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
                 },
                 redirect: "follow",
+                signal: ctx.signal,
             });
         }
         catch (e) {

package/dist/tui/App.js

@@ -3,150 +3,72 @@ import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "reac
 import { Box, render, Text, useApp, useInput } from "ink";
 import { Markdown } from "./components/Markdown.js";
 import { LogView } from "./LogView.js";
-import { LogStore } from "./LogStore.js";
 import { AppHeader } from "./AppHeader.js";
 import { PromptOrCommandInput } from "./PromptOrCommandInput.js";
+import { QuestionView } from "./QuestionView.js";
 import { Spinner } from "./Spinner.js";
 import { compactDisplay } from "../util/format.js";
 const STREAM_FRAME_MS = 240;
-export function App({ agent, commands, mcp }) {
+export function App({ session }) {
     const { exit } = useApp();
-    const [store] = useState(() => new LogStore());
-    const log = useSyncExternalStore(store.subscribe, store.getSnapshot);
-    const [status, setStatus] = useState("idle");
+    useSyncExternalStore(session.subscribe, session.getSnapshot);
+    const [running, setRunning] = useState(false);
+    const [elapsed, setElapsed] = useState(0);
+    const [usage, setUsage] = useState({ prompt: 0, completion: 0 });
     const [, setTick] = useState(0);
     const streamingRef = useRef("");
     const renderTimerRef = useRef(undefined);
-    const abortRef = useRef(null);
-    const startRef = useRef(0);
-    const timerRef = useRef(undefined);
-    const [elapsed, setElapsed] = useState(0);
-    const [usage, setUsage] = useState({ prompt: 0, completion: 0 });
-    const allCmds = useMemo(() => commands.schemas(), []);
+    const allCmds = useMemo(() => session.commandSchemas, [session]);
+    const pendingQuestion = session.logEntries.find((e) => e.kind === "question" && e.answer === null);
     useEffect(() => {
-        for (const msg of mcp.flushErrors())
-            store.append({ kind: "error", text: msg });
-        mcp.onError = (msg) => store.append({ kind: "error", text: msg });
-        return () => {
-            mcp.onError = undefined;
-        };
+        session.setCallbacks({
+            onStreaming: (text) => {
+                streamingRef.current = text;
+                scheduleStreamingRender();
+            },
+            onRunStateChange: (r) => setRunning(r),
+            onElapsedChange: (s) => setElapsed(s),
+            onUsageChange: (p, c) => setUsage({ prompt: p, completion: c }),
+        });
     }, []);
-    const cancelStreamingRender = () => {
-        if (renderTimerRef.current) {
-            clearTimeout(renderTimerRef.current);
-            renderTimerRef.current = undefined;
-        }
-    };
     const scheduleStreamingRender = () => {
         if (renderTimerRef.current)
             return;
         renderTimerRef.current = setTimeout(() => {
             renderTimerRef.current = undefined;
-            setStatus("streaming");
             setTick((t) => t + 1);
         }, STREAM_FRAME_MS);
     };
-    const flushStreaming = () => {
-        cancelStreamingRender();
-        if (streamingRef.current) {
-            store.append({ kind: "assistant", text: streamingRef.current });
-            streamingRef.current = "";
-        }
-    };
-    const onEvent = (e) => {
-        if (e.type === "delta") {
-            streamingRef.current += e.text;
-            scheduleStreamingRender();
-        }
-        else if (e.type === "tool_start") {
-            flushStreaming();
-            setStatus("thinking");
-            store.append({ kind: "tool", id: e.id, name: e.name, summary: e.summary, result: null });
-        }
-        else if (e.type === "retry") {
-            cancelStreamingRender();
-            streamingRef.current = "";
-            setStatus("thinking");
-            store.append({ kind: "retry", attempt: e.attempt, max: e.max });
-        }
-        else if (e.type === "tool_end") {
-            setStatus("thinking");
-            store.setToolResult(e.id, e.result, e.isError);
-        }
-        else if (e.type === "error") {
-            flushStreaming();
-            store.append({ kind: "error", text: e.text });
-        }
-        else if (e.type === "interrupted") {
-            flushStreaming();
-            store.append({ kind: "interrupted" });
-        }
-        else if (e.type === "usage") {
-            setUsage({ prompt: e.promptTokens, completion: e.completionTokens });
-        }
-    };
     useInput((_input, key) => {
+        if (pendingQuestion) {
+            if (key.ctrl && _input === "c")
+                session.abort();
+            return;
+        }
         if (key.escape) {
-            abortRef.current?.abort();
+            session.abort();
         }
         else if (key.ctrl && _input === "c") {
-            if (abortRef.current)
-                abortRef.current.abort();
+            if (running)
+                session.abort();
             else
                 exit();
         }
     });
     async function handleCommand(name) {
-        return await commands.execute(name, { agent, mcp }, {
-            exit,
-            clearLog: () => store.clear(),
-            info: (t) => store.append({ kind: "system", text: t }),
-            error: (t) => store.append({ kind: "error", text: t }),
-            thinking: (on) => setStatus(on ? "thinking" : "idle"),
-            runSkill: (s) => handleSkill(s),
-        });
-    }
-    async function runAgent(entry, run) {
-        store.append(entry);
-        setStatus("thinking");
-        streamingRef.current = "";
-        startRef.current = Date.now();
-        setElapsed(0);
-        setUsage({ prompt: 0, completion: 0 });
-        timerRef.current = setInterval(() => {
-            setElapsed(Math.floor((Date.now() - startRef.current) / 1000));
-        }, 1000);
-        const controller = new AbortController();
-        abortRef.current = controller;
-        try {
-            await run(controller.signal);
-            flushStreaming();
-        }
-        catch (e) {
-            flushStreaming();
-            store.append({ kind: "error", text: e.message });
-        }
-        finally {
-            clearInterval(timerRef.current);
-            timerRef.current = undefined;
-            abortRef.current = null;
-            setStatus("idle");
-        }
+        await session.executeCommand(name, { exit, setRunning });
     }
     async function handlePrompt(text) {
-        if (commands.exists(text)) {
+        if (session.isCommand(text)) {
             await handleCommand(text);
         }
         else {
-            await runAgent({ kind: "user", text }, (signal) => agent.run(text, onEvent, signal));
+            await session.startPrompt(text);
         }
     }
-    async function handleSkill(skill) {
-        await runAgent({ kind: "skill", name: skill.name }, (signal) => agent.runSkill(skill, onEvent, signal));
-    }
-    return (_jsxs(Box, { flexDirection: "column", minWidth: 80, children: [_jsx(AppHeader, {}), _jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: log.map((entry, i) => (_jsx(LogView, { entry: entry }, i))) }), status === "streaming" && streamingRef.current ? (_jsx(Box, { paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { color: "green", children: streamingRef.current }) })) : null, status === "thinking" ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: "thinking", elapsed: elapsed, promptTokens: usage.prompt, completionTokens: usage.completion }) })) : null, status === "idle" ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["[CTX ", compactDisplay(agent.contextTokens), "] \u00B7 ESC to stop \u00B7 \"/quit\" to leave"] }), _jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", minWidth: 80, children: [_jsx(AppHeader, {}), _jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [session.logEntries.length === 0 ? (_jsx(Box, { paddingTop: 2 })) : null, session.logEntries.map((entry, i) => (_jsx(LogView, { entry: entry }, i)))] }), running && pendingQuestion ? (_jsx(QuestionView, { question: pendingQuestion, onAnswer: (ans) => session.submitAnswer(pendingQuestion.id, ans) })) : running && streamingRef.current ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { color: "green", children: streamingRef.current }) })) : running ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: "thinking", elapsed: elapsed, promptTokens: usage.prompt, completionTokens: usage.completion }) })) : null, !running ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["[CTX ", compactDisplay(session.contextTokens), "] \u00B7 ESC to stop \u00B7 type / for commands"] }), _jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })] })) : null] }));
 }
-export function startApp(agent, commands, mcp) {
-    process.stdout.write("\u001B[2J\u001B[H");
-    return render(_jsx(App, { agent: agent, commands: commands, mcp: mcp }), { exitOnCtrlC: false });
+export function startApp(session) {
+    process.stdout.write("");
+    return render(_jsx(App, { session: session }), { exitOnCtrlC: false });
 }

package/dist/tui/AppHeader.js

@@ -3,5 +3,5 @@ import { Box, Text } from "ink";
 import { getPackageInfo } from "../util/package.js";
 export function AppHeader() {
     const pkginfo = getPackageInfo();
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkginfo.version] })] }), _jsx(Text, { dimColor: true, children: process.cwd() })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkginfo.version] })] }), _jsx(Text, { dimColor: true, children: process.cwd() })] }), _jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray" })] }));
 }

package/dist/tui/LogView.js

@@ -14,20 +14,24 @@ function preview(isError, text) {
 export const LogView = memo(function Entry({ entry }) {
     switch (entry.kind) {
         case "user":
-            return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: `❯ ${entry.text}` }) }));
+            return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "\u276F " }), entry.text] }) }));
         case "skill":
-            return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "magenta", children: `◈ skill: ${entry.name}` }) }));
+            return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "magenta", children: "\u25C8 " }), _jsx(Text, { dimColor: true, children: "skill " }), _jsx(Text, { color: "magenta", bold: true, children: entry.name })] }) }));
         case "assistant":
             return (_jsx(Box, { marginTop: 1, children: _jsx(Markdown, { color: "green", children: entry.text }) }));
         case "tool":
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: `● ${entry.name}${entry.summary ? ` ${entry.summary}` : ""}` }), entry.result !== null ? (_jsx(Text, { color: entry.isError ? "red" : "gray", children: `  ${preview(entry.isError ?? false, entry.result)}` })) : null] }));
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u25CF " }), _jsx(Text, { color: "yellow", bold: true, children: entry.name }), entry.summary ? _jsxs(Text, { dimColor: true, children: [" ", entry.summary] }) : null] }), entry.result !== null ? (_jsx(Text, { color: entry.isError ? "red" : "gray", children: `  ${preview(entry.isError ?? false, entry.result)}` })) : null] }));
         case "retry":
-            return (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: `↻ Retry ${entry.attempt}/${entry.max}` }) }));
+            return (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u21BB " }), _jsxs(Text, { dimColor: true, children: ["retry ", entry.attempt, "/", entry.max] })] }) }));
         case "error":
-            return (_jsx(Box, { children: _jsx(Text, { color: "red", children: `✗ ${entry.text}` }) }));
+            return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: [_jsx(Text, { bold: true, children: "\u2717 " }), entry.text] }) }));
         case "interrupted":
-            return (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "\u25FC interrupted" }) }));
+            return (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u25FC " }), _jsx(Text, { dimColor: true, children: "interrupted" })] }) }));
+        case "question":
+            if (entry.answer === null)
+                return null;
+            return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: `? ${entry.text}` }), _jsx(Text, { dimColor: true, children: `  › ${entry.answer || "(skipped)"}` })] }));
         case "system":
-            return (_jsx(Box, { children: _jsx(Text, { color: "gray", children: entry.text }) }));
+            return (_jsx(Box, { children: _jsx(Text, { color: "blue", children: entry.text }) }));
     }
 });

package/dist/tui/PromptOrCommandInput.js

@@ -32,6 +32,16 @@ export function PromptOrCommandInput({ commands, onCommand, onPrompt }) {
             setInput("");
         }
     }, { isActive: showMenu });
+    const visibleItems = useMemo(() => {
+        if (!showMenu || filtered.length === 0)
+            return { start: 0, items: [] };
+        const total = filtered.length;
+        const half = Math.floor(MAX_ITEMS / 2);
+        let start = Math.max(0, selectedIndex - half);
+        if (start + MAX_ITEMS > total)
+            start = Math.max(0, total - MAX_ITEMS);
+        return { start, items: filtered.slice(start, start + MAX_ITEMS) };
+    }, [showMenu, filtered, selectedIndex]);
     const onSubmit = (value) => {
         const text = value.trim();
         setInput("");
@@ -46,16 +56,8 @@ export function PromptOrCommandInput({ commands, onCommand, onPrompt }) {
         }
         onPrompt(text);
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [showMenu && filtered.length > 0 ? (_jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: (() => {
-                    const total = filtered.length;
-                    const half = Math.floor(MAX_ITEMS / 2);
-                    let start = Math.max(0, selectedIndex - half);
-                    if (start + MAX_ITEMS > total)
-                        start = Math.max(0, total - MAX_ITEMS);
-                    const visible = filtered.slice(start, start + MAX_ITEMS);
-                    return visible.map((cmd, i) => {
-                        const realIdx = start + i;
-                        return (_jsxs(Box, { children: [_jsxs(Text, { color: realIdx === selectedIndex ? "cyan" : undefined, children: [realIdx === selectedIndex ? "▸ " : "  ", "/", cmd.name] }), _jsxs(Text, { dimColor: true, children: ["  ", cmd.description] })] }, cmd.name));
-                    });
-                })() })) : null, _jsxs(Box, { borderStyle: "single", borderLeft: false, borderRight: false, borderColor: "gray", children: [_jsx(Text, { color: "gray", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [showMenu && filtered.length > 0 ? (_jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: visibleItems.items.map((cmd, i) => {
+                    const realIdx = visibleItems.start + i;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: realIdx === selectedIndex ? "cyan" : undefined, children: [realIdx === selectedIndex ? "▸ " : "  ", "/", cmd.name] }), _jsxs(Text, { dimColor: true, children: ["  ", cmd.description] })] }, cmd.name));
+                }) })) : null, _jsxs(Box, { borderStyle: "single", borderLeft: false, borderRight: false, borderColor: "gray", children: [_jsx(Text, { color: "gray", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit })] })] }));
 }

package/dist/tui/QuestionView.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+const CUSTOM_LABEL = "✎ Custom input";
+export function QuestionView({ question, onAnswer }) {
+    const hasOptions = question.options.length > 0;
+    const items = hasOptions ? [...question.options, CUSTOM_LABEL] : [];
+    const [selected, setSelected] = useState(0);
+    const [mode, setMode] = useState(hasOptions ? "select" : "input");
+    const [text, setText] = useState("");
+    useInput((input, key) => {
+        if (mode === "select") {
+            if (key.upArrow) {
+                setSelected((i) => (i <= 0 ? items.length - 1 : i - 1));
+            }
+            else if (key.downArrow) {
+                setSelected((i) => (i >= items.length - 1 ? 0 : i + 1));
+            }
+            else if (key.return) {
+                if (selected === items.length - 1)
+                    setMode("input");
+                else
+                    onAnswer(items[selected]);
+            }
+            else if (key.escape) {
+                onAnswer("");
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setText(input);
+                setMode("input");
+            }
+        }
+        else if (key.escape) {
+            if (hasOptions)
+                setMode("select");
+            else
+                onAnswer("");
+        }
+    });
+    if (mode === "input") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { color: "cyan", children: `? ${question.text}` }), _jsxs(Box, { borderStyle: "single", borderLeft: false, borderRight: false, borderColor: "gray", children: [_jsx(Text, { color: "gray", children: "\u276F " }), _jsx(TextInput, { value: text, onChange: setText, onSubmit: () => onAnswer(text) })] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { color: "cyan", children: `? ${question.text}` }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: items.map((item, i) => (_jsx(Box, { children: _jsxs(Text, { color: i === selected ? "cyan" : undefined, children: [i === selected ? "▸ " : "  ", item] }) }, item))) })] }));
+}

package/dist/tui/Spinner.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { Text } from "ink";
 import { timeDisplay, compactDisplay } from "../util/format.js";
@@ -9,5 +9,5 @@ export function Spinner({ label, elapsed, promptTokens, completionTokens, }) {
         const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
         return () => clearInterval(id);
     }, []);
-    return (_jsxs(Text, { color: "gray", children: [SPINNER_FRAMES[frame], " ", label, " \u00B7 ", timeDisplay(elapsed), " \u00B7 \u2191", compactDisplay(promptTokens), " \u00B7 \u2193", compactDisplay(completionTokens)] }));
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: SPINNER_FRAMES[frame] }), _jsxs(Text, { children: [" ", label] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", timeDisplay(elapsed), " \u00B7 \u2191", compactDisplay(promptTokens), " \u00B7 \u2193", compactDisplay(completionTokens)] })] }));
 }

package/dist/util/package.js

@@ -1,12 +1,12 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 const __dirname = import.meta.dirname;
 const MAX_PARENT_TRAVERSAL = 10;
 let _pkg = null;
 function findPackageJson() {
     let current = __dirname;
     for (let i = 0; i < MAX_PARENT_TRAVERSAL; i++) {
-        const pkgPath = join(current, 'package.json');
+        const pkgPath = join(current, "package.json");
         if (existsSync(pkgPath)) {
             return pkgPath;
         }
@@ -15,12 +15,12 @@ function findPackageJson() {
             break;
         current = parent;
     }
-    throw new Error('Cannot find package.json');
+    throw new Error("Cannot find package.json");
 }
 export function getPackageInfo() {
     if (_pkg === null) {
         const pkgPath = findPackageJson();
-        _pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        _pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     }
     return _pkg;
 }

package/dist/util/process.js

@@ -1,11 +1,17 @@
 import { spawn } from "node:child_process";
 const MAX_BUFFER = 10 * 1024 * 1024;
-export function runProcess(cmd, args, opts = {}) {
+export function runProcess(cmd, args, opts = {}, signal) {
     return new Promise((resolve) => {
         const child = spawn(cmd, args, {
             cwd: opts.cwd,
             stdio: ["ignore", "pipe", "pipe"],
         });
+        const onAbort = () => child.kill();
+        if (signal) {
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
         const outChunks = [];
         const errChunks = [];
         let size = 0;
@@ -21,8 +27,12 @@ export function runProcess(cmd, args, opts = {}) {
         child.stderr?.on("data", (c) => {
             errChunks.push(c);
         });
-        child.on("error", (error) => resolve({ stdout: "", stderr: "", status: null, error }));
+        child.on("error", (error) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve({ stdout: "", stderr: "", status: null, error });
+        });
         child.on("close", (status) => {
+            signal?.removeEventListener("abort", onAbort);
             const stdout = Buffer.concat(outChunks).toString("utf-8");
             const stderr = Buffer.concat(errChunks).toString("utf-8");
             resolve(overflow

package/dist/util/ripgrep.js

@@ -5,9 +5,9 @@ export function resolveCwd(path) {
     const root = path || ".";
     return isAbsolute(root) ? root : join(process.cwd(), root);
 }
-export async function runRgLines(args, cwd) {
-    const rgArgs = ["--hidden", "--path-separator", "/", "-g", "!.git/**", ...args];
-    const r = await runProcess(rgPath, rgArgs, { cwd });
+export async function runRgLines(args, cwd, signal) {
+    const rgArgs = ["--hidden", "--path-separator", "/", "-g", "!.git/**", "-g", "!node_modules/**", ...args];
+    const r = await runProcess(rgPath, rgArgs, { cwd }, signal);
     if (r.error)
         throw r.error;
     if (r.status !== 0 && r.status !== 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vietor/easy-agent",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
@@ -20,7 +20,7 @@
     "cli"
   ],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "packageManager": "pnpm@10.30.3",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",

package/dist/tui/LogStore.js

@@ -1,35 +0,0 @@
-export class LogStore {
-    entries = [];
-    listeners = new Set();
-    getSnapshot = () => this.entries;
-    subscribe = (listener) => {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    };
-    append(entry) {
-        this.entries = [...this.entries, entry];
-        this.emit();
-    }
-    clear() {
-        this.entries = [];
-        this.emit();
-    }
-    setToolResult(id, result, isError) {
-        for (let i = this.entries.length - 1; i >= 0; i--) {
-            const entry = this.entries[i];
-            if (entry.kind === "tool" && entry.id === id && entry.result === null) {
-                const copy = [...this.entries];
-                copy[i] = { ...entry, result, isError };
-                this.entries = copy;
-                this.emit();
-                return;
-            }
-        }
-    }
-    emit() {
-        for (const listener of this.listeners)
-            listener();
-    }
-}