@aigne/cli 1.27.0 → 1.27.1-1

package/dist/cli.d.ts

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
-export {};
+declare const _default: Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;
+export default _default;

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { existsSync, realpathSync, statSync } from "node:fs";
 import chalk from "chalk";
 import { config } from "dotenv-flow";
+import { hideBin } from "yargs/helpers";
 import { createAIGNECommand } from "./commands/aigne.js";
 config({ silent: true });
 function getAIGNEFilePath() {
@@ -15,8 +16,8 @@ function getAIGNEFilePath() {
     }
 }
 const aigneFilePath = getAIGNEFilePath();
-createAIGNECommand({ aigneFilePath })
-    .parseAsync(["", "", ...process.argv.slice(aigneFilePath ? 3 : 2)])
+export default createAIGNECommand({ aigneFilePath })
+    .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))
     .catch((error) => {
     console.log(""); // Add an empty line for better readability
     console.error(`${chalk.red("Error:")} ${error.message}`);

package/dist/commands/aigne.d.ts

@@ -1,4 +1,4 @@
-import { Command } from "commander";
+import yargs from "yargs";
 export declare function createAIGNECommand(options?: {
     aigneFilePath?: string;
-}): Command;
+}): yargs.Argv<{}>;

package/dist/commands/aigne.js

@@ -1,6 +1,7 @@
-import { Command } from "commander";
+import yargs from "yargs";
 import { AIGNE_CLI_VERSION } from "../constants.js";
 import { asciiLogo } from "../utils/ascii-logo.js";
+import { createAppCommands } from "./app.js";
 import { createConnectCommand } from "./connect.js";
 import { createCreateCommand } from "./create.js";
 import { createObservabilityCommand } from "./observe.js";
@@ -9,16 +10,20 @@ import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
     console.log(asciiLogo);
-    return new Command()
-        .name("aigne")
-        .description("CLI for AIGNE framework")
+    return yargs()
+        .scriptName("aigne")
+        .usage("CLI for AIGNE framework")
         .version(AIGNE_CLI_VERSION)
-        .addCommand(createRunCommand(options), { isDefault: true })
-        .addCommand(createTestCommand(options))
-        .addCommand(createCreateCommand())
-        .addCommand(createServeMCPCommand(options))
-        .addCommand(createObservabilityCommand())
-        .addCommand(createConnectCommand())
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+        .command(createRunCommand(options))
+        .command(createTestCommand(options))
+        .command(createCreateCommand())
+        .command(createServeMCPCommand(options))
+        .command(createObservabilityCommand())
+        .command(createConnectCommand())
+        .command(createAppCommands())
+        .help()
+        .alias("help", "h")
+        .alias("version", "v")
+        .showHelpOnFail(true)
+        .strict();
 }

package/dist/commands/app.d.ts

@@ -0,0 +1,2 @@
+import type { CommandModule } from "yargs";
+export declare function createAppCommands(): CommandModule[];

package/dist/commands/app.js

@@ -0,0 +1,203 @@
+import assert from "node:assert";
+import { spawnSync } from "node:child_process";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join } from "node:path";
+import { isatty } from "node:tty";
+import { AIAgent, AIGNE, readAllString } from "@aigne/core";
+import { pick } from "@aigne/core/utils/type-utils.js";
+import { Listr, PRESET_TIMER } from "@aigne/listr2";
+import { joinURL } from "ufo";
+import { parse } from "yaml";
+import { ZodObject } from "zod";
+import { availableModels } from "../constants.js";
+import { downloadAndExtract } from "../utils/download.js";
+import { loadAIGNE } from "../utils/load-aigne.js";
+import { runAgentWithAIGNE, stdinHasData } from "../utils/run-with-aigne.js";
+const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
+const builtinApps = [
+    {
+        name: "doc-smith",
+        describe: "Generate professional documents by doc-smith",
+        aliases: ["docsmith", "doc"],
+    },
+];
+export function createAppCommands() {
+    return builtinApps.map((app) => ({
+        command: app.name,
+        describe: app.describe,
+        aliases: app.aliases,
+        builder: async (yargs) => {
+            const { aigne, dir, version } = await loadApplication({ name: "doc-smith" });
+            for (const agent of aigne.agents) {
+                const inputSchema = Object.entries(agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {});
+                yargs.command(agent.name, agent.description || "", (yargs) => {
+                    for (const [option, config] of inputSchema) {
+                        yargs.option(option, {
+                            // TODO: support more types
+                            type: "string",
+                            description: config.description,
+                        });
+                        if (!(config.isNullable() || config.isOptional())) {
+                            yargs.demandOption(option);
+                        }
+                    }
+                    yargs
+                        .option("input", {
+                        type: "array",
+                        description: "Input to the agent, use @<file> to read from a file",
+                        alias: ["i"],
+                    })
+                        .option("format", {
+                        type: "string",
+                        description: 'Input format, can be "json" or "yaml"',
+                        choices: ["json", "yaml"],
+                    });
+                }, async (argv) => {
+                    try {
+                        const aigne = await loadAIGNE(dir);
+                        const _agent = aigne.agents[agent.name];
+                        assert(_agent, `Agent ${agent.name} not found in ${app.name}`);
+                        const input = pick(argv, inputSchema.map(([key]) => key));
+                        const rawInput = argv.input ||
+                            (isatty(process.stdin.fd) || !(await stdinHasData())
+                                ? null
+                                : [await readAllString(process.stdin)].filter(Boolean));
+                        if (rawInput) {
+                            for (let raw of rawInput) {
+                                let format = argv.format;
+                                if (raw.startsWith("@")) {
+                                    raw = await readFile(raw.slice(1), "utf8");
+                                    if (!format) {
+                                        const ext = extname(raw);
+                                        if (ext === ".json")
+                                            format = "json";
+                                        else if (ext === ".yaml" || ext === ".yml")
+                                            format = "yaml";
+                                    }
+                                }
+                                const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
+                                if (format === "json") {
+                                    Object.assign(input, JSON.parse(raw));
+                                }
+                                else if (format === "yaml") {
+                                    Object.assign(input, parse(raw));
+                                }
+                                else if (inputKey) {
+                                    Object.assign(input, { [inputKey]: raw });
+                                }
+                            }
+                        }
+                        await runAgentWithAIGNE(aigne, _agent, { input });
+                    }
+                    finally {
+                        await aigne.shutdown();
+                    }
+                });
+            }
+            yargs.version(`${app.name} v${version}`);
+            return yargs.demandCommand();
+        },
+        handler: () => { },
+    }));
+}
+async function loadApplication({ name, }) {
+    name = `@aigne/${name}`;
+    const dir = join(homedir(), ".aigne", "registry.npmjs.org", name);
+    const check = await isInstallationAvailable(dir);
+    if (check?.available) {
+        return {
+            aigne: await AIGNE.load(dir, { models: availableModels() }),
+            dir,
+            version: check.version,
+        };
+    }
+    const result = await new Listr([
+        {
+            title: "Fetching application metadata",
+            task: async (ctx) => {
+                const info = await getNpmTgzInfo(name);
+                Object.assign(ctx, info);
+            },
+        },
+        {
+            title: "Downloading application",
+            skip: (ctx) => ctx.version === check?.version,
+            task: async (ctx) => {
+                await downloadApplication({ url: ctx.url, dir });
+            },
+        },
+        {
+            title: "Installing dependencies",
+            skip: (ctx) => ctx.version === check?.version,
+            task: async () => {
+                await installDependencies(dir);
+            },
+        },
+    ], {
+        rendererOptions: {
+            collapseSubtasks: false,
+            showErrorMessage: false,
+            timer: PRESET_TIMER,
+        },
+    }).run();
+    return {
+        aigne: await AIGNE.load(dir, { models: availableModels() }),
+        dir,
+        version: result.version,
+    };
+}
+async function isInstallationAvailable(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
+    const s = await stat(join(dir, "package.json")).catch((error) => {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+    if (!s)
+        return null;
+    const version = safeParseJSON(await readFile(join(dir, "package.json"), "utf-8"))?.version;
+    if (!version)
+        return null;
+    const installedAt = safeParseJSON(await readFile(join(dir, ".aigne-cli.json"), "utf-8").catch(() => "{}"))?.installedAt;
+    if (!installedAt)
+        return null;
+    const now = Date.now();
+    const available = installedAt ? now - installedAt < cacheTimeMs : false;
+    return { version, available };
+}
+async function downloadApplication({ url, dir }) {
+    await mkdir(dir, { recursive: true });
+    await downloadAndExtract(url, dir, { strip: 1 });
+}
+async function installDependencies(dir) {
+    const { stderr, status } = spawnSync("npm", ["install", "--omit", "dev"], {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    if (status !== 0) {
+        console.error(stderr.toString());
+        throw new Error(`Failed to install dependencies in ${dir}`);
+    }
+    await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify({ installedAt: Date.now() }, null, 2));
+}
+async function getNpmTgzInfo(name) {
+    const res = await fetch(joinURL("https://registry.npmjs.org", name));
+    if (!res.ok)
+        throw new Error(`Failed to fetch package info for ${name}: ${res.statusText}`);
+    const data = await res.json();
+    const latestVersion = data["dist-tags"].latest;
+    const url = data.versions[latestVersion].dist.tarball;
+    return {
+        version: latestVersion,
+        url,
+    };
+}
+function safeParseJSON(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/connect.d.ts

@@ -1,2 +1,6 @@
-import { Command } from "commander";
-export declare function createConnectCommand(): Command;
+import type { CommandModule } from "yargs";
+interface ConnectOptions {
+    url?: string;
+}
+export declare function createConnectCommand(): CommandModule<unknown, ConnectOptions>;
+export {};

package/dist/commands/connect.js

@@ -1,7 +1,6 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import chalk from "chalk";
-import { Command } from "commander";
 import { parse } from "yaml";
 import { getUserInfo } from "../utils/aigne-hub-user.js";
 import { AIGNE_ENV_FILE, connectToAIGNEHub } from "../utils/load-aigne.js";
@@ -57,30 +56,36 @@ async function displayStatus(statusList) {
     }
 }
 export function createConnectCommand() {
-    const connectCommand = new Command("connect")
-        .description("Manage AIGNE Hub connections")
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
-    connectCommand
-        .command("status")
-        .description("Show current connection status")
-        .action(async () => {
-        const statusList = await getConnectionStatus();
-        await displayStatus(statusList);
-    });
-    connectCommand
-        .option("--url <url>", "URL to the AIGNE Hub server")
-        .action(async (options) => {
-        const url = options.url || "https://hub.aigne.io/";
-        console.log(chalk.blue(`Connecting to AIGNE Hub: ${url}`));
-        try {
-            await connectToAIGNEHub(url);
-            console.log(chalk.green("✓ Successfully connected to AIGNE Hub"));
-        }
-        catch (error) {
-            console.error(chalk.red("✗ Failed to connect to AIGNE Hub:"), error.message);
-            process.exit(1);
-        }
-    });
-    return connectCommand;
+    return {
+        command: "connect [url]",
+        describe: "Manage AIGNE Hub connections",
+        builder: (yargs) => {
+            return yargs
+                .positional("url", {
+                describe: "URL to the AIGNE Hub server",
+                type: "string",
+                default: "https://hub.aigne.io/",
+            })
+                .command({
+                command: "status",
+                describe: "Show current connection status",
+                handler: async () => {
+                    const statusList = await getConnectionStatus();
+                    await displayStatus(statusList);
+                },
+            });
+        },
+        handler: async (argv) => {
+            const url = argv.url || "https://hub.aigne.io/";
+            console.log(chalk.blue(`Connecting to AIGNE Hub: ${url}`));
+            try {
+                await connectToAIGNEHub(url);
+                console.log(chalk.green("✓ Successfully connected to AIGNE Hub"));
+            }
+            catch (error) {
+                console.error(chalk.red("✗ Failed to connect to AIGNE Hub:"), error.message);
+                process.exit(1);
+            }
+        },
+    };
 }

package/dist/commands/create.d.ts

@@ -1,2 +1,6 @@
-import { Command } from "commander";
-export declare function createCreateCommand(): Command;
+import type { CommandModule } from "yargs";
+interface CreateOptions {
+    path: string;
+}
+export declare function createCreateCommand(): CommandModule<unknown, CreateOptions>;
+export {};

package/dist/commands/create.js

@@ -1,69 +1,73 @@
 import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import { cp } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
-import { Command } from "commander";
 import inquirer from "inquirer";
 export function createCreateCommand() {
-    return new Command("create")
-        .description("Create a new aigne project with agent config files")
-        .argument("[path]", "Path to create the project directory", ".")
-        .action(async (_path) => {
-        let path = _path;
-        if (path === ".") {
-            const answers = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "projectName",
-                    message: "Project name:",
-                    default: _path !== "." ? _path : "my-aigne-project",
-                    validate: (input) => {
-                        if (input.trim() === "")
-                            return "Project name cannot be empty.";
-                        return true;
+    return {
+        command: "create [path]",
+        describe: "Create a new aigne project with agent config files",
+        builder: (yargs) => {
+            return yargs.positional("path", {
+                describe: "Path to create the project directory",
+                type: "string",
+                default: ".",
+            });
+        },
+        handler: async ({ path }) => {
+            if (path === ".") {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "projectName",
+                        message: "Project name:",
+                        default: path !== "." ? path : "my-aigne-project",
+                        validate: (input) => {
+                            if (input.trim() === "")
+                                return "Project name cannot be empty.";
+                            return true;
+                        },
                     },
-                },
-            ]);
-            path = answers.projectName;
-        }
-        path = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const isPathNotEmpty = existsSync(path) && readdirSync(path).length > 0;
-        if (isPathNotEmpty) {
-            const answers = await inquirer.prompt([
+                ]);
+                path = answers.projectName;
+            }
+            path = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            const isPathNotEmpty = existsSync(path) && readdirSync(path).length > 0;
+            if (isPathNotEmpty) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "overwrite",
+                        message: `The directory "${path}" is not empty. Do you want to remove its contents?`,
+                        default: false,
+                    },
+                ]);
+                if (!answers.overwrite) {
+                    console.log("Operation cancelled.");
+                    process.exit(0);
+                }
+            }
+            const templates = [{ name: "default" }];
+            const { template } = await inquirer.prompt([
                 {
-                    type: "confirm",
-                    name: "overwrite",
-                    message: `The directory "${path}" is not empty. Do you want to remove its contents?`,
-                    default: false,
+                    type: "list",
+                    name: "template",
+                    message: "Select a template:",
+                    choices: templates.map((t) => t.name),
+                    default: "default",
                 },
             ]);
-            if (!answers.overwrite) {
-                console.log("Operation cancelled.");
-                process.exit(0);
+            mkdirSync(path, { recursive: true });
+            const templatePath = join(import.meta.dirname, "../../templates", template);
+            if (!existsSync(templatePath))
+                throw new Error(`Template "${template}" not found.`);
+            const files = readdirSync(templatePath);
+            for (const file of files) {
+                const source = join(templatePath, file);
+                const destination = join(path, file);
+                await cp(source, destination, { recursive: true, force: true });
             }
-        }
-        const templates = [{ name: "default" }];
-        const { template } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "template",
-                message: "Select a template:",
-                choices: templates.map((t) => t.name),
-                default: "default",
-            },
-        ]);
-        mkdirSync(path, { recursive: true });
-        const templatePath = join(import.meta.dirname, "../../templates", template);
-        if (!existsSync(templatePath))
-            throw new Error(`Template "${template}" not found.`);
-        const files = readdirSync(templatePath);
-        for (const file of files) {
-            const source = join(templatePath, file);
-            const destination = join(path, file);
-            await cp(source, destination, { recursive: true, force: true });
-        }
-        console.log("\n✅ AIGNE project created successfully!");
-        console.log(`\nTo use your new agent, run:\n  cd ${relative(process.cwd(), path)} && aigne run`);
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+            console.log("\n✅ AIGNE project created successfully!");
+            console.log(`\nTo use your new agent, run:\n  cd ${relative(process.cwd(), path)} && aigne run`);
+        },
+    };
 }

package/dist/commands/observe.d.ts

@@ -1,2 +1,7 @@
-import { Command } from "commander";
-export declare function createObservabilityCommand(): Command;
+import type { CommandModule } from "yargs";
+interface ServeMCPOptions {
+    host: string;
+    port?: number;
+}
+export declare function createObservabilityCommand(): CommandModule<unknown, ServeMCPOptions>;
+export {};

package/dist/commands/observe.js

@@ -2,7 +2,6 @@ import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { startObservabilityCLIServer } from "@aigne/observability-api/cli";
 import getObservabilityDbPath from "@aigne/observability-api/db-path";
 import chalk from "chalk";
-import { Command } from "commander";
 import detectPort from "detect-port";
 const DEFAULT_PORT = () => tryOrThrow(() => {
     const { PORT } = process.env;
@@ -14,16 +13,26 @@ const DEFAULT_PORT = () => tryOrThrow(() => {
     return port;
 }, (error) => new Error(`parse PORT error ${error.message}`));
 export function createObservabilityCommand() {
-    return new Command("observe")
-        .description("Start the observability server")
-        .option("--host <host>", "Host to run the observability server on, use 0.0.0.0 to publicly expose the server", "localhost")
-        .option("--port <port>", "Port to run the observability server on", (s) => Number.parseInt(s))
-        .action(async (options) => {
-        const port = await detectPort(options.port || DEFAULT_PORT());
-        const dbUrl = getObservabilityDbPath();
-        console.log("Observability database path:", chalk.greenBright(dbUrl));
-        await startObservabilityCLIServer({ port, dbUrl });
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+    return {
+        command: "observe",
+        describe: "Start the observability server",
+        builder: (yargs) => {
+            return yargs
+                .option("host", {
+                type: "string",
+                describe: "Host to run the observability server on, use 0.0.0.0 to publicly expose the server",
+                default: "localhost",
+            })
+                .option("port", {
+                type: "number",
+                describe: "Port to run the observability server on",
+            });
+        },
+        handler: async (options) => {
+            const port = await detectPort(options.port || DEFAULT_PORT());
+            const dbUrl = getObservabilityDbPath();
+            console.log("Observability database path:", chalk.greenBright(dbUrl));
+            await startObservabilityCLIServer({ port, dbUrl });
+        },
+    };
 }

package/dist/commands/run.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
-export declare function createRunCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+export declare function createRunCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule;

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 });

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<unknown, 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<unknown, 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/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/run-with-aigne.d.ts

@@ -1,7 +1,7 @@
 import { type Agent, AIGNE, type ChatModelOptions, type Message } from "@aigne/core";
 import { LogLevel } from "@aigne/core/utils/logger.js";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
-import { Command } from "commander";
+import type { Argv } from "yargs";
 import { type ChatLoopOptions } from "./run-chat-loop.js";
 export interface RunAIGNECommandOptions {
     chat?: boolean;
@@ -17,7 +17,31 @@ export interface RunAIGNECommandOptions {
     logLevel?: LogLevel;
     force?: boolean;
 }
-export declare const createRunAIGNECommand: (name?: string) => Command;
+export declare const createRunAIGNECommand: (yargs: Argv) => Argv<{
+    chat: boolean;
+} & {
+    model: string | undefined;
+} & {
+    temperature: number | undefined;
+} & {
+    "top-p": number | undefined;
+} & {
+    "presence-penalty": number | undefined;
+} & {
+    "frequency-penalty": number | undefined;
+} & {
+    input: (string | number)[] | undefined;
+} & {
+    format: string | undefined;
+} & {
+    output: string | undefined;
+} & {
+    "output-key": string;
+} & {
+    force: boolean;
+} & {
+    "log-level": LogLevel;
+}>;
 export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
     inputKey?: string;
     argv?: string[];
@@ -41,3 +65,4 @@ export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKe
 } & Omit<RunAIGNECommandOptions, "input">): Promise<{
     result: Message;
 } | undefined>;
+export declare function stdinHasData(): Promise<boolean>;

package/dist/utils/run-with-aigne.js

@@ -4,67 +4,91 @@ import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { promisify } from "node:util";
 import { exists } from "@aigne/agent-library/utils/fs.js";
-import { AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+import { AIAgent, AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
 import { loadModel } from "@aigne/core/loader/index.js";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { isEmpty, isNonNullable, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
+import { flat, isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
-import { Command } from "commander";
 import { parse } from "yaml";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import { ZodError, ZodObject, z } from "zod";
 import { availableModels } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
-export const createRunAIGNECommand = (name = "run") => new Command(name)
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .description("Run agent with AIGNE in terminal")
-    .option("--chat", "Run chat loop in terminal", false)
-    .option("--model <provider[:model]>", `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
-    .map((i) => i.name.toLowerCase().replace(/ChatModel$/i, ""))
-    .join(", ")} (default: openai)`)
-    .option("--temperature <temperature>", "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0", customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)))
-    .option("--top-p <top-p>", "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0", customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)))
-    .option("--presence-penalty <presence-penalty>", "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0", customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
-    .option("--frequency-penalty <frequency-penalty>", "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0", customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
-    .option("--input -i <input...>", "Input to the agent, use @<file> to read from a file")
-    .option("--format <format>", "Input format for the agent (available: text, json, yaml default: text)")
-    .option("--output -o <output>", "Output file to save the result (default: stdout)")
-    .option("--output-key <output-key>", "Key in the result to save to the output file", DEFAULT_OUTPUT_KEY)
-    .option("--force", "Truncate the output file if it exists, and create directory if the output path is not exists", false)
-    .option("--log-level <level>", `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`, customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)), getLevelFromEnv(logger.options.ns) || LogLevel.INFO);
+export const createRunAIGNECommand = (yargs) => yargs
+    .option("chat", {
+    describe: "Run chat loop in terminal",
+    type: "boolean",
+    default: false,
+})
+    .option("model", {
+    describe: `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
+        .map((i) => i.name.toLowerCase().replace(/ChatModel$/i, ""))
+        .join(", ")} (default: openai)`,
+    type: "string",
+})
+    .option("temperature", {
+    describe: "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0",
+    type: "number",
+    coerce: customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)),
+})
+    .option("top-p", {
+    describe: "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0",
+    type: "number",
+    coerce: customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)),
+})
+    .option("presence-penalty", {
+    describe: "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0",
+    type: "number",
+    coerce: customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
+})
+    .option("frequency-penalty", {
+    describe: "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0",
+    type: "number",
+    coerce: customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
+})
+    .option("input", {
+    describe: "Input to the agent, use @<file> to read from a file",
+    type: "array",
+    alias: "i",
+})
+    .option("format", {
+    describe: "Input format for the agent (available: text, json, yaml default: text)",
+    type: "string",
+})
+    .option("output", {
+    describe: "Output file to save the result (default: stdout)",
+    type: "string",
+    alias: "o",
+})
+    .option("output-key", {
+    describe: "Key in the result to save to the output file",
+    type: "string",
+    default: DEFAULT_OUTPUT_KEY,
+})
+    .option("force", {
+    describe: "Truncate the output file if it exists, and create directory if the output path is not exists",
+    type: "boolean",
+    default: false,
+})
+    .option("log-level", {
+    describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
+    type: "string",
+    default: getLevelFromEnv(logger.options.ns) || LogLevel.INFO,
+    coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
+});
 export async function parseAgentInputByCommander(agent, options = {}) {
-    const cmd = new Command()
-        .description(`Run agent ${agent.name} with AIGNE`)
-        .allowUnknownOption(true)
-        .allowExcessArguments(true);
-    const inputSchemaShape = agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : [];
-    for (const option of inputSchemaShape) {
-        cmd.option(`--input-${option} <${option}>`);
-    }
-    const input = await new Promise((resolve, reject) => {
-        cmd
-            .action(async (agentInputOptions) => {
-            try {
-                const input = Object.fromEntries((await Promise.all(Object.entries(agentInputOptions).map(async ([key, value]) => {
-                    let k = key.replace(/^input/, "");
-                    k = k.charAt(0).toLowerCase() + k.slice(1);
-                    if (!k)
-                        return null;
-                    if (typeof value === "string" && value.startsWith("@")) {
-                        value = await readFile(value.slice(1), "utf8");
-                    }
-                    return [k, value];
-                }))).filter(isNonNullable));
-                resolve(input);
-            }
-            catch (error) {
-                reject(error);
-            }
-        })
-            .parseAsync(options.argv ?? process.argv)
-            .catch((error) => reject(error));
-    });
+    const inputSchemaShape = flat(agent instanceof AIAgent ? agent.inputKey : undefined, agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : []);
+    const parsedInput = await yargs().parseAsync(options.argv ?? process.argv);
+    const input = Object.fromEntries(await Promise.all(inputSchemaShape.map(async (key) => {
+        const k = `input${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+        let value = parsedInput[k];
+        if (typeof value === "string" && value.startsWith("@")) {
+            value = await readFile(value.slice(1), "utf8");
+        }
+        return [key, value];
+    })));
     const rawInput = options.input ||
         (isatty(process.stdin.fd) || !(await stdinHasData())
             ? null
@@ -100,10 +124,8 @@ export const parseModelOption = (model) => {
     return { provider, name };
 };
 export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
-    await createRunAIGNECommand()
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true)
-        .action(async (options) => {
+    await yargs()
+        .command("$0", "Run an agent with AIGNE", (yargs) => createRunAIGNECommand(yargs), async (options) => {
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
@@ -134,7 +156,9 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
             await aigne.shutdown();
         }
     })
-        .parseAsync(argv)
+        .alias("h", "help")
+        .alias("v", "version")
+        .parseAsync(hideBin(argv))
         .catch((error) => {
         console.error(`${chalk.red("Error:")} ${error.message}`);
         process.exit(1);
@@ -186,7 +210,7 @@ export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptio
     }
     return { result };
 }
-async function stdinHasData() {
+export async function stdinHasData() {
     const stats = await promisify(fstat)(0);
     return stats.isFIFO() || stats.isFile();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.27.0",
+  "version": "1.27.1-1",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -51,7 +51,6 @@
     "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
     "chalk": "^5.4.1",
-    "commander": "^14.0.0",
     "crypto": "^1.0.1",
     "detect-port": "^2.1.0",
     "dotenv-flow": "^4.1.0",
@@ -69,21 +68,22 @@
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
+    "yargs": "^18.0.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.6",
-    "@aigne/aigne-hub": "^0.3.0",
     "@aigne/agentic-memory": "^1.0.6",
-    "@aigne/anthropic": "^0.10.2",
+    "@aigne/agent-library": "^1.21.6",
     "@aigne/bedrock": "^0.8.6",
+    "@aigne/aigne-hub": "^0.3.0",
+    "@aigne/core": "^1.39.0",
     "@aigne/deepseek": "^0.7.6",
+    "@aigne/anthropic": "^0.10.2",
     "@aigne/default-memory": "^1.0.6",
     "@aigne/gemini": "^0.8.6",
     "@aigne/observability-api": "^0.8.2",
     "@aigne/open-router": "^0.7.6",
-    "@aigne/ollama": "^0.7.6",
-    "@aigne/core": "^1.39.0",
     "@aigne/openai": "^0.10.6",
-    "@aigne/xai": "^0.7.6"
+    "@aigne/xai": "^0.7.6",
+    "@aigne/ollama": "^0.7.6"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",
@@ -92,6 +92,7 @@
     "@types/glob": "^9.0.0",
     "@types/gradient-string": "^1.1.6",
     "@types/node": "^24.0.12",
+    "@types/yargs": "^17.0.33",
     "archiver": "^7.0.1",
     "hono": "4.8.4",
     "npm-run-all": "^4.1.5",