@vietor/easy-agent 0.4.13 → 0.5.2

package/README.md

@@ -155,6 +155,7 @@ A status bar at the bottom shows the context token usage with a progress bar and
 - **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.
+- **SubAgent** — delegate investigation (`explore`), implementation-planning (`plan`), or full-tool execution (`generic`) subtasks to a nested sub-agent.
 
 ### Slash commands
 
@@ -163,6 +164,7 @@ A status bar at the bottom shows the context token usage with a progress bar and
 | `/mcp` | List linked MCP servers, their status, and exposed tools |
 | `/clear` | Reset the conversation |
 | `/compact` | Compress the conversation into a summary to free context |
+| `/skill` | List available skills |
 | `/export` | Save the current conversation to `conversation-{timestamp}.jsonl` |
 | `/quit` or `/exit` | Leave the app |
 

package/dist/commands/builtin.js

@@ -0,0 +1,85 @@
+import { writeFileSync } from "node:fs";
+export const clearCommand = {
+    name: "clear",
+    description: "Clear the conversation and log",
+    async execute(ctx) {
+        ctx.session.clear();
+    },
+};
+export const mcpCommand = {
+    name: "mcp",
+    description: "List linked MCP servers",
+    async execute(ctx) {
+        const servers = ctx.session.mcpServers;
+        const text = servers.length
+            ? [
+                "MCP servers:",
+                ...servers.map((s) => {
+                    const base = `❯ ${s.name} ⋅ ${s.type} ⋅ ${s.status} ∶ ${s.tools.join(", ") || "(no tools)"}`;
+                    return s.error ? `${base}\n  ${s.error}` : base;
+                }),
+            ].join("\n")
+            : "No MCP servers linked.";
+        ctx.message(text);
+    },
+};
+export const compactCommand = {
+    name: "compact",
+    description: "Compact the agent context",
+    async execute(ctx) {
+        await ctx.session.compact();
+    },
+};
+export const skillCommand = {
+    name: "skill",
+    description: "List available skills",
+    async execute(ctx) {
+        const skills = ctx.session.skills;
+        const text = skills.length
+            ? [
+                "Skills:",
+                ...skills.map((s) => `❯ ${s.name} ∶ ${s.description || "no description"}`),
+            ].join("\n")
+            : "No skills available.";
+        ctx.message(text);
+    },
+};
+export const exitCommand = {
+    name: "exit",
+    description: "Exit the conversation",
+    async execute(ctx) {
+        ctx.session.localStore.set("exitRequested", true);
+    },
+};
+export const exportCommand = {
+    name: "export",
+    description: "Export the conversation to a JSONL file",
+    async execute(ctx) {
+        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 = `conversation-${ts}.jsonl`;
+        const lines = ctx.session
+            .export()
+            .map((m) => JSON.stringify(m))
+            .join("\n");
+        writeFileSync(file, lines + "\n", "utf-8");
+        ctx.message(`exported to ${file}`);
+    },
+};
+export const quitCommand = {
+    name: "quit",
+    description: "Exit the conversation",
+    async execute(ctx) {
+        ctx.session.localStore.set("exitRequested", true);
+    },
+};
+export const builtinCommands = [
+    clearCommand,
+    mcpCommand,
+    compactCommand,
+    skillCommand,
+    exitCommand,
+    quitCommand,
+    exportCommand,
+];

package/dist/commands/dispatch.js

@@ -0,0 +1,34 @@
+import { errorMessage } from "@vietor/easy-agent-core";
+import { builtinCommands } from "./builtin.js";
+const commands = new Map(builtinCommands.map((c) => [c.name, c]));
+export async function executeCommand(name, session) {
+    const cmd = commands.get(name);
+    if (cmd) {
+        const ctx = { session, message: session.timelineNotice, error: session.timelineError };
+        try {
+            await cmd.execute(ctx);
+        }
+        catch (e) {
+            ctx.error(errorMessage(e));
+        }
+        return;
+    }
+    try {
+        if (await session.runSkill(name))
+            return;
+    }
+    catch (e) {
+        session.timelineError(errorMessage(e));
+        return;
+    }
+    session.timelineError(`unknown command: /${name}`);
+}
+export function commandSchemas(session) {
+    const map = new Map();
+    for (const c of builtinCommands)
+        map.set(c.name, { name: c.name, description: c.description });
+    for (const s of session.skills)
+        if (!map.has(s.name))
+            map.set(s.name, { name: s.name, description: s.description ?? s.name });
+    return [...map.values()];
+}

package/dist/commands/types.js

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

package/dist/config.js

@@ -3,30 +3,32 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 const CONFIG_FILE = ".easy-agent.json";
-const LLMConfig = z.object({
+const LLMConfigSchema = z.object({
     baseUrl: z.string(),
     apiKey: z.string(),
     model: z.string(),
     reasoningEffort: z.enum(["high", "max"]).default("high"),
     wireApi: z.enum(["completions", "anthropic"]).default("completions"),
+    contextWindow: z.number().int().positive().default(1_000_000),
 });
-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(),
+const MCPServerConfigSchema = z.union([
+    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(),
+    }),
+    z.object({
+        type: z.enum(["http"]),
+        url: z.string().url(),
+        headers: z.record(z.string(), z.string()).optional(),
+        enabled: z.boolean().optional(),
+    }),
+]);
+const ConfigSchema = z.object({
+    llm: LLMConfigSchema,
+    mcpServers: z.record(z.string(), MCPServerConfigSchema).optional(),
 });
 export function loadConfig() {
     const path = join(homedir(), CONFIG_FILE);
@@ -44,7 +46,7 @@ export function loadConfig() {
     catch {
         throw new Error(`Invalid JSON in ~/${CONFIG_FILE}.`);
     }
-    const result = Config.safeParse(parsed);
+    const result = ConfigSchema.safeParse(parsed);
     if (!result.success) {
         const issues = result.error.issues
             .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)

package/dist/main.js

@@ -1,13 +1,13 @@
+#!/usr/bin/env node
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "./config.js";
 import { tryLoadSkills, tryReadFileText, createSession, SYSTEM_PROMPT_BOUNDARY } from "@vietor/easy-agent-core";
-import { builtinCommands } from "./cmds/builtin.js";
-import { startApp } from "./tui/App.js";
+import { startApp } from "./tui/app.js";
 import { getPackageInfo } from "./util/package.js";
-import { FileSessionPersistence } from "./util/sessionStore.js";
+import { FileSessionPersistence } from "./util/session-store.js";
 function buildSystemPromptBase(cwd) {
     return [
         "You are Easy Agent, an autonomous assistant. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.",
@@ -18,8 +18,6 @@ function buildSystemPromptBase(cwd) {
         `Environment:
 - Platform: ${process.platform}
 - Working directory: ${cwd}`,
-        `Decision making:
-- When a decision belongs to the user, call AskUser and wait for the answer rather than listing options in prose. Ask when there are multiple reasonable approaches, an irreversible or consequential action, or the request is ambiguous; when you have enough to proceed, act without asking.`,
         `Working style:
 - Read relevant code/config before acting; do not guess implementation details or restate files from memory.
 - Make surgical changes and match existing style; do not refactor unrelated code.
@@ -84,20 +82,42 @@ export async function main(argv = []) {
         llmConfig: config.llm,
         mcpServers: config.mcpServers,
         skills: globalSkills,
-        commands: builtinCommands,
         builtinTools: {
             askUser: true,
             todoWrite: true,
+            skill: true,
+            subAgent: true,
         },
         cwd: cwd,
         sessionId,
         persistence: store,
     });
-    if (resume)
-        await session.restore();
+    if (resume) {
+        const restored = await session.restore();
+        if (!restored) {
+            console.error(`Session not found: ${sessionId}`);
+            process.exit(1);
+        }
+    }
+    let shuttingDown = false;
+    const shutdown = () => {
+        if (shuttingDown)
+            process.exit(1);
+        shuttingDown = true;
+        session.dispose();
+        session.flush().catch(() => { }).finally(() => process.exit(0));
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    process.stdout.write("");
     const app = startApp(session);
-    await app.waitUntilExit().finally(() => {
+    await app.waitUntilExit().finally(async () => {
         session.dispose();
+        await session.flush();
         console.log(["Resume this session with:", `easy-agent --resume ${sessionId}`].join("\n"));
     });
 }
+main(process.argv.slice(2)).catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/tui/{AppHeader.js → app-header.js}

@@ -4,7 +4,7 @@ import { Box, Text, useWindowSize } from "ink";
 import { getPackageInfo } from "../util/package.js";
 export const AppHeader = memo(function AppHeader({ cwd, model, reasoningEffort }) {
     const { columns } = useWindowSize();
-    const pkginfo = getPackageInfo();
+    const pkg = getPackageInfo();
     const reasoning = ` · reasoning ${reasoningEffort}`;
-    return (_jsxs(Box, { width: columns, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkginfo.version] })] }), _jsx(Text, { dimColor: true, children: `${model}${reasoning}` })] }), _jsx(Text, { dimColor: true, children: cwd })] }));
+    return (_jsxs(Box, { width: columns, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkg.version] })] }), _jsx(Text, { dimColor: true, children: `${model}${reasoning}` })] }), _jsx(Text, { dimColor: true, children: cwd })] }));
 });

package/dist/tui/{App.js → app.js}

@@ -1,47 +1,64 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Box, render, Text, useApp, useInput, useWindowSize } from "ink";
-import { Markdown } from "./components/Markdown.js";
-import { TimelineView } from "./TimelineView.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 { StatusBar } from "./StatusBar.js";
+import { createSessionRunState, errorMessage } from "@vietor/easy-agent-core";
+import { executeCommand, commandSchemas } from "../commands/dispatch.js";
+import { Markdown } from "./components/markdown.js";
+import { TimelineView } from "./timeline-view.js";
+import { TodoView } from "./todo-view.js";
+import { AppHeader } from "./app-header.js";
+import { PromptOrCommandInput } from "./prompt-or-command-input.js";
+import { QuestionView } from "./question-view.js";
+import { Spinner } from "./spinner.js";
+import { StatusBar } from "./status-bar.js";
 const STREAM_FRAME_MS = 120;
+function useThrottledText(frameMs) {
+    const [text, setText] = useState("");
+    const bufRef = useRef("");
+    const timerRef = useRef(undefined);
+    const append = (t) => {
+        bufRef.current += t;
+        if (timerRef.current === undefined) {
+            timerRef.current = setTimeout(() => {
+                timerRef.current = undefined;
+                setText(bufRef.current);
+            }, frameMs);
+        }
+    };
+    const reset = () => {
+        bufRef.current = "";
+        setText("");
+    };
+    return { text, append, reset };
+}
 export function App({ session }) {
     const { exit } = useApp();
     const { columns } = useWindowSize();
     const view = useSyncExternalStore(session.subscribe, session.getSnapshot);
-    const [runState, setRunState] = useState({ running: false, elapsed: 0, thinkingElapsed: 0, replyElapsed: 0, inputTokens: 0, outputTokens: 0 });
-    const [streamingText, setStreamingText] = useState("");
-    const streamingRef = useRef("");
-    const renderTimerRef = useRef(undefined);
-    const [reasoningText, setReasoningText] = useState("");
-    const reasoningRef = useRef("");
-    const reasoningRenderTimerRef = useRef(undefined);
+    const [runState, setRunState] = useState(createSessionRunState);
+    const streaming = useThrottledText(STREAM_FRAME_MS);
+    const reasoning = useThrottledText(STREAM_FRAME_MS);
     const [showReasoning, setShowReasoning] = useState(false);
-    const allCmds = useMemo(() => session.commandSchemas, [session]);
+    const allCmds = useMemo(() => commandSchemas(session), [session]);
     const pendingQuestion = session.getPendingQuestion();
     useEffect(() => {
         const unsub = session.subscribeEvents((e) => {
             switch (e.type) {
                 case "assistant_delta":
-                    streamingRef.current += e.text;
-                    scheduleStreamingRender();
+                    streaming.append(e.text);
                     break;
                 case "reasoning_delta":
-                    reasoningRef.current += e.text;
-                    scheduleReasoningRender();
+                    reasoning.append(e.text);
                     break;
                 case "reasoning_clear":
-                    reasoningRef.current = "";
-                    setReasoningText("");
+                    reasoning.reset();
                     break;
                 case "assistant":
-                    streamingRef.current = "";
-                    setStreamingText("");
+                    streaming.reset();
+                    break;
+                case "retry":
+                case "interrupted":
+                    streaming.reset();
                     break;
                 case "state":
                     setRunState(e);
@@ -50,29 +67,13 @@ export function App({ session }) {
         });
         return unsub;
     }, []);
-    const scheduleStreamingRender = () => {
-        if (renderTimerRef.current)
-            return;
-        renderTimerRef.current = setTimeout(() => {
-            renderTimerRef.current = undefined;
-            setStreamingText(streamingRef.current);
-        }, STREAM_FRAME_MS);
-    };
-    const scheduleReasoningRender = () => {
-        if (reasoningRenderTimerRef.current)
-            return;
-        reasoningRenderTimerRef.current = setTimeout(() => {
-            reasoningRenderTimerRef.current = undefined;
-            setReasoningText(reasoningRef.current);
-        }, STREAM_FRAME_MS);
-    };
     useInput((_input, key) => {
         if (pendingQuestion) {
             if (key.ctrl && _input === "c")
                 session.abort();
             return;
         }
-        if (_input === "t" && runState.running && reasoningText) {
+        if (_input === "t" && runState.running && reasoning.text) {
             setShowReasoning((v) => !v);
             return;
         }
@@ -86,13 +87,18 @@ export function App({ session }) {
                 exit();
         }
     });
-    async function handleCommand(name, args) {
-        await session.executeCommand(name, args);
+    async function handleCommand(name) {
+        await executeCommand(name, session);
         if (session.localStore.get("exitRequested") != null)
             exit();
     }
     async function handlePrompt(text) {
-        await session.startPrompt(text);
+        try {
+            await session.startPrompt(text);
+        }
+        catch (e) {
+            session.timelineError(errorMessage(e));
+        }
     }
     let runningView = null;
     if (runState.running) {
@@ -100,11 +106,11 @@ export function App({ session }) {
             runningView = (_jsx(QuestionView, { question: pendingQuestion, onAnswer: (ans) => session.submitAnswer(pendingQuestion.id, ans) }));
         }
         else {
-            const spinnerLabel = streamingText ? "replying" : "working";
-            runningView = (_jsxs(_Fragment, { children: [reasoningText ? renderReasoning(reasoningText, showReasoning) : null, streamingText ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, borderStyle: "single", borderTop: false, borderRight: false, borderBottom: false, borderColor: "gray", children: _jsx(Markdown, { children: streamingText }) })) : null, _jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: spinnerLabel, thinkingElapsed: runState.thinkingElapsed, replyElapsed: runState.replyElapsed, inputTokens: runState.inputTokens, outputTokens: runState.outputTokens }) })] }));
+            const spinnerLabel = streaming.text ? "replying" : "working";
+            runningView = (_jsxs(_Fragment, { children: [reasoning.text ? renderReasoning(reasoning.text, showReasoning) : null, streaming.text ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { children: streaming.text }) })) : null, _jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: spinnerLabel, thinkingElapsed: runState.thinkingElapsed, replyElapsed: runState.replyElapsed, inputTokens: runState.inputTokens, outputTokens: runState.outputTokens }) })] }));
         }
     }
-    return (_jsxs(Box, { width: columns, flexDirection: "column", children: [_jsx(AppHeader, { cwd: session.cwd, model: session.model, reasoningEffort: session.reasoningEffort }), view.timeline.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: view.timeline.map((entry, i) => (_jsx(TimelineView, { entry: entry }, i))) })) : null, runningView, view.todos.length > 0 ? _jsx(TodoView, { todos: view.todos }) : null, !runState.running ? (_jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })) : null, _jsx(StatusBar, { contextTokens: session.contextTokens, contextLimit: session.compactThreshold, running: runState.running, questionPending: !!pendingQuestion, reasoningAvailable: !!reasoningText })] }));
+    return (_jsxs(Box, { width: columns, flexDirection: "column", children: [_jsx(AppHeader, { cwd: session.cwd, model: session.model, reasoningEffort: session.reasoningEffort }), view.timeline.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: view.timeline.map((entry, i) => (_jsx(TimelineView, { entry: entry }, i))) })) : null, runningView, view.todos.length > 0 ? _jsx(TodoView, { todos: view.todos }) : null, !runState.running ? (_jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })) : null, _jsx(StatusBar, { contextTokens: session.contextTokens, contextLimit: session.compactThreshold, running: runState.running, questionPending: !!pendingQuestion, reasoningAvailable: !!reasoning.text })] }));
 }
 function renderReasoning(text, expanded) {
     const lines = text.split("\n");
@@ -116,6 +122,5 @@ function renderReasoning(text, expanded) {
     return (_jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsxs(Text, { dimColor: true, children: ["\u250A ", firstLine, extra, " (t to expand)"] }) }));
 }
 export function startApp(session) {
-    process.stdout.write("");
     return render(_jsx(App, { session: session }), { exitOnCtrlC: false, incrementalRendering: true });
 }

package/dist/tui/components/{Markdown.js → markdown.js}

@@ -37,36 +37,52 @@ function renderBlock(token) {
             return null;
     }
 }
-function renderInline(tokens) {
+function renderInline(tokens, mode = "react") {
     if (!tokens || tokens.length === 0)
-        return null;
-    return tokens.map((token, i) => {
+        return mode === "react" ? null : "";
+    const inner = (t) => renderInline(t, mode);
+    const out = tokens.map((token, i) => {
         const tok = token;
         switch (tok.type) {
-            case "text":
-                return _jsx(Text, { children: tok.tokens ? renderInline(tok.tokens) : tok.text }, i);
-            case "strong":
-                return _jsx(Text, { bold: true, children: renderInline(tok.tokens) }, i);
-            case "em":
-                return _jsx(Text, { italic: true, children: renderInline(tok.tokens) }, i);
+            case "text": {
+                const content = tok.tokens ? inner(tok.tokens) : tok.text;
+                return mode === "react" ? _jsx(Text, { children: content }, i) : content;
+            }
+            case "strong": {
+                const content = inner(tok.tokens);
+                return mode === "react" ? _jsx(Text, { bold: true, children: content }, i) : content;
+            }
+            case "em": {
+                const content = inner(tok.tokens);
+                return mode === "react" ? _jsx(Text, { italic: true, children: content }, i) : content;
+            }
             case "codespan":
-                return _jsx(Text, { color: "cyan", children: tok.text }, i);
-            case "del":
-                return _jsx(Text, { strikethrough: true, children: renderInline(tok.tokens) }, i);
-            case "link":
-                return _jsx(Text, { color: "blue", underline: true, children: renderInline(tok.tokens) }, i);
-            case "image":
-                return _jsx(Text, { color: "magenta", children: tok.text || tok.href }, i);
+                return mode === "react" ? _jsx(Text, { color: "cyan", children: tok.text }, i) : tok.text;
+            case "del": {
+                const content = inner(tok.tokens);
+                return mode === "react" ? _jsx(Text, { strikethrough: true, children: content }, i) : content;
+            }
+            case "link": {
+                const content = inner(tok.tokens);
+                return mode === "react" ? _jsx(Text, { color: "blue", underline: true, children: content }, i) : content;
+            }
+            case "image": {
+                const content = tok.text || tok.href;
+                return mode === "react" ? _jsx(Text, { color: "magenta", children: content }, i) : content;
+            }
             case "br":
-                return _jsx(Text, { children: "\n" }, i);
+                return mode === "react" ? _jsx(Text, { children: "\n" }, i) : "";
             case "escape":
-                return _jsx(Text, { children: tok.text }, i);
+                return mode === "react" ? _jsx(Text, { children: tok.text }, i) : tok.text;
             case "html":
-                return _jsx(Text, { dimColor: true, children: tok.text }, i);
+                return mode === "react" ? _jsx(Text, { dimColor: true, children: tok.text }, i) : tok.text;
             default:
-                return _jsx(Text, { children: tok.text ?? "" }, i);
+                return mode === "react"
+                    ? _jsx(Text, { children: tok.text ?? "" }, i)
+                    : tok.text ?? "";
         }
     });
+    return mode === "react" ? out : out.join("");
 }
 function renderList(token) {
     const markers = token.items.map((item, i) => {
@@ -87,14 +103,14 @@ function renderTable(token) {
     const natural = new Array(cols).fill(0);
     for (const row of [token.header, ...token.rows]) {
         for (let c = 0; c < cols; c++) {
-            const w = stringWidth(tokensToText(row[c].tokens));
+            const w = stringWidth(renderInline(row[c].tokens, "text"));
             if (w > natural[c])
                 natural[c] = w;
         }
     }
     const widths = fitWidths(natural, available);
     const renderRow = (row, bold = false) => {
-        const wrapped = row.map((tc, c) => wrapText(tokensToText(tc.tokens), widths[c]));
+        const wrapped = row.map((tc, c) => wrapText(renderInline(tc.tokens, "text"), widths[c]));
         const height = Math.max(1, ...wrapped.map(lines => lines.length));
         return Array.from({ length: height }, (_, r) => (_jsx(Text, { children: [
                 ...row.flatMap((_, c) => [
@@ -107,36 +123,6 @@ function renderTable(token) {
     const border = (l, m, r) => l + widths.map(w => "─".repeat(w + 2)).join(m) + r;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: border("┌", "┬", "┐") }), _jsx(Fragment, { children: renderRow(token.header, true) }), _jsx(Text, { dimColor: true, children: border("├", "┼", "┤") }), token.rows.map((row, i) => (_jsx(Fragment, { children: renderRow(row) }, i))), _jsx(Text, { dimColor: true, children: border("└", "┴", "┘") })] }));
 }
-function tokensToText(tokens) {
-    if (!tokens)
-        return "";
-    return tokens.map(tokenToText).join("");
-}
-function tokenToText(token) {
-    const t = token;
-    switch (t.type) {
-        case "text":
-            return t.tokens ? tokensToText(t.tokens) : t.text;
-        case "strong":
-        case "em":
-        case "del":
-            return tokensToText(t.tokens);
-        case "codespan":
-            return t.text;
-        case "link":
-            return tokensToText(t.tokens);
-        case "image":
-            return t.text || t.href;
-        case "br":
-            return "";
-        case "escape":
-            return t.text;
-        case "html":
-            return t.text;
-        default:
-            return t.text ?? "";
-    }
-}
 function padAlign(text, width, align) {
     const pad = Math.max(0, width - stringWidth(text));
     if (align === "right")

package/dist/tui/{PromptOrCommandInput.js → prompt-or-command-input.js}

@@ -45,20 +45,19 @@ export function PromptOrCommandInput({ commands, onCommand, onPrompt }) {
         if (!text)
             return;
         if (text.startsWith("/")) {
-            const [name, ...rest] = text.slice(1).split(/\s+/);
-            const args = rest.join(" ");
+            const name = text.slice(1).split(/\s+/)[0];
             if (filtered.length > 0) {
                 const cmd = filtered[selectedIndex];
-                onCommand(cmd ? cmd.name : name, args);
+                onCommand(cmd ? cmd.name : name);
             }
             else {
-                onCommand(name, args);
+                onCommand(name);
             }
             return;
         }
-        const [first, ...rest] = text.split(/\s+/);
+        const first = text.split(/\s+/)[0];
         if (commands.some((c) => c.name === first)) {
-            onCommand(first, rest.join(" "));
+            onCommand(first);
             return;
         }
         onPrompt(text);

package/dist/tui/{TimelineView.js → timeline-view.js}

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo, useEffect, useState } from "react";
 import { Box, Text } from "ink";
-import { Markdown } from "./components/Markdown.js";
+import { Markdown } from "./components/markdown.js";
 export const TimelineView = memo(function TimelineView({ entry }) {
     switch (entry.kind) {
         case "user":
@@ -22,7 +22,7 @@ export const TimelineView = memo(function TimelineView({ entry }) {
             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":
+        case "notice":
             return (_jsx(Box, { children: _jsx(Text, { color: "blue", children: entry.text }) }));
     }
 });

package/dist/tui/{TodoView.js → todo-view.js}

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo } from "react";
 import { Box, Text } from "ink";
-const ICONS = {
+const GLYPHS = {
     pending: "○",
     in_progress: "◐",
     completed: "✓",
@@ -14,5 +14,5 @@ const COLORS = {
 export const TodoView = memo(function TodoView({ todos }) {
     const done = todos.filter((t) => t.status === "completed").length;
     const headerColor = done === todos.length ? "green" : "cyan";
-    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray" }), _jsx(Text, { color: headerColor, children: `Tasks [${done}/${todos.length}]` }), todos.map((t, i) => (_jsx(Text, { color: COLORS[t.status], strikethrough: t.status === "completed", children: `${ICONS[t.status]} ${t.content}` }, i)))] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray" }), _jsx(Text, { color: headerColor, children: `Tasks [${done}/${todos.length}]` }), todos.map((t, i) => (_jsx(Text, { color: COLORS[t.status], strikethrough: t.status === "completed", children: `${GLYPHS[t.status]} ${t.content}` }, i)))] }));
 });

package/dist/util/{sessionStore.js → session-store.js}

@@ -1,12 +1,27 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFile, writeFile } from "node:fs/promises";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { ellipsisText, MAX_PREVIEW_LEN } from "@vietor/easy-agent-core";
 function encodeCwd(cwd) {
     return cwd.replace(/[\/\\:]/g, "-");
 }
+function parseJsonLines(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch { /* skip malformed lines */ }
+    }
+    return out;
+}
 export class FileSessionPersistence {
     cwd;
     dir;
+    writtenCounts = new Map();
     constructor(cwd) {
         this.cwd = cwd;
         this.dir = join(homedir(), ".easy-agent", "projects", encodeCwd(cwd));
@@ -24,30 +39,31 @@ export class FileSessionPersistence {
             return null;
         const messages = [];
         let todos = [];
-        for (const line of readFileSync(path, "utf-8").split("\n")) {
-            if (!line.trim())
-                continue;
-            let rec;
-            try {
-                rec = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const r = rec;
-            if (r.t === "m" && r.m)
+        for (const r of parseJsonLines(readFileSync(path, "utf-8"))) {
+            if (r.t === "message" && r.m)
                 messages.push(r.m);
             else if (r.t === "todo" && r.todos)
                 todos = r.todos;
         }
+        this.writtenCounts.set(sessionId, messages.length);
         return { messages, todos };
     }
     async saveAll(sessionId, state) {
         this.ensureDir();
+        const written = this.writtenCounts.get(sessionId) ?? 0;
+        const shrink = state.messages.length < written;
         const lines = state.messages
-            .map((m) => JSON.stringify({ t: "m", m }))
+            .slice(shrink ? 0 : written)
+            .map((m) => JSON.stringify({ t: "message", m }))
             .concat([JSON.stringify({ t: "todo", todos: state.todos })]);
-        writeFileSync(this.file(sessionId), lines.join("\n") + "\n", "utf-8");
+        const path = this.file(sessionId);
+        if (shrink) {
+            await writeFile(path, lines.join("\n") + "\n", "utf-8");
+        }
+        else {
+            await appendFile(path, lines.join("\n") + "\n", "utf-8");
+        }
+        this.writtenCounts.set(sessionId, state.messages.length);
     }
     async listSessions() {
         if (!existsSync(this.dir))
@@ -72,33 +88,15 @@ export class FileSessionPersistence {
         }
         return out.sort((a, b) => b.updatedAt - a.updatedAt);
     }
-    async delete(sessionId) {
-        const path = this.file(sessionId);
-        if (existsSync(path))
-            unlinkSync(path);
-    }
     readTitle(path) {
         const first = this.readFirstUser(path);
         if (!first)
             return undefined;
-        const oneline = first.replace(/\s+/g, " ").trim();
-        return oneline.length > 60 ? oneline.slice(0, 60) + "…" : oneline;
+        return ellipsisText(first, MAX_PREVIEW_LEN);
     }
     readFirstUser(path) {
-        for (const line of readFileSync(path, "utf-8").split("\n")) {
-            if (!line.trim())
-                continue;
-            let rec;
-            try {
-                rec = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const r = rec;
-            if (r.t === "m" && r.m && r.m.role === "user" && typeof r.m.content === "string")
-                return r.m.content;
-        }
-        return undefined;
+        const first = parseJsonLines(readFileSync(path, "utf-8"))
+            .find((r) => r.t === "message" && r.m && r.m.role === "user" && typeof r.m.content === "string");
+        return first?.m?.content;
     }
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@vietor/easy-agent",
-  "version": "0.4.13",
+  "version": "0.5.2",
   "type": "module",
-  "main": "dist/cli.js",
+  "main": "dist/main.js",
   "bin": {
-    "easy-agent": "dist/cli.js"
+    "easy-agent": "dist/main.js"
   },
   "files": [
     "dist"
@@ -23,7 +23,7 @@
     "react": "^19.2.8",
     "string-width": "^8.2.2",
     "zod": "^4.4.3",
-    "@vietor/easy-agent-core": "0.4.13"
+    "@vietor/easy-agent-core": "0.5.2"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",
@@ -42,7 +42,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/cli.ts",
-    "start": "node dist/cli.js"
+    "dev": "tsx src/main.ts",
+    "start": "node dist/main.js"
   }
 }

package/dist/cli.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { main } from "./main.js";
-main(process.argv.slice(2)).catch((e) => {
-    console.error(e);
-    process.exit(1);
-});

package/dist/cmds/builtin.js

@@ -1,29 +0,0 @@
-import { writeFileSync } from "node:fs";
-export const exitCommand = {
-    name: "exit",
-    description: "Exit the conversation",
-    async execute(ctx) {
-        ctx.session.localStore.set("exitRequested", true);
-    },
-};
-export const exportCommand = {
-    name: "export",
-    description: "Export the conversation to a JSONL file",
-    async execute(ctx) {
-        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 = `conversation-${ts}.jsonl`;
-        const lines = ctx.session
-            .export()
-            .map((m) => JSON.stringify(m))
-            .join("\n");
-        writeFileSync(file, lines + "\n", "utf-8");
-        ctx.message(`exported to ${file}`);
-    },
-};
-export const builtinCommands = [
-    exitCommand,
-    { ...exitCommand, name: "quit" },
-    exportCommand,
-];