@vietor/easy-agent 0.2.1 → 0.4.1

package/README.md

@@ -1,10 +1,6 @@
-# Easy Agent
+# @vietor/easy-agent
 
-![](https://img.shields.io/badge/Node.js-22%2B-brightgreen?style=flat-square) [![npm]](https://www.npmjs.com/package/@vietor/easy-agent)
-
-[npm]: https://img.shields.io/npm/v/@vietor/easy-agent.svg?style=flat-square
-
-An autonomous coding agent in the terminal.
+Terminal-based AI agent CLI with a conversational TUI, powered by `@vietor/easy-agent-core`.
 
 ## Requirements
 
@@ -12,7 +8,7 @@ An autonomous coding agent in the terminal.
 
 ## Install
 
-Install globally with npm:
+Install globally:
 
 ```bash
 npm install -g @vietor/easy-agent
@@ -31,18 +27,18 @@ Create `~/.easy-agent.json` in your home directory:
 ```json
 {
   "llm": {
-    "baseUrl": "https://api.example.com/v1",
+    "baseUrl": "https://api.openai.com/v1",
     "apiKey": "your-api-key",
-    "model": "your-model"
+    "model": "gpt-4o"
   }
 }
 ```
 
 `llm.baseUrl`, `llm.apiKey`, and `llm.model` are all required. Point `baseUrl` at any OpenAI-compatible endpoint (OpenAI, Azure OpenAI, local servers, etc.) and set `model` to a model that endpoint serves.
 
-### Optional: MCP servers
+### MCP servers (optional)
 
-Add an `mcpServers` map to expose external tools through the Model Context Protocol. Each entry spawns a local process (stdio transport):
+Add an `mcpServers` map to expose external tools through the Model Context Protocol. Each entry is either a local process (stdio) or a remote endpoint (Streamable HTTP):
 
 ```json
 {
@@ -50,28 +46,29 @@ Add an `mcpServers` map to expose external tools through the Model Context Proto
   "mcpServers": {
     "chrome-devtools": {
       "command": "npx",
-      "args": [
-        "chrome-devtools-mcp@latest",
-        "--auto-connect",
-        "--accept-insecure-certs"
-      ]
+      "args": ["chrome-devtools-mcp@latest", "--auto-connect", "--accept-insecure-certs"]
+    },
+    "api-server": {
+      "type": "http",
+      "url": "https://mcp.example.com/mcp",
+      "headers": { "Authorization": "Bearer your-token" }
     }
   }
 }
 ```
 
-Only `command` is required; `args` and `env` are optional. MCP tools become available to the agent as `MCP__<server>__<tool>`. If a server fails to connect within 30s, it is disabled and the error is shown in the TUI — the rest keep running.
+A stdio server omits `type` (or sets `"stdio"`); only `command` is required, `args` and `env` are optional. A remote server sets `type` to `"http"` with a required `url`; `headers` is optional and sent with every request (use it for static auth tokens). Either entry accepts an optional `enabled` (defaults to `true`); set `false` to keep a server configured but skip starting it. MCP tools become available to the agent as `MCP__<server>__<tool>`. If a server fails to connect within 30s, it is disabled and the error is shown in the TUI — for stdio servers the captured stderr tail is included to help diagnose startup failures — and the rest keep running.
 
-### Optional: Agent instructions
+### Agent instructions (optional)
 
 Easy Agent reads instructions files and appends them to the system prompt, so you can set persistent rules, conventions, or preferences. It looks in two places:
 
-1. **Global** — your home directory, applied to every session. Checks `~/.agents/AGENTS.md` first, then `~/.claude/CLAUDE.md`; uses the first one found.
+1. **Global** — your home directory, applied to every conversation. Checks `~/.agents/AGENTS.md` first, then `~/.claude/CLAUDE.md`; uses the first one found.
 2. **Project** — your current working directory, applied per-project. Checks `./AGENTS.md` first, then `./CLAUDE.md`; uses the first one found.
 
 Both global and project files are loaded and concatenated into the system prompt if they exist.
 
-### Optional: Skills
+### Skills (optional)
 
 Skills are reusable prompts that register themselves as slash commands. Create a subdirectory for each skill under `~/.agents/skills/` (or `~/.claude/skills/`) with a `SKILL.md` file:
 
@@ -104,22 +101,36 @@ Launch the TUI:
 easy-agent
 ```
 
-Type a prompt and press Enter. The agent streams its reply and calls tools as needed, showing each tool call and a one-line preview of its result. It iterates until the task is done (capped at 25 tool rounds per turn).
+Type a prompt and press Enter. The agent streams its reply and calls tools as needed, showing each tool call and a one-line preview of its result. It iterates until the task is done (capped at 50 tool rounds per turn).
 
-Built-in tools:
+### Built-in tools
 
 - **Shell** — run shell commands using this platform's native syntax.
-- **FileRead** — read a file's full contents.
+- **FileRead** — read a file with line numbers; supports `offset`/`limit` for paging large files.
 - **FileWrite** — create or fully overwrite a file.
-- **FileEdit** — replace one exact, unique match within a file.
+- **FileEdit** — replace exact matches in a file; `replace_all` for every occurrence.
 - **Glob** — list files, optionally filtered by a glob pattern.
-- **Grep** — search file contents by regex.
+- **Grep** — search file contents by regex with `glob`/`type` filters, context lines, case-insensitive, and `files_with_matches`/`count` output modes.
 - **WebFetch** — fetch a URL as markdown or text.
+- **AskUser** — ask the user a question and wait for their answer.
+- **TodoWrite** — track multi-step work as a task list (pending / in_progress / completed), shown live as a panel in the TUI.
+
+### Slash commands
 
-Slash commands:
+| Command | Description |
+|---------|-------------|
+| `/mcp` | List linked MCP servers, their status, and exposed tools |
+| `/clear` | Reset the conversation |
+| `/compact` | Compress the conversation into a summary to free context |
+| `/export` | Save the current conversation to `conversation-{timestamp}.jsonl` |
+| `/quit` or `/exit` | Leave the app |
 
-- `/mcp` — list linked MCP servers, their status, and exposed tools.
-- `/clear` — reset the conversation.
-- `/compact` — compress the conversation into a summary to free context.
-- `/export` — save the current session to `session-{timestamp}.jsonl`.
-- `/quit` or `/exit` — leave the app.
+## Build from source
+
+```bash
+git clone <repo-url>
+cd easy-agent
+pnpm install
+pnpm build                 # build core → CLI
+pnpm --filter @vietor/easy-agent dev   # hot-reload dev mode
+```

package/dist/cmds/builtin.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from "node:fs";
 export const exitCommand = {
     name: "exit",
-    description: "Exit the session",
+    description: "Exit the conversation",
     async execute(_ctx, host) {
         host.exit();
     },
@@ -9,9 +9,8 @@ export const exitCommand = {
 export const clearCommand = {
     name: "clear",
     description: "Clear the conversation and log",
-    async execute(ctx, host) {
-        ctx.agent.clear();
-        host.clearLog();
+    async execute(ctx) {
+        ctx.session.clear();
     },
 };
 export const mcpCommand = {
@@ -22,7 +21,7 @@ export const mcpCommand = {
         const text = servers.length
             ? [
                 "MCP servers:",
-                ...servers.map((s) => `❯ ${s.name} ⋅ ${s.status} ∶ ${s.tools.join(", ") || "(no tools)"}`),
+                ...servers.map((s) => `❯ ${s.name} ⋅ ${s.type} ⋅ ${s.status} ∶ ${s.tools.join(", ") || "(no tools)"}`),
             ].join("\n")
             : "No MCP servers linked.";
         host.info(text);
@@ -34,8 +33,9 @@ export const compactCommand = {
     async execute(ctx, host) {
         host.thinking(true);
         try {
-            await ctx.agent.compact();
-            host.info("context compacted");
+            const ok = await ctx.session.compact();
+            if (ok)
+                host.info("context compacted");
         }
         catch (e) {
             host.error(e.message);
@@ -47,14 +47,14 @@ export const compactCommand = {
 };
 export const exportCommand = {
     name: "export",
-    description: "Export the session to a JSONL file",
+    description: "Export the conversation to a JSONL file",
     async execute(ctx, host) {
         try {
             const d = new Date();
             const pad = (n) => String(n).padStart(2, "0");
             const ts = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-            const file = `session-${ts}.jsonl`;
-            const lines = ctx.agent
+            const file = `conversation-${ts}.jsonl`;
+            const lines = ctx.session
                 .export()
                 .map((m) => JSON.stringify(m))
                 .join("\n");
@@ -66,3 +66,11 @@ export const exportCommand = {
         }
     },
 };
+export const builtinCommands = [
+    exitCommand,
+    { ...exitCommand, name: "quit" },
+    clearCommand,
+    mcpCommand,
+    compactCommand,
+    exportCommand,
+];

package/dist/config.js

@@ -8,19 +8,41 @@ const LLMConfig = z.object({
     apiKey: z.string(),
     model: z.string(),
 });
-const MCPServerConfig = z.object({
+const StdioServerConfig = z.object({
+    type: z.literal("stdio").optional(),
     command: z.string(),
     args: z.array(z.string()).optional(),
     env: z.record(z.string(), z.string()).optional(),
+    enabled: z.boolean().optional(),
 });
+const RemoteServerConfig = z.object({
+    type: z.enum(["http"]),
+    url: z.string().url(),
+    headers: z.record(z.string(), z.string()).optional(),
+    enabled: z.boolean().optional(),
+});
+const MCPServerConfig = z.union([StdioServerConfig, RemoteServerConfig]);
 const Config = z.object({
     llm: LLMConfig,
     mcpServers: z.record(z.string(), MCPServerConfig).optional(),
 });
 export function loadConfig() {
     const path = join(homedir(), CONFIG_FILE);
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
-    const result = Config.safeParse(raw);
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        throw new Error(`Config not found: create ~/${CONFIG_FILE} (see README for format).`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ~/${CONFIG_FILE}.`);
+    }
+    const result = Config.safeParse(parsed);
     if (!result.success) {
         const issues = result.error.issues
             .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)

package/dist/main.js

@@ -1,61 +1,35 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadConfig } from "./config.js";
-import { LLMClient } from "./llm/client.js";
-import { Session } from "./core/session.js";
-import { Agent } from "./core/agent.js";
-import { ToolRegistry, registerBuiltinTools } from "./tools/registry.js";
-import { CommandRegistry, registerBuiltinCommands } from "./cmds/registry.js";
-import { tryLoadSkills } from "./skills/loader.js";
-import { tryReadFileText, readFirstFileContent } from "./util/fs.js";
-import { MCPServers } from "./mcp/server.js";
+import { tryLoadSkills, tryReadFileText, readFirstFileContent, startSession, } from "@vietor/easy-agent-core";
+import { builtinCommands } from "./cmds/builtin.js";
 import { startApp } from "./tui/App.js";
-const SYSTEM_PROMPT_BASE = `You are Easy Agent, an autonomous coding assistant running in the terminal. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.
-
-Environment:
-- Platform: ${process.platform}
-- Working directory: ${process.cwd()}
-
-Tool use:
-- Prefer dedicated tools (FileRead, FileEdit, Glob, Grep) over the Shell tool when they fit the task.
-- Read a file before editing it; make minimal, surgical changes that match the surrounding code style.
-- Reference code as file_path:line_number.
-
-Output:
-- Be concise and use GitHub-flavored markdown.
-- State what you did and stop once the task is complete. Report outcomes faithfully, and do not narrate alternatives you will not pursue.`;
+const SYSTEM_PROMPT_BASE = [
+    "You are Easy Agent, an autonomous assistant. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.",
+    `Output:
+- Be concise and use GitHub-flavored markdown.
+- State what you did and stop once the task is complete; report outcomes faithfully.
+- Do not lay out alternative approaches in prose - if a choice is the user's, use AskUser.`,
+].join("\n\n");
 export async function main() {
     const config = loadConfig();
-    const llm = new LLMClient(config.llm);
-    const tools = new ToolRegistry();
-    registerBuiltinTools(tools);
-    const commands = new CommandRegistry();
-    registerBuiltinCommands(commands);
-    const mcp = new MCPServers();
-    mcp
-        .connect(config.mcpServers)
-        .then((list) => {
-        for (const t of list)
-            tools.register(t);
-    })
-        .catch((e) => mcp.report(`MCP connect failed: ${e.message}`));
     const globalSkills = readFirstFileContent([join(homedir(), ".agents", "skills"), join(homedir(), ".claude", "skills")], tryLoadSkills);
-    if (globalSkills) {
-        globalSkills.forEach((skill) => commands.register({
-            name: skill.name,
-            description: skill.description ?? skill.name,
-            execute: async (_, host) => {
-                await host.runSkill(skill);
-            },
-        }));
-    }
     const globalPrompt = readFirstFileContent([join(homedir(), ".agents", "AGENTS.md"), join(homedir(), ".claude", "CLAUDE.md")], tryReadFileText);
     const projectPrompt = readFirstFileContent([join(process.cwd(), "AGENTS.md"), join(process.cwd(), "CLAUDE.md")], tryReadFileText);
     const systemPrompt = [SYSTEM_PROMPT_BASE, globalPrompt, projectPrompt]
         .filter(Boolean)
         .join("\n\n=================\n\n");
-    const session = new Session(systemPrompt);
-    const agent = new Agent(llm, session, tools);
-    const app = startApp(agent, commands, mcp);
-    await app.waitUntilExit().finally(() => mcp.kill());
+    const session = await startSession({
+        systemPrompt,
+        llmConfig: config.llm,
+        mcpServers: config.mcpServers,
+        skills: globalSkills,
+        commands: builtinCommands,
+        enableTools: {
+            askUser: true,
+            todoWrite: true
+        }
+    });
+    const app = startApp(session);
+    await app.waitUntilExit().finally(() => session.dispose());
 }

package/dist/tui/App.js

@@ -2,151 +2,86 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 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 { LogList } from "./LogList.js";
+import { TodoView } from "./TodoView.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 }) {
+const STREAM_FRAME_MS = 120;
+export function App({ session }) {
     const { exit } = useApp();
-    const [store] = useState(() => new LogStore());
-    const log = useSyncExternalStore(store.subscribe, store.getSnapshot);
-    const [status, setStatus] = useState("idle");
-    const [, setTick] = useState(0);
+    const version = useSyncExternalStore(session.subscribe, session.getSnapshot);
+    const [running, setRunning] = useState(false);
+    const [runElapsed, setRunElapsed] = useState(0);
+    const [runUsage, setRunUsage] = useState({ prompt: 0, completion: 0 });
+    const [streamingText, setStreamingText] = useState("");
     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 = useMemo(() => session.logEntries.find((e) => e.kind === "question" && e.answer === null), [session, version]);
     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),
+            onRunElapsedChange: (s) => setRunElapsed(s),
+            onRunUsageChange: (p, c) => setRunUsage({ 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);
+            setStreamingText(streamingRef.current);
         }, 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));
+    let runningView = null;
+    if (running) {
+        if (pendingQuestion) {
+            runningView = (_jsx(QuestionView, { question: pendingQuestion, onAnswer: (ans) => session.submitAnswer(pendingQuestion.id, ans) }));
+        }
+        else if (streamingText) {
+            runningView = (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { color: "green", children: streamingText }) }));
+        }
+        else {
+            runningView = (_jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: "thinking", elapsed: runElapsed, promptTokens: runUsage.prompt, completionTokens: runUsage.completion }) }));
+        }
     }
-    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, {}), _jsx(LogList, { session: session }), session.todos.length > 0 ? _jsx(TodoView, { todos: session.todos }) : null, runningView, !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, incrementalRendering: true });
 }

package/dist/tui/AppHeader.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
 import { Box, Text } from "ink";
-import { getPackageInfo } from "../util/package.js";
-export function AppHeader() {
+import { getPackageInfo } from "@vietor/easy-agent-core";
+export const AppHeader = memo(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", 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() })] }));
+});

package/dist/tui/LogList.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useSyncExternalStore } from "react";
+import { Box } from "ink";
+import { LogView } from "./LogView.js";
+export const LogList = memo(function LogList({ session }) {
+    useSyncExternalStore(session.subscribe, session.getSnapshot);
+    const entries = session.logEntries;
+    return (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: entries.map((entry, i) => (_jsx(LogView, { entry: entry }, i))) }));
+});

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

@@ -16,10 +16,7 @@ export function PromptOrCommandInput({ commands, onCommand, onPrompt }) {
     }, [showMenu, prefix, commands]);
     const [selectedIndex, setSelectedIndex] = useState(0);
     useEffect(() => {
-        if (filtered.length > 0 && selectedIndex === -1)
-            setSelectedIndex(0);
-        else if (selectedIndex >= filtered.length)
-            setSelectedIndex(Math.max(0, filtered.length - 1));
+        setSelectedIndex((prev) => Math.max(0, Math.min(prev, Math.max(0, filtered.length - 1))));
     }, [filtered.length]);
     useInput((_input, key) => {
         if (key.upArrow) {
@@ -32,6 +29,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 +53,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 })] })] }));
 }