@vietor/easy-agent 0.2.1 → 0.4.1

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/tui/TodoView.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Box, Text } from "ink";
+const ICONS = {
+    pending: "○",
+    in_progress: "◐",
+    completed: "✓",
+};
+const COLORS = {
+    pending: "gray",
+    in_progress: "yellow",
+    completed: "green",
+};
+export const TodoView = memo(function TodoView({ todos }) {
+    if (todos.length === 0)
+        return null;
+    const done = todos.filter((t) => t.status === "completed").length;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { dimColor: true, 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)))] }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vietor/easy-agent",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
@@ -9,40 +9,37 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc",
-    "start": "tsc && node dist/cli.js",
-    "dev": "tsx src/cli.ts",
-    "prepublishOnly": "tsc"
+  "description": "Terminal-based AI agent CLI with conversational TUI (Ink/React) powered by easy-agent-core",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vietor/easy-agent.git"
   },
-  "keywords": [
-    "ai",
-    "cli"
-  ],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.30.3",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@vscode/ripgrep": "^1.18.0",
-    "htmlparser2": "^12.0.0",
     "ink": "^7.1.0",
     "ink-text-input": "^6.0.0",
     "marked": "^18.0.5",
-    "openai": "^6.45.0",
     "react": "^19.2.7",
     "string-width": "^8.2.1",
-    "turndown": "^7.2.4",
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "@vietor/easy-agent-core": "0.4.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/react": "^19.2.17",
-    "@types/turndown": "^5.0.6",
     "tsx": "^4.23.0",
     "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">=22.0.0"
+  },
+  "keywords": [
+    "ai",
+    "cli"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js"
   }
-}
+}

package/dist/cmds/registry.js

@@ -1,30 +0,0 @@
-import { exitCommand, clearCommand, mcpCommand, compactCommand, exportCommand } from "./builtin.js";
-export class CommandRegistry {
-    commands = new Map();
-    register(command) {
-        this.commands.set(command.name, command);
-    }
-    schemas() {
-        return [...this.commands.values()].map((t) => ({
-            name: t.name,
-            description: t.description,
-        }));
-    }
-    exists(name) {
-        return this.commands.has(name);
-    }
-    async execute(command, ctx, host) {
-        const cmd = this.commands.get(command);
-        if (!cmd) {
-            host.error(`unknown command: /${command}`);
-            return;
-        }
-        await cmd.execute(ctx, host);
-    }
-}
-export function registerBuiltinCommands(commands) {
-    commands.register(exitCommand);
-    commands.register({ ...exitCommand, name: "quit" });
-    for (const t of [clearCommand, mcpCommand, compactCommand, exportCommand])
-        commands.register(t);
-}

package/dist/cmds/types.js

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

package/dist/core/agent.js

@@ -1,116 +0,0 @@
-import { withAbort } from "../util/async.js";
-const STALL_THRESHOLD = 3;
-const COMPACT_PROMPT = "Summarize this conversation into a concise context summary. Preserve the user's goal, decisions made, files touched, and current progress. Write the summary in the same language the user used in the conversation. Begin your reply with \"Summary of conversation so far:\".";
-export class Agent {
-    llm;
-    session;
-    tools;
-    constructor(llm, session, tools) {
-        this.llm = llm;
-        this.session = session;
-        this.tools = tools;
-    }
-    get contextTokens() {
-        return this.session.getEstimatedTokens();
-    }
-    clear() {
-        this.session.clear();
-    }
-    export() {
-        return this.session.export();
-    }
-    async compact() {
-        const history = this.session.toLLM().slice(1);
-        if (history.length === 0)
-            return;
-        const request = [
-            ...history,
-            { role: "user", content: COMPACT_PROMPT },
-        ];
-        const msg = await this.llm.chat(request, []);
-        this.session.compact(msg.content || "");
-    }
-    async run(userInput, onEvent, signal) {
-        this.session.createCheckpoint();
-        try {
-            this.session.add({ role: "user", content: userInput });
-            await this.loop(onEvent, signal);
-        }
-        finally {
-            this.session.removeCheckpoint();
-        }
-    }
-    async runSkill(skill, onEvent, signal) {
-        this.session.createCheckpoint();
-        try {
-            this.session.add({ role: "skill", name: skill.name, content: skill.prompt });
-            await this.loop(onEvent, signal);
-        }
-        finally {
-            this.session.removeCheckpoint();
-        }
-    }
-    async loop(onEvent, signal) {
-        await withAbort(async (aborted) => {
-            let lastSig = "";
-            let stall = 0;
-            while (true) {
-                let msg;
-                try {
-                    msg = await this.llm.chat(this.session.toLLM(), this.tools.schemas(), (text) => onEvent?.({ type: "delta", text }), (attempt, max) => onEvent?.({ type: "retry", attempt, max }), (promptTokens, completionTokens) => onEvent?.({ type: "usage", promptTokens, completionTokens }), signal);
-                }
-                catch (e) {
-                    if (aborted())
-                        return;
-                    onEvent?.({ type: "error", text: e.message });
-                    return;
-                }
-                this.session.add(msg);
-                if (!msg.tool_calls?.length)
-                    return;
-                if (aborted())
-                    return;
-                const sig = msg.tool_calls
-                    .map((c) => `${c.function.name}:${c.function.arguments}`)
-                    .join("|");
-                stall = sig === lastSig ? stall + 1 : 1;
-                lastSig = sig;
-                if (stall >= STALL_THRESHOLD) {
-                    onEvent?.({ type: "error", text: "agent stalled: repeated identical tool calls" });
-                    return;
-                }
-                await Promise.all(msg.tool_calls.map(async (call) => {
-                    let args = {};
-                    let argsError = "";
-                    if (call.function.arguments) {
-                        try {
-                            args = JSON.parse(call.function.arguments);
-                        }
-                        catch (e) {
-                            argsError = `Error: invalid arguments: ${e.message}`;
-                        }
-                    }
-                    const summary = this.tools.summarize(call.function.name, args);
-                    onEvent?.({ type: "tool_start", id: call.id, name: call.function.name, summary });
-                    if (aborted())
-                        return;
-                    const result = argsError
-                        ? { content: argsError, isError: true }
-                        : await this.tools.execute(call.function.name, args);
-                    if (aborted())
-                        return;
-                    onEvent?.({ type: "tool_end", id: call.id, name: call.function.name, result: result.content, isError: result.isError });
-                    this.session.add({ role: "tool", tool_call_id: call.id, content: result.content });
-                }));
-                if (aborted())
-                    return;
-            }
-        }, {
-            signal,
-            onAbort: () => {
-                this.session.restoreCheckpoint();
-                onEvent?.({ type: "interrupted" });
-            },
-        });
-    }
-}

package/dist/core/session.js

@@ -1,75 +0,0 @@
-function estimateTokens(text) {
-    if (!text)
-        return 0;
-    const cjk = (text.match(/[一-龥぀-ヿ가-힯]/g) || []).length;
-    const words = (text.match(/[a-zA-Z0-9']+/g) || []).length;
-    return Math.ceil(cjk * 1.6 + words * 1.3 + (text.length - cjk) * 0.3);
-}
-function messageText(msg) {
-    const parts = [];
-    if (typeof msg.content === "string")
-        parts.push(msg.content);
-    else if (Array.isArray(msg.content)) {
-        for (const p of msg.content) {
-            if (p.type === "text")
-                parts.push(p.text);
-        }
-    }
-    if ("tool_calls" in msg && msg.tool_calls) {
-        for (const tc of msg.tool_calls) {
-            if (tc.function?.name)
-                parts.push(tc.function.name);
-            if (tc.function?.arguments)
-                parts.push(tc.function.arguments);
-        }
-    }
-    return parts.join(" ");
-}
-export class Session {
-    system;
-    messages = [];
-    estimatedTokens = 0;
-    checkpoint;
-    checkpointTokens = 0;
-    constructor(system) {
-        this.system = system;
-        this.messages.push({ role: "system", content: system });
-        this.estimatedTokens = estimateTokens(system);
-    }
-    getEstimatedTokens() {
-        return this.estimatedTokens;
-    }
-    add(msg) {
-        this.messages.push(msg);
-        this.estimatedTokens += estimateTokens(messageText(msg));
-    }
-    toLLM() {
-        return this.messages.map((m) => (m.role === "skill" ? { role: "user", name: m.name, content: m.content } : m));
-    }
-    export() {
-        return this.messages.slice(1);
-    }
-    clear() {
-        this.messages = [{ role: "system", content: this.system }];
-        this.estimatedTokens = estimateTokens(this.system);
-    }
-    compact(summary) {
-        this.messages = [
-            { role: "system", content: this.system },
-            { role: "assistant", content: summary },
-        ];
-        this.estimatedTokens = estimateTokens(this.system) + estimateTokens(summary);
-    }
-    createCheckpoint() {
-        this.checkpoint = this.messages.slice();
-        this.checkpointTokens = this.estimatedTokens;
-    }
-    restoreCheckpoint() {
-        this.messages = this.checkpoint.slice();
-        this.estimatedTokens = this.checkpointTokens;
-    }
-    removeCheckpoint() {
-        this.checkpoint = undefined;
-        this.checkpointTokens = 0;
-    }
-}

package/dist/llm/client.js

@@ -1,74 +0,0 @@
-import OpenAI, { APIConnectionError } from "openai";
-import { withRetry } from "../util/async.js";
-const MAX_RETRIES = 3;
-export class LLMClient {
-    client;
-    model;
-    constructor(config) {
-        this.client = new OpenAI({
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl || undefined,
-            maxRetries: 0,
-        });
-        this.model = config.model;
-    }
-    async chat(messages, tools, onDelta, onRetry, onUsage, signal) {
-        return withRetry(() => this.streamOnce(messages, tools, onDelta, onUsage, signal), {
-            retries: MAX_RETRIES,
-            retryable: (e) => e instanceof APIConnectionError,
-            backoff: (attempt) => 1000 * 2 ** attempt,
-            onRetry,
-            signal,
-        });
-    }
-    async streamOnce(messages, tools, onDelta, onUsage, signal) {
-        let content = "";
-        const calls = new Map();
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            messages,
-            tools,
-            stream: true,
-            stream_options: { include_usage: true },
-        }, { signal });
-        for await (const chunk of stream) {
-            if (chunk.usage) {
-                onUsage?.(chunk.usage.prompt_tokens ?? 0, chunk.usage.completion_tokens ?? 0);
-            }
-            const delta = chunk.choices[0]?.delta;
-            if (!delta)
-                continue;
-            if (delta.content) {
-                content += delta.content;
-                onDelta?.(delta.content);
-            }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    let acc = calls.get(tc.index);
-                    if (!acc) {
-                        acc = { id: tc.id ?? "", name: "", arguments: "" };
-                        calls.set(tc.index, acc);
-                    }
-                    if (tc.function?.name)
-                        acc.name += tc.function.name;
-                    if (tc.function?.arguments)
-                        acc.arguments += tc.function.arguments;
-                }
-            }
-        }
-        const message = {
-            role: "assistant",
-            content: content || null,
-        };
-        if (calls.size) {
-            message.tool_calls = [...calls.entries()]
-                .sort((a, b) => a[0] - b[0])
-                .map(([, acc]) => ({
-                id: acc.id,
-                type: "function",
-                function: { name: acc.name, arguments: acc.arguments },
-            }));
-        }
-        return message;
-    }
-}

package/dist/llm/types.js

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

package/dist/mcp/client.js

@@ -1,45 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { getPackageInfo } from "../util/package.js";
-function getClientINfo() {
-    const pkginfo = getPackageInfo();
-    return { name: pkginfo.name, version: pkginfo.version };
-}
-export class MCPClient {
-    name;
-    client = new Client(getClientINfo(), { capabilities: {} });
-    transport;
-    connectReject;
-    constructor(name, config) {
-        this.name = name;
-        this.transport = new StdioClientTransport({ ...config, stderr: "ignore" });
-    }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            this.connectReject = reject;
-            this.client
-                .connect(this.transport)
-                .then(resolve, reject)
-                .finally(() => {
-                this.connectReject = undefined;
-            });
-        });
-    }
-    async listTools() {
-        return this.client.listTools().then((r) => r.tools);
-    }
-    async callTool(name, args) {
-        return this.client.callTool({ name, arguments: args });
-    }
-    kill() {
-        this.connectReject?.(new Error("aborted"));
-        this.connectReject = undefined;
-        const pid = this.transport.pid;
-        if (pid) {
-            try {
-                process.kill(pid, "SIGTERM");
-            }
-            catch { }
-        }
-    }
-}

package/dist/mcp/server.js

@@ -1,85 +0,0 @@
-import { MCPClient } from "./client.js";
-import { withTimeout } from "../util/async.js";
-const CONNECT_TIMEOUT = 30_000;
-function fixError(text) {
-    return text.startsWith("Error: ") ? text : `Error: ${text}`;
-}
-export class MCPServers {
-    servers = new Map();
-    pending = new Set();
-    disposed = false;
-    errorBuffer = [];
-    onError;
-    report(msg) {
-        if (this.onError)
-            this.onError(msg);
-        else
-            this.errorBuffer.push(msg);
-    }
-    flushErrors() {
-        const buf = this.errorBuffer;
-        this.errorBuffer = [];
-        return buf;
-    }
-    async connect(mcpServers = {}) {
-        const tools = [];
-        await Promise.all(Object.entries(mcpServers).map(async ([name, cfg]) => {
-            if (this.disposed)
-                return;
-            const client = new MCPClient(name, cfg);
-            this.pending.add(client);
-            try {
-                await withTimeout(client.connect(), CONNECT_TIMEOUT);
-                if (this.disposed) {
-                    client.kill();
-                    return;
-                }
-                const mcpTools = await withTimeout(client.listTools(), CONNECT_TIMEOUT);
-                if (this.disposed) {
-                    client.kill();
-                    return;
-                }
-                this.servers.set(name, { status: "connected", client, tools: mcpTools.map((t) => t.name) });
-                for (const t of mcpTools)
-                    tools.push(this.adapt(name, client, t));
-            }
-            catch (e) {
-                client.kill();
-                if (!this.disposed) {
-                    this.servers.set(name, { status: "disabled", tools: [] });
-                    this.report(`MCP server "${name}" failed: ${e.message}`);
-                }
-            }
-            finally {
-                this.pending.delete(client);
-            }
-        }));
-        return tools;
-    }
-    adapt(server, client, tool) {
-        return {
-            name: `MCP__${server}__${tool.name}`,
-            description: tool.description ?? `${server} ${tool.name}`,
-            parameters: tool.inputSchema,
-            async execute(args) {
-                const result = await client.callTool(tool.name, args);
-                const text = result.content.map((c) => (c.type === "text" ? c.text : "")).join("\n");
-                return result.isError
-                    ? { content: fixError(text), isError: true }
-                    : { content: text || "(no output)" };
-            },
-        };
-    }
-    list() {
-        return [...this.servers.entries()].map(([name, s]) => ({ name, status: s.status, tools: s.tools }));
-    }
-    kill() {
-        this.disposed = true;
-        for (const { client } of this.servers.values())
-            client?.kill();
-        for (const client of this.pending)
-            client.kill();
-        this.servers.clear();
-        this.pending.clear();
-    }
-}

package/dist/skills/loader.js

@@ -1,43 +0,0 @@
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { tryReadFileText } from "../util/fs.js";
-function parseSkillFile(skillName, skillFile) {
-    const content = tryReadFileText(skillFile);
-    if (!content)
-        return undefined;
-    const frontMatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
-    const match = content.match(frontMatterRegex);
-    let name = null;
-    let description = "";
-    let prompt = content;
-    if (match) {
-        const yamlBody = match[1];
-        prompt = content.replace(match[0], "").trim();
-        const nameMatch = yamlBody.match(/^name:\s*(.+)$/m);
-        if (nameMatch)
-            name = nameMatch[1].trim();
-        const descMatch = yamlBody.match(/^description:\s*(.+)$/m);
-        if (descMatch)
-            description = descMatch[1].trim();
-    }
-    if (!name) {
-        name = skillName;
-    }
-    return { name, description, prompt };
-}
-export function tryLoadSkills(path) {
-    if (!existsSync(path))
-        return undefined;
-    const skills = [];
-    for (const entry of readdirSync(path, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        const skillFile = join(path, entry.name, "SKILL.md");
-        if (!existsSync(skillFile))
-            continue;
-        const skill = parseSkillFile(entry.name, skillFile);
-        if (skill && skill.prompt)
-            skills.push(skill);
-    }
-    return skills.length > 0 ? skills : undefined;
-}

package/dist/skills/types.js

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

package/dist/tools/file_edit.js

@@ -1,39 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-const DESCRIPTION = [
-    "Replace the single occurrence of old_string with new_string in a file.",
-    "old_string must match exactly (including whitespace and indentation) and appear exactly once; read the file first and include enough surrounding context to be unique.",
-    "For full rewrites prefer FileWrite.",
-].join(" ");
-export const fileEditTool = {
-    name: "FileEdit",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string" },
-            old_string: { type: "string" },
-            new_string: { type: "string" },
-        },
-        required: ["path", "old_string", "new_string"],
-    },
-    async execute(args) {
-        const path = args.path;
-        const oldStr = args.old_string;
-        const newStr = args.new_string;
-        if (!path)
-            throw new Error("path is required");
-        if (!oldStr)
-            throw new Error("old_string is required");
-        if (newStr === undefined)
-            throw new Error("new_string is required");
-        const content = await readFile(path, "utf-8");
-        const count = content.split(oldStr).length - 1;
-        if (count === 0)
-            throw new Error(`old_string not found in ${path}`);
-        if (count > 1)
-            throw new Error(`old_string appears ${count} times in ${path}, must be unique`);
-        await writeFile(path, content.replace(oldStr, newStr), "utf-8");
-        return `Edited ${path}`;
-    },
-    summaryArg: "path",
-};