@aigne/cli 1.3.1-1 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [1.5.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.4.0...cli-v1.5.0) (2025-04-22)
+
+
+### Features
+
+* **cli:** render output message with markdown highlight ([#76](https://github.com/AIGNE-io/aigne-framework/issues/76)) ([b2a793a](https://github.com/AIGNE-io/aigne-framework/commit/b2a793a638e5f95d3f68be80f907da40bd7e624a))
+* **stream:** add streaming output support for agent ([#73](https://github.com/AIGNE-io/aigne-framework/issues/73)) ([5f3ea4b](https://github.com/AIGNE-io/aigne-framework/commit/5f3ea4bccda7c8c457d6e9518b3d6a8b254ec041))
+
+## [1.4.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.3.0...cli-v1.4.0) (2025-04-20)
+
+
+### Features
+
+* **core:** add model adapters for DeepSeek, Gemini, OpenRouter, and Ollama ([#53](https://github.com/AIGNE-io/aigne-framework/issues/53)) ([5d40546](https://github.com/AIGNE-io/aigne-framework/commit/5d40546bd5ddb70233d27ea3b20e5711b2af320a))
+
+
+### Bug Fixes
+
+* **cli:** display progressing for `run` command ([#68](https://github.com/AIGNE-io/aigne-framework/issues/68)) ([e3d2193](https://github.com/AIGNE-io/aigne-framework/commit/e3d21930bc2cf20edeb0ad7123e9e87e3e0ea653))
+* **cli:** ensure dir exists before extract package ([#70](https://github.com/AIGNE-io/aigne-framework/issues/70)) ([5ebe56d](https://github.com/AIGNE-io/aigne-framework/commit/5ebe56d3483d4309d9e39ab0566d353b3787edce))
+
 ## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.2.0...cli-v1.3.0) (2025-04-17)
 
 

package/dist/tracer/terminal.d.ts

@@ -1,8 +1,10 @@
-import { type Agent, type Context, type Message } from "@aigne/core";
+import { type Agent, type Context, MESSAGE_KEY, type Message } from "@aigne/core";
 import type { ContextUsage } from "@aigne/core/execution-engine/usage";
 import { type DefaultRenderer, Listr, type ListrRenderer, type ListrTaskWrapper } from "@aigne/listr2";
+import { promiseWithResolvers } from "../utils/promise-with-resolvers.js";
 export interface TerminalTracerOptions {
     verbose?: boolean;
+    aiResponsePrefix?: (context: Context) => string;
 }
 export declare class TerminalTracer {
     readonly context: Context;
@@ -11,10 +13,10 @@ export declare class TerminalTracer {
     private spinner;
     private tasks;
     run(agent: Agent, input: Message): Promise<{
-        result: any;
+        result: Message;
         context: Context;
     }>;
-    protected newListr(): MyListr;
+    protected wrap(str: string): string;
     formatAgentStartedOutput(agent: Agent, data: Message): string;
     formatAgentSucceedOutput(agent: Agent, data: Message): string;
     formatAgentFailedOutput(agent: Agent, data: Error): string;
@@ -28,9 +30,11 @@ export declare class TerminalTracer {
         usage?: boolean;
         time?: boolean;
     }): string;
+    private marked;
+    formatAIResponse({ [MESSAGE_KEY]: msg, ...message }?: Message): string;
 }
-type Task = ReturnType<typeof Promise.withResolvers<void>> & {
-    listr: ReturnType<typeof Promise.withResolvers<{
+type Task = ReturnType<typeof promiseWithResolvers<void>> & {
+    listr: ReturnType<typeof promiseWithResolvers<{
         ctx: object;
         subtask: Listr;
         taskWrapper: ListrTaskWrapper<unknown, typeof DefaultRenderer, typeof ListrRenderer>;
@@ -42,11 +46,4 @@ type Task = ReturnType<typeof Promise.withResolvers<void>> & {
         [key: string]: string;
     };
 };
-declare class MyListr extends Listr {
-    private taskPromise;
-    private isTaskPromiseResolved;
-    resolveWaitingTask(): void;
-    add(...args: Parameters<Listr["add"]>): ReturnType<Listr["add"]>;
-    waitTaskAndRun(ctx?: unknown): Promise<any>;
-}
 export {};

package/dist/tracer/terminal.js

@@ -1,8 +1,14 @@
+import { EOL } from "node:os";
 import { inspect } from "node:util";
-import { ChatModel, } from "@aigne/core";
+import { ChatModel, MESSAGE_KEY, } from "@aigne/core";
+import { mergeAgentResponseChunk, readableStreamToAsyncIterator, } from "@aigne/core/utils/stream-utils.js";
 import { Listr, ListrDefaultRendererLogLevels, Spinner, figures, } from "@aigne/listr2";
 import chalk from "chalk";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import wrap from "wrap-ansi";
 import { z } from "zod";
+import { promiseWithResolvers } from "../utils/promise-with-resolvers.js";
 import { parseDuration } from "../utils/time.js";
 const DEBUG_DEPTH = z.number().int().default(2).safeParse(Number(process.env.DEBUG_DEPTH)).data;
 export class TerminalTracer {
@@ -15,91 +21,18 @@ export class TerminalTracer {
     spinner = new Spinner();
     tasks = {};
     async run(agent, input) {
-        try {
-            this.spinner.start();
-            const context = this.context.newContext({ reset: true });
-            const listr = this.newListr();
-            context.on("agentStarted", async ({ contextId, parentContextId, agent, input, timestamp }) => {
-                const task = {
-                    ...Promise.withResolvers(),
-                    listr: Promise.withResolvers(),
-                    startTime: timestamp,
-                };
-                this.tasks[contextId] = task;
-                const listrTask = {
-                    title: this.formatTaskTitle(agent),
-                    task: (ctx, taskWrapper) => {
-                        const subtask = taskWrapper.newListr([{ task: () => task.promise }]);
-                        task.listr.resolve({ subtask, taskWrapper, ctx });
-                        return subtask;
-                    },
-                    rendererOptions: {
-                        persistentOutput: true,
-                        outputBar: Number.POSITIVE_INFINITY,
-                        bottomBar: Number.POSITIVE_INFINITY,
-                    },
-                };
-                const parentTask = parentContextId ? this.tasks[parentContextId] : undefined;
-                if (parentTask) {
-                    parentTask.listr.promise.then(({ subtask }) => {
-                        subtask.add(listrTask);
-                    });
-                }
-                else {
-                    listr.add(listrTask);
-                }
-                const { taskWrapper } = await task.listr.promise;
-                if (this.options.verbose) {
-                    taskWrapper.output = this.formatAgentStartedOutput(agent, input);
-                }
-            });
-            context.on("agentSucceed", async ({ agent, contextId, parentContextId, output, timestamp }) => {
-                const task = this.tasks[contextId];
-                if (!task)
-                    return;
-                task.endTime = timestamp;
-                const { taskWrapper, ctx } = await task.listr.promise;
-                if (agent instanceof ChatModel) {
-                    const { usage, model } = output;
-                    task.usage = usage;
-                    task.extraTitleMetadata ??= {};
-                    if (model)
-                        task.extraTitleMetadata.model = model;
-                }
-                taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
-                if (this.options.verbose) {
-                    taskWrapper.output = this.formatAgentSucceedOutput(agent, output);
-                }
-                if (!parentContextId || !this.tasks[parentContextId]) {
-                    Object.assign(ctx, output);
-                }
-                task.resolve();
-            });
-            context.on("agentFailed", async ({ agent, contextId, error, timestamp }) => {
-                const task = this.tasks[contextId];
-                if (!task)
-                    return;
-                task.endTime = timestamp;
-                const { taskWrapper } = await task.listr.promise;
-                taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
-                taskWrapper.output = this.formatAgentFailedOutput(agent, error);
-                task.reject(error);
-            });
-            const [result] = await Promise.all([
-                listr.waitTaskAndRun(),
-                context.call(agent, input).finally(() => {
-                    listr.resolveWaitingTask();
-                }),
-            ]);
-            return { result, context };
-        }
-        finally {
-            this.spinner.stop();
-        }
-    }
-    newListr() {
-        return new MyListr([], {
+        this.spinner.start();
+        const context = this.context.newContext({ reset: true });
+        const listr = new AIGNEListr({
+            formatResult: (result) => {
+                return [
+                    this.wrap(this.options.aiResponsePrefix?.(context) || ""),
+                    this.wrap(this.formatAIResponse(result)),
+                ];
+            },
+        }, [], {
             concurrent: true,
+            forceTTY: process.env.CI === "true",
             rendererOptions: {
                 collapseSubtasks: false,
                 writeBottomBarDirectly: true,
@@ -109,6 +42,92 @@ export class TerminalTracer {
                 },
             },
         });
+        const onAgentStarted = async ({ contextId, parentContextId, agent, input, timestamp, }) => {
+            const task = {
+                ...promiseWithResolvers(),
+                listr: promiseWithResolvers(),
+                startTime: timestamp,
+            };
+            this.tasks[contextId] = task;
+            const listrTask = {
+                title: this.formatTaskTitle(agent),
+                task: (ctx, taskWrapper) => {
+                    const subtask = taskWrapper.newListr([{ task: () => task.promise }]);
+                    task.listr.resolve({ subtask, taskWrapper, ctx });
+                    return subtask;
+                },
+                rendererOptions: {
+                    persistentOutput: true,
+                    outputBar: Number.POSITIVE_INFINITY,
+                    bottomBar: Number.POSITIVE_INFINITY,
+                },
+            };
+            const parentTask = parentContextId ? this.tasks[parentContextId] : undefined;
+            if (parentTask) {
+                parentTask.listr.promise.then(({ subtask }) => {
+                    subtask.add(listrTask);
+                });
+            }
+            else {
+                listr.add(listrTask);
+            }
+            const { taskWrapper } = await task.listr.promise;
+            if (this.options.verbose) {
+                taskWrapper.output = this.formatAgentStartedOutput(agent, input);
+            }
+        };
+        const onAgentSucceed = async ({ agent, contextId, parentContextId, output, timestamp, }) => {
+            const task = this.tasks[contextId];
+            if (!task)
+                return;
+            task.endTime = timestamp;
+            const { taskWrapper, ctx } = await task.listr.promise;
+            if (agent instanceof ChatModel) {
+                const { usage, model } = output;
+                task.usage = usage;
+                task.extraTitleMetadata ??= {};
+                if (model)
+                    task.extraTitleMetadata.model = model;
+            }
+            taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
+            if (this.options.verbose) {
+                taskWrapper.output = this.formatAgentSucceedOutput(agent, output);
+            }
+            if (!parentContextId || !this.tasks[parentContextId]) {
+                Object.assign(ctx, output);
+            }
+            task.resolve();
+        };
+        const onAgentFailed = async ({ agent, contextId, error, timestamp, }) => {
+            const task = this.tasks[contextId];
+            if (!task)
+                return;
+            task.endTime = timestamp;
+            const { taskWrapper } = await task.listr.promise;
+            taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
+            taskWrapper.output = this.formatAgentFailedOutput(agent, error);
+            task.reject(error);
+        };
+        context.on("agentStarted", onAgentStarted);
+        context.on("agentSucceed", onAgentSucceed);
+        context.on("agentFailed", onAgentFailed);
+        try {
+            const stream = await context.call(agent, input, { streaming: true });
+            const result = await listr.run(stream);
+            return { result, context };
+        }
+        finally {
+            this.spinner.stop();
+            context.off("agentStarted", onAgentStarted);
+            context.off("agentSucceed", onAgentSucceed);
+            context.off("agentFailed", onAgentFailed);
+        }
+    }
+    wrap(str) {
+        return wrap(str, process.stdout.columns ?? 80, {
+            hard: true,
+            trim: false,
+        });
     }
     formatAgentStartedOutput(agent, data) {
         return `\
@@ -154,26 +173,49 @@ ${this.formatMessage(data)}`;
             title += ` ${this.formatTimeUsage(task.startTime, task.endTime)}`;
         return title;
     }
+    marked = new Marked().use(markedTerminal());
+    formatAIResponse({ [MESSAGE_KEY]: msg, ...message } = {}) {
+        const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
+        const json = Object.keys(message).length > 0 ? inspect(message, { colors: true }) : undefined;
+        return [text, json].filter(Boolean).join("\n");
+    }
 }
-class MyListr extends Listr {
-    taskPromise = Promise.withResolvers();
-    isTaskPromiseResolved = false;
-    resolveWaitingTask() {
-        if (!this.isTaskPromiseResolved) {
-            this.taskPromise.resolve();
-            this.isTaskPromiseResolved = true;
-        }
+class AIGNEListr extends Listr {
+    myOptions;
+    result = {};
+    isStreamRunning = false;
+    constructor(myOptions, ...args) {
+        super(...args);
+        this.myOptions = myOptions;
+        const renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
+        const spinner = renderer.spinner;
+        // Override the `create` method of renderer to customize the output
+        const create = renderer.create;
+        renderer.create = (...args) => {
+            const [tasks, output] = create.call(renderer, ...args);
+            const l = [
+                "",
+                tasks,
+                "",
+                ...[this.myOptions.formatResult(this.result)].flat(),
+                this.isStreamRunning ? spinner.fetch() : "",
+            ];
+            return [l.join(EOL), output];
+        };
+        // @ts-ignore initialize the renderer
+        this.renderer = renderer;
     }
-    add(...args) {
-        const result = super.add(...args);
-        this.resolveWaitingTask();
-        return result;
+    async run(stream) {
+        this.add({ task: () => this.extractStream(stream) });
+        return await super.run().then(() => ({ ...this.result }));
     }
-    async waitTaskAndRun(ctx) {
-        if (!this.tasks.length)
-            await this.taskPromise.promise;
-        if (!this.tasks.length)
-            return ctx;
-        return super.run(ctx);
+    async extractStream(stream) {
+        this.isStreamRunning = true;
+        this.result = {};
+        for await (const value of readableStreamToAsyncIterator(stream)) {
+            mergeAgentResponseChunk(this.result, value);
+        }
+        this.isStreamRunning = false;
+        return this.result;
     }
 }

package/dist/utils/promise-with-resolvers.d.ts

@@ -0,0 +1,6 @@
+export interface PromiseWithResolvers<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+export declare function promiseWithResolvers<T = void>(): PromiseWithResolvers<T>;

package/dist/utils/promise-with-resolvers.js

@@ -0,0 +1,9 @@
+export function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}

package/dist/utils/run-chat-loop.js

@@ -1,5 +1,4 @@
-import { inspect } from "node:util";
-import { MESSAGE_KEY, createMessage } from "@aigne/core";
+import { createMessage } from "@aigne/core";
 import { logger } from "@aigne/core/utils/logger.js";
 import { figures } from "@aigne/listr2";
 import chalk from "chalk";
@@ -49,14 +48,15 @@ export async function runChatLoopInTerminal(userAgent, options = {}) {
     }
 }
 async function callAgent(userAgent, input, options) {
-    const tracer = new TerminalTracer(userAgent.context, { verbose: options.verbose });
-    const { result, context } = await tracer.run(userAgent, options.inputKey && typeof input === "string"
+    const tracer = new TerminalTracer(userAgent.context, {
+        verbose: options.verbose,
+        aiResponsePrefix: (context) => {
+            return `${chalk.grey(figures.tick)} 🤖 ${tracer.formatTokenUsage(context.usage)}`;
+        },
+    });
+    await tracer.run(userAgent, options.inputKey && typeof input === "string"
         ? { [options.inputKey]: input }
         : createMessage(input));
-    console.log(`
-${chalk.grey(figures.tick)} 🤖 ${tracer.formatTokenUsage(context.usage)}
-${formatAIResponse(result)}
-`);
 }
 const COMMANDS = {
     "/exit": () => ({ exit: true }),
@@ -68,8 +68,3 @@ Commands:
 `,
     }),
 };
-function formatAIResponse({ [MESSAGE_KEY]: msg, ...message } = {}) {
-    const text = msg && typeof msg === "string" ? msg : undefined;
-    const json = Object.keys(message).length > 0 ? inspect(message, { colors: true }) : undefined;
-    return [text, json].filter(Boolean).join("\n");
-}

package/dist/utils/serve-mcp.js

@@ -3,6 +3,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import express from "express";
 import { ZodObject } from "zod";
+import { promiseWithResolvers } from "./promise-with-resolvers.js";
 export async function serveMCPServer({ engine, port }) {
     const server = new McpServer({
         name: engine.name || "aigne-mcp-server",
@@ -53,7 +54,7 @@ export async function serveMCPServer({ engine, port }) {
             .status(error instanceof HttpError ? error.status : 500)
             .json({ error: { message: error.message } });
     }));
-    const { promise, resolve, reject } = Promise.withResolvers();
+    const { promise, resolve, reject } = promiseWithResolvers();
     const httpServer = app.listen(port, (error) => {
         if (error)
             reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.3.1-1",
+  "version": "1.5.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -34,7 +34,7 @@
     }
   },
   "dependencies": {
-    "@aigne/listr2": "^1.0.7",
+    "@aigne/listr2": "^1.0.8",
     "@modelcontextprotocol/sdk": "^1.9.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
@@ -42,12 +42,14 @@
     "glob": "^11.0.1",
     "gradient-string": "^3.0.0",
     "inquirer": "^12.5.2",
+    "marked": "^15.0.9",
+    "marked-terminal": "^7.3.0",
     "openai": "^4.94.0",
     "prettier": "^3.5.3",
     "pretty-error": "^4.0.0",
     "tar": "^7.4.3",
     "zod": "^3.24.2",
-    "@aigne/core": "^1.8.0"
+    "@aigne/core": "^1.10.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",