@aigne/cli 1.26.1-0 → 1.27.0

package/dist/commands/run.js

@@ -12,109 +12,94 @@ 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 {
-        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 }));
+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),
                             },
-                        });
-                        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(`\
+            },
+            {
+                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(`\
 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}`);
                         }
-                        ctx.agent = entryAgent;
-                    },
-                },
-            ], {
-                rendererOptions: {
-                    collapseSubtasks: false,
-                    showErrorMessage: false,
-                    timer: PRESET_TIMER,
+                    }
+                    else {
+                        entryAgent = aigne.agents[0];
+                        if (!entryAgent)
+                            throw new Error(`No any agent found in ${aigne.rootDir}`);
+                    }
+                    ctx.agent = entryAgent;
                 },
-            }).run();
-            assert(aigne);
-            assert(agent);
-            const input = await parseAgentInputByCommander(agent, options);
-            try {
-                await runAgentWithAIGNE(aigne, agent, { ...options, input });
-            }
-            finally {
-                await aigne.shutdown();
-            }
-        },
-    };
+            },
+        ], {
+            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);
 }
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
@@ -136,7 +121,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);
@@ -148,7 +133,7 @@ function prepareDirs(path, options) {
     }
     return { cacheDir, dir };
 }
-export function getLocalPackagePathFromUrl(url, { subdir } = {}) {
+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,11 +1,4 @@
-import type { CommandModule } from "yargs";
-interface ServeMCPOptions {
-    path: string;
-    host: string;
-    port?: number;
-    pathname: string;
-}
-export declare function createServeMCPCommand({ aigneFilePath, }?: {
+import { Command } from "commander";
+export declare function createServeMCPCommand({ aigneFilePath }?: {
     aigneFilePath?: string;
-}): CommandModule<{}, ServeMCPOptions>;
-export {};
+}): Command;

package/dist/commands/serve-mcp.js

@@ -1,5 +1,6 @@
 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(() => {
@@ -11,45 +12,26 @@ 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 {
-        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}`);
-        },
-    };
+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);
 }

package/dist/commands/test.d.ts

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

package/dist/commands/test.js

@@ -1,25 +1,19 @@
 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 {
-        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" });
-        },
-    };
+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);
 }

package/dist/utils/aigne-hub-user.d.ts

@@ -0,0 +1,16 @@
+export interface UserInfoResult {
+    user: Record<string, any>;
+    enableCredit: boolean;
+    creditBalance: {
+        balance: string;
+        total: string;
+        grantCount: number;
+        pendingCredit: string;
+    } | null;
+    paymentLink: string | null;
+    profileLink: string;
+}
+export declare function getUserInfo({ baseUrl, accessKey, }: {
+    baseUrl: string;
+    accessKey: string;
+}): Promise<UserInfoResult>;

package/dist/utils/aigne-hub-user.js

@@ -0,0 +1,12 @@
+import { joinURL } from "ufo";
+export async function getUserInfo({ baseUrl, accessKey, }) {
+    const response = await fetch(joinURL(baseUrl, "/api/user/info"), {
+        headers: {
+            Authorization: `Bearer ${accessKey}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(`Failed to fetch user info: ${response.statusText}`);
+    const data = await response.json();
+    return data;
+}

package/dist/utils/download.d.ts

@@ -1,3 +1 @@
-export declare function downloadAndExtract(url: string, dir: string, options?: {
-    strip?: number;
-}): Promise<void>;
+export declare function downloadAndExtract(url: string, dir: string): 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, options = {}) {
+export async function downloadAndExtract(url, dir) {
     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, options = {}) {
         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, ...options })));
+        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir })));
     }
     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 type { Argv } from "yargs";
+import { Command } from "commander";
 import { type ChatLoopOptions } from "./run-chat-loop.js";
 export interface RunAIGNECommandOptions {
     chat?: boolean;
@@ -17,31 +17,7 @@ export interface RunAIGNECommandOptions {
     logLevel?: LogLevel;
     force?: boolean;
 }
-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 const createRunAIGNECommand: (name?: string) => Command;
 export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
     inputKey?: string;
     argv?: string[];

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

@@ -4,90 +4,67 @@ 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 { AIAgent, AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+import { 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 { flat, isEmpty, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
+import { isEmpty, isNonNullable, 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 { 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 = (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 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 async function parseAgentInputByCommander(agent, options = {}) {
-    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 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 rawInput = options.input ||
         (isatty(process.stdin.fd) || !(await stdinHasData())
             ? null
@@ -123,8 +100,10 @@ export const parseModelOption = (model) => {
     return { provider, name };
 };
 export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
-    await yargs()
-        .command("$0", "Run an agent with AIGNE", (yargs) => createRunAIGNECommand(yargs), async (options) => {
+    await createRunAIGNECommand()
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true)
+        .action(async (options) => {
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
@@ -155,8 +134,6 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
             await aigne.shutdown();
         }
     })
-        .alias("h", "help")
-        .alias("v", "version")
         .parseAsync(argv)
         .catch((error) => {
         console.error(`${chalk.red("Error:")} ${error.message}`);