@aigne/cli 1.25.1 → 1.26.1-0

package/dist/commands/run.js

@@ -12,94 +12,109 @@ import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { createRunAIGNECommand, parseAgentInputByCommander, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
-export function createRunCommand({ aigneFilePath } = {}) {
-    return createRunAIGNECommand()
-        .description("Run AIGNE from the specified agent")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .option("--entry-agent <entry-agent>", "Name of the agent to run (defaults to the first agent found)")
-        .option("--cache-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        if (options.logLevel)
-            logger.level = options.logLevel;
-        const { cacheDir, dir } = prepareDirs(path, options);
-        const { aigne, agent } = await new Listr([
-            {
-                title: "Prepare environment",
-                task: (_, task) => {
-                    if (cacheDir) {
-                        return task.newListr([
-                            {
-                                title: "Download package",
-                                task: () => downloadPackage(path, cacheDir),
-                            },
-                            {
-                                title: "Extract package",
-                                task: () => extractPackage(cacheDir, dir),
-                            },
-                        ]);
-                    }
+export function createRunCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "run [path]",
+        describe: "Run AIGNE from the specified agent",
+        builder: (yargs) => {
+            return createRunAIGNECommand(yargs)
+                .positional("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            })
+                .option("entry-agent", {
+                describe: "Name of the agent to run (defaults to the first agent found)",
+                type: "string",
+            })
+                .option("cache-dir", {
+                describe: "Directory to download the package to (defaults to the ~/.aigne/xxx)",
+                type: "string",
+            });
+        },
+        handler: async (argv) => {
+            const options = argv;
+            const path = aigneFilePath || options.path;
+            if (options.logLevel)
+                logger.level = options.logLevel;
+            const { cacheDir, dir } = prepareDirs(path, options);
+            const { aigne, agent } = await new Listr([
+                {
+                    title: "Prepare environment",
+                    task: (_, task) => {
+                        if (cacheDir) {
+                            return task.newListr([
+                                {
+                                    title: "Download package",
+                                    task: () => downloadPackage(path, cacheDir),
+                                },
+                                {
+                                    title: "Extract package",
+                                    task: () => extractPackage(cacheDir, dir),
+                                },
+                            ]);
+                        }
+                    },
                 },
-            },
-            {
-                title: "Initialize AIGNE",
-                task: async (ctx, task) => {
-                    // Load env files in the aigne directory
-                    config({ path: dir, silent: true });
-                    const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
-                        inquirerPromptFn: (prompt) => {
-                            return task
-                                .prompt(ListrInquirerPromptAdapter)
-                                .run(select, prompt)
-                                .then((res) => ({ [prompt.name]: res }));
-                        },
-                    });
-                    ctx.aigne = aigne;
+                {
+                    title: "Initialize AIGNE",
+                    task: async (ctx, task) => {
+                        // Load env files in the aigne directory
+                        config({ path: dir, silent: true });
+                        const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
+                            inquirerPromptFn: (prompt) => {
+                                return task
+                                    .prompt(ListrInquirerPromptAdapter)
+                                    .run(select, prompt)
+                                    .then((res) => ({ [prompt.name]: res }));
+                            },
+                        });
+                        ctx.aigne = aigne;
+                    },
                 },
-            },
-            {
-                task: (ctx) => {
-                    const { aigne } = ctx;
-                    assert(aigne);
-                    let entryAgent;
-                    if (options.entryAgent) {
-                        entryAgent = aigne.agents[options.entryAgent];
-                        if (!entryAgent) {
-                            throw new Error(`\
+                {
+                    task: (ctx) => {
+                        const { aigne } = ctx;
+                        assert(aigne);
+                        let entryAgent;
+                        if (options.entryAgent) {
+                            entryAgent = aigne.agents[options.entryAgent];
+                            if (!entryAgent) {
+                                throw new Error(`\
 Agent "${options.entryAgent}" not found in ${aigne.rootDir}
 
 Available agents:
 ${aigne.agents.map((agent) => `  - ${agent.name}`).join("\n")}
 `);
+                            }
+                        }
+                        else {
+                            entryAgent = aigne.agents[0];
+                            if (!entryAgent)
+                                throw new Error(`No any agent found in ${aigne.rootDir}`);
                         }
-                    }
-                    else {
-                        entryAgent = aigne.agents[0];
-                        if (!entryAgent)
-                            throw new Error(`No any agent found in ${aigne.rootDir}`);
-                    }
-                    ctx.agent = entryAgent;
+                        ctx.agent = entryAgent;
+                    },
+                },
+            ], {
+                rendererOptions: {
+                    collapseSubtasks: false,
+                    showErrorMessage: false,
+                    timer: PRESET_TIMER,
                 },
-            },
-        ], {
-            rendererOptions: {
-                collapseSubtasks: false,
-                showErrorMessage: false,
-                timer: PRESET_TIMER,
-            },
-        }).run();
-        assert(aigne);
-        assert(agent);
-        const input = await parseAgentInputByCommander(agent, options);
-        try {
-            await runAgentWithAIGNE(aigne, agent, { ...options, input });
-        }
-        finally {
-            await aigne.shutdown();
-        }
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+            }).run();
+            assert(aigne);
+            assert(agent);
+            const input = await parseAgentInputByCommander(agent, options);
+            try {
+                await runAgentWithAIGNE(aigne, agent, { ...options, input });
+            }
+            finally {
+                await aigne.shutdown();
+            }
+        },
+    };
 }
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
@@ -121,7 +136,7 @@ function prepareDirs(path, options) {
     if (!path.startsWith("http")) {
         dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    else if (options.cacheDir) {
+    else if (options?.cacheDir) {
         dir = isAbsolute(options.cacheDir)
             ? options.cacheDir
             : resolve(process.cwd(), options.cacheDir);
@@ -133,7 +148,7 @@ function prepareDirs(path, options) {
     }
     return { cacheDir, dir };
 }
-function getLocalPackagePathFromUrl(url, { subdir } = {}) {
+export function getLocalPackagePathFromUrl(url, { subdir } = {}) {
     const root = [homedir(), ".aigne", subdir].filter(isNonNullable);
     const u = new URL(url);
     return join(...root, u.hostname, u.pathname);

package/dist/commands/serve-mcp.d.ts

@@ -1,4 +1,11 @@
-import { Command } from "commander";
-export declare function createServeMCPCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+interface ServeMCPOptions {
+    path: string;
+    host: string;
+    port?: number;
+    pathname: string;
+}
+export declare function createServeMCPCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule<{}, ServeMCPOptions>;
+export {};

package/dist/commands/serve-mcp.js

@@ -1,6 +1,5 @@
 import { isAbsolute, resolve } from "node:path";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
-import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { serveMCPServer } from "../utils/serve-mcp.js";
 const DEFAULT_PORT = () => tryOrThrow(() => {
@@ -12,26 +11,45 @@ const DEFAULT_PORT = () => tryOrThrow(() => {
         throw new Error(`Invalid PORT: ${PORT}`);
     return port;
 }, (error) => new Error(`parse PORT error ${error.message}`));
-export function createServeMCPCommand({ aigneFilePath } = {}) {
-    return new Command("serve-mcp")
-        .description("Serve the agents in the specified directory as a MCP server (streamable http)")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .option("--host <host>", "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server", "localhost")
-        .option("--port <port>", "Port to run the MCP server on", (s) => Number.parseInt(s))
-        .option("--pathname <pathname>", "Pathname to the service", "/mcp")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const port = options.port || DEFAULT_PORT();
-        const aigne = await loadAIGNE(absolutePath);
-        await serveMCPServer({
-            aigne,
-            host: options.host,
-            port,
-            pathname: options.pathname,
-        });
-        console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+export function createServeMCPCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "serve-mcp",
+        describe: "Serve the agents in the specified directory as a MCP server (streamable http)",
+        builder: (yargs) => {
+            return yargs
+                .option("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            })
+                .option("host", {
+                describe: "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server",
+                type: "string",
+                default: "localhost",
+            })
+                .option("port", {
+                describe: "Port to run the MCP server on",
+                type: "number",
+            })
+                .option("pathname", {
+                describe: "Pathname to the service",
+                type: "string",
+                default: "/mcp",
+            });
+        },
+        handler: async (options) => {
+            const path = aigneFilePath || options.path;
+            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            const port = options.port || DEFAULT_PORT();
+            const aigne = await loadAIGNE(absolutePath);
+            await serveMCPServer({
+                aigne,
+                host: options.host,
+                port,
+                pathname: options.pathname,
+            });
+            console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
+        },
+    };
 }

package/dist/commands/test.d.ts

@@ -1,4 +1,8 @@
-import { Command } from "commander";
-export declare function createTestCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+interface TestOptions {
+    path: string;
+}
+export declare function createTestCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule<{}, TestOptions>;
+export {};

package/dist/commands/test.js

@@ -1,19 +1,25 @@
 import assert from "node:assert";
 import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
-import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
-export function createTestCommand({ aigneFilePath } = {}) {
-    return new Command("test")
-        .description("Run tests in the specified agents directory")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const aigne = await loadAIGNE(absolutePath);
-        assert(aigne.rootDir);
-        spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+export function createTestCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "test",
+        describe: "Run tests in the specified agents directory",
+        builder: (yargs) => {
+            return yargs.option("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            });
+        },
+        handler: async (options) => {
+            const path = aigneFilePath || options.path;
+            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            const aigne = await loadAIGNE(absolutePath);
+            assert(aigne.rootDir);
+            spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
+        },
+    };
 }

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./type.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./type.js";

package/dist/tracer/terminal.js

@@ -3,9 +3,11 @@ import { inspect } from "node:util";
 import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, } from "@aigne/core";
 import { LogLevel, logger } from "@aigne/core/utils/logger.js";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
-import { omit } from "@aigne/core/utils/type-utils.js";
+import { flat, omit } from "@aigne/core/utils/type-utils.js";
 import { figures } from "@aigne/listr2";
 import { markedTerminal } from "@aigne/marked-terminal";
+import * as prompts from "@inquirer/prompts";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
 import chalk from "chalk";
 import { Marked } from "marked";
 import { AIGNEListr } from "../utils/listr.js";
@@ -27,11 +29,13 @@ export class TerminalTracer {
                 : undefined,
             formatResult: (result, options) => [this.formatResult(agent, context, result, options)].filter(Boolean),
         }, [], { concurrent: true });
-        const onAgentStarted = async ({ contextId, parentContextId, agent, timestamp, }) => {
+        const onStart = async ({ context, agent }) => {
+            const contextId = context.id;
+            const parentContextId = context.parentId;
             const task = {
                 ...promiseWithResolvers(),
                 listr: promiseWithResolvers(),
-                startTime: timestamp,
+                startTime: Date.now(),
             };
             this.tasks[contextId] = task;
             const listrTask = {
@@ -56,12 +60,32 @@ export class TerminalTracer {
             else {
                 listr.add(listrTask);
             }
+            return {
+                options: {
+                    prompts: new Proxy({}, {
+                        get: (_target, prop) => {
+                            // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
+                            const method = prompts[prop];
+                            if (!method)
+                                return undefined;
+                            return async (config) => {
+                                const { taskWrapper } = await task.listr.promise;
+                                return taskWrapper
+                                    .prompt(ListrInquirerPromptAdapter)
+                                    .run(method, config);
+                            };
+                        },
+                    }),
+                },
+            };
         };
-        const onAgentSucceed = async ({ agent, contextId, parentContextId, output, timestamp, }) => {
+        const onSuccess = async ({ context, agent, output }) => {
+            const contextId = context.id;
+            const parentContextId = context.parentId;
             const task = this.tasks[contextId];
             if (!task)
                 return;
-            task.endTime = timestamp;
+            task.endTime = Date.now();
             const { taskWrapper, ctx } = await task.listr.promise;
             if (agent instanceof ChatModel) {
                 const { usage, model } = output;
@@ -76,27 +100,27 @@ export class TerminalTracer {
             }
             task.resolve();
         };
-        const onAgentFailed = async ({ agent, contextId, error, timestamp, }) => {
+        const onError = async ({ context, agent, error }) => {
+            const contextId = context.id;
             const task = this.tasks[contextId];
             if (!task)
                 return;
-            task.endTime = timestamp;
+            task.endTime = Date.now();
             const { taskWrapper } = await task.listr.promise;
             taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
             task.reject(error);
         };
-        context.on("agentStarted", onAgentStarted);
-        context.on("agentSucceed", onAgentSucceed);
-        context.on("agentFailed", onAgentFailed);
-        try {
-            const result = await listr.run(() => context.invoke(agent, input, { ...options, streaming: true, newContext: false }));
-            return { result, context };
-        }
-        finally {
-            context.off("agentStarted", onAgentStarted);
-            context.off("agentSucceed", onAgentSucceed);
-            context.off("agentFailed", onAgentFailed);
-        }
+        const result = await listr.run(() => context.invoke(agent, input, {
+            ...options,
+            hooks: flat({
+                onStart,
+                onSuccess,
+                onError,
+            }, options?.hooks),
+            streaming: true,
+            newContext: false,
+        }));
+        return { result, context };
     }
     formatTokenUsage(usage, extra) {
         const items = [

package/dist/type.d.ts

@@ -0,0 +1,5 @@
+import type { AgentInvokeOptions as _AgentInvokeOptions, UserContext } from "@aigne/core";
+import type * as prompts from "@inquirer/prompts";
+export interface AgentInvokeOptions<U extends UserContext = UserContext> extends _AgentInvokeOptions<U> {
+    prompts: typeof prompts;
+}

package/dist/type.js

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

package/dist/utils/download.d.ts

@@ -1 +1,3 @@
-export declare function downloadAndExtract(url: string, dir: string): Promise<void>;
+export declare function downloadAndExtract(url: string, dir: string, options?: {
+    strip?: number;
+}): Promise<void>;

package/dist/utils/download.js

@@ -1,7 +1,7 @@
 import { Readable } from "node:stream";
 import { finished } from "node:stream/promises";
 import { x } from "tar";
-export async function downloadAndExtract(url, dir) {
+export async function downloadAndExtract(url, dir, options = {}) {
     const response = await fetch(url).catch((error) => {
         throw new Error(`Failed to download package from ${url}: ${error.message}`);
     });
@@ -12,7 +12,7 @@ export async function downloadAndExtract(url, dir) {
         throw new Error(`Failed to download package from ${url}: Unexpected to get empty response`);
     }
     try {
-        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir })));
+        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir, ...options })));
     }
     catch (error) {
         error.message = `Failed to extract package from ${url}: ${error.message}`;

package/dist/utils/listr.js

@@ -98,7 +98,7 @@ export class AIGNEListrRenderer extends DefaultRenderer {
             this._updater.clear();
             this._logger.toStdout(logs.join(EOL));
         }
-        let tasks = super.create(options);
+        let tasks = super.create({ ...options, prompt: false });
         const bottomBar = this._options.aigne?.getBottomBarLogs?.({ running });
         if (bottomBar?.length) {
             tasks += EOL.repeat(2);
@@ -116,6 +116,10 @@ export class AIGNEListrRenderer extends DefaultRenderer {
                 tasks += output.split(EOL).slice(-Math.max(4, lines)).join(EOL);
             }
         }
+        const prompt = super["renderPrompt"]();
+        if (prompt.length) {
+            tasks += `${EOL.repeat(2)}${prompt.join(EOL)}`;
+        }
         return tasks;
     }
     _wrap(str) {

package/dist/utils/load-aigne.d.ts

@@ -1,11 +1,54 @@
 import { AIGNE } from "@aigne/core";
+import type { LoadableModel } from "@aigne/core/loader/index.js";
+import inquirer from "inquirer";
 import { type RunAIGNECommandOptions } from "./run-with-aigne.js";
+export declare const decrypt: (m: string, s: string, i: string) => string;
+export declare const encrypt: (m: string, s: string, i: string) => string;
+export declare const encodeEncryptionKey: (key: string) => string;
+export declare const decodeEncryptionKey: (str: string) => Uint8Array<ArrayBuffer>;
+export declare const AIGNE_ENV_FILE: string;
 export interface RunOptions extends RunAIGNECommandOptions {
     path: string;
     entryAgent?: string;
     cacheDir?: string;
 }
-export declare function loadAIGNE(path: string, options?: RunOptions, checkAuthorizeOptions?: {
+type FetchResult = {
+    accessKeyId: string;
+    accessKeySecret: string;
+};
+export declare const fetchConfigs: ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }: {
+    connectUrl: string;
+    sessionId: string;
+    fetchInterval: number;
+    fetchTimeout: number;
+}) => Promise<any>;
+declare function baseWrapSpinner(_: string, waiting: () => Promise<FetchResult>): Promise<FetchResult>;
+interface CreateConnectOptions {
+    connectUrl: string;
+    openPage?: (url: string) => void;
+    fetchInterval?: number;
+    retry?: number;
+    source?: string;
+    connectAction?: string;
+    wrapSpinner?: typeof baseWrapSpinner;
+    prettyUrl?: (url: string) => string;
+    closeOnSuccess?: boolean;
+    intervalFetchConfig?: (options: {
+        sessionId: string;
+        fetchInterval: number;
+        fetchTimeout: number;
+    }) => Promise<FetchResult>;
+}
+export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, }: CreateConnectOptions): Promise<FetchResult>;
+export declare const formatModelName: (models: LoadableModel[], model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
+export declare function connectToAIGNEHub(url: string): Promise<{
+    accessKey: string;
+    url: string;
+} | {
+    accessKey: undefined;
+    url: undefined;
+}>;
+export declare function loadAIGNE(path: string, options?: RunOptions, actionOptions?: {
     inquirerPromptFn?: (prompt: {
         type: string;
         name: string;
@@ -16,4 +59,6 @@ export declare function loadAIGNE(path: string, options?: RunOptions, checkAutho
         }[];
         default: any;
     }) => Promise<any>;
+    runTest?: boolean;
 }): Promise<AIGNE<import("@aigne/core").UserContext>>;
+export {};