@aigne/cli 1.25.1 → 1.26.1-0

package/dist/utils/load-aigne.js

@@ -1,9 +1,10 @@
-import { existsSync } from "node:fs";
-import { appendFile, readFile } from "node:fs/promises";
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { AIGNE } from "@aigne/core";
-import { loadModel } from "@aigne/core/loader/index.js";
+import { loadAIGNEFile, loadModel } from "@aigne/core/loader/index.js";
+import { logger } from "@aigne/core/utils/logger.js";
 import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
 import crypto from "crypto";
 import inquirer from "inquirer";
@@ -14,28 +15,40 @@ import { parse, stringify } from "yaml";
 import { availableMemories, availableModels } from "../constants.js";
 import { parseModelOption } from "./run-with-aigne.js";
 const aes = new AesCrypter();
-const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+export const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+export const encrypt = (m, s, i) => aes.encrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
 const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
+const unescapeFn = (str) => (str + "===".slice((str.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+export const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
+export const decodeEncryptionKey = (str) => new Uint8Array(Buffer.from(unescapeFn(str), "base64"));
+const TEST_ENV = process.env.CI || process.env.NODE_ENV === "test";
+export const AIGNE_ENV_FILE = TEST_ENV
+    ? join(homedir(), ".aigne", "test-aigne-hub-connected.yaml")
+    : join(homedir(), ".aigne", "aigne-hub-connected.yaml");
 const request = async (config) => {
-    const response = await fetch(config.url, { method: config.method || "GET" });
-    if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+    const headers = {};
+    if (config.requestCount !== undefined) {
+        headers["X-Request-Count"] = config.requestCount.toString();
     }
+    const response = await fetch(config.url, { method: config.method || "GET", headers });
+    if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
     const data = await response.json();
     return { data };
 };
 const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
 const ACCESS_KEY_PREFIX = "/api/access-key";
 const ACCESS_KEY_SESSION_API = `${ACCESS_KEY_PREFIX}/session`;
-const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
+export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
     const sessionURL = withQuery(joinURL(connectUrl, ACCESS_KEY_SESSION_API), { sid: sessionId });
+    let requestCount = 0;
     const condition = async () => {
-        const { data: session } = await request({ url: sessionURL });
+        const { data: session } = await request({ url: sessionURL, requestCount });
+        requestCount++;
         return Boolean(session.accessKeyId && session.accessKeySecret);
     };
     await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
-    const { data: session } = await request({ url: sessionURL });
+    const { data: session } = await request({ url: sessionURL, requestCount });
     await request({ url: sessionURL, method: "DELETE" });
     return {
         ...session,
@@ -46,7 +59,7 @@ const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout
 function baseWrapSpinner(_, waiting) {
     return Promise.resolve(waiting());
 }
-async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, }) {
+export async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, }) {
     try {
         const startSessionURL = joinURL(connectUrl, ACCESS_KEY_SESSION_API);
         const { data: session } = await request({ url: startSessionURL, method: "POST" });
@@ -80,13 +93,11 @@ const AGENT_HUB_PROVIDER = "aignehub";
 const DEFAULT_AIGNE_HUB_MODEL = "openai/gpt-4o";
 const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = `${AGENT_HUB_PROVIDER}:${DEFAULT_AIGNE_HUB_MODEL}`;
 const DEFAULT_URL = "https://hub.aigne.io/";
-const formatModelName = async (models, model, inquirerPrompt) => {
-    if (process.env.NODE_ENV === "test")
-        return model;
+export const formatModelName = async (models, model, inquirerPrompt) => {
     if (!model)
         return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
     const { provider, name } = parseModelOption(model);
-    if (!provider || !name) {
+    if (!provider) {
         return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
     }
     const providerName = provider.replace(/-/g, "");
@@ -99,6 +110,9 @@ const formatModelName = async (models, model, inquirerPrompt) => {
     if (m.apiKeyEnvName && process.env[m.apiKeyEnvName]) {
         return model;
     }
+    if (TEST_ENV) {
+        return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
+    }
     const result = await inquirerPrompt({
         type: "list",
         name: "useAigneHub",
@@ -119,88 +133,106 @@ const formatModelName = async (models, model, inquirerPrompt) => {
         return model;
     return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
 };
-export async function loadAIGNE(path, options, checkAuthorizeOptions) {
+export async function connectToAIGNEHub(url) {
+    const { origin, host } = new URL(url);
+    const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
+    const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
+    const blocklet = await blockletInfo.json();
+    const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === "z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ");
+    try {
+        const result = await createConnect({
+            connectUrl: connectUrl,
+            connectAction: "gen-simple-access-key",
+            source: `@aigne/cli connect to AIGNE hub`,
+            closeOnSuccess: true,
+            openPage: (pageUrl) => open(pageUrl),
+        });
+        const accessKeyOptions = {
+            accessKey: result.accessKeySecret,
+            url: joinURL(origin, aigneHubMount?.mountPoint || ""),
+        };
+        // After redirection, write the AIGNE Hub access token
+        const aigneDir = join(homedir(), ".aigne");
+        if (!existsSync(aigneDir)) {
+            mkdirSync(aigneDir, { recursive: true });
+        }
+        const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+        await writeFile(AIGNE_ENV_FILE, stringify({
+            ...envs,
+            [host]: {
+                AIGNE_HUB_API_KEY: accessKeyOptions.accessKey,
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+        })).catch((err) => {
+            logger.error("Failed to write AIGNE Hub access token to .aigne/aigne-hub-connected.yaml", err.message);
+            throw err;
+        });
+        return accessKeyOptions;
+    }
+    catch (error) {
+        logger.error("Failed to connect to AIGNE Hub", error.message);
+        return { accessKey: undefined, url: undefined };
+    }
+}
+export async function loadAIGNE(path, options, actionOptions) {
     const models = availableModels();
-    const AIGNE_ENV_FILE = join(homedir(), ".aigne", "aigne-hub-connected.yaml");
     const AIGNE_HUB_URL = process.env.AIGNE_HUB_API_URL || DEFAULT_URL;
     const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
-    const inquirerPrompt = (checkAuthorizeOptions?.inquirerPromptFn ??
+    const inquirerPrompt = (actionOptions?.inquirerPromptFn ??
         inquirer.prompt);
+    const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
     let accessKeyOptions = {};
-    const modelName = await formatModelName(models, options?.model || "", inquirerPrompt);
-    if (!process.env.CI) {
-        if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
-            const { origin, host } = new URL(AIGNE_HUB_URL);
-            try {
-                // 检查 aigne-hub access token
-                if (!existsSync(AIGNE_ENV_FILE)) {
-                    throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
-                }
-                const data = await readFile(AIGNE_ENV_FILE, "utf8");
-                if (!data.includes("AIGNE_HUB_API_KEY")) {
-                    throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-                }
-                const envs = parse(data);
-                if (!envs[host]) {
-                    throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
-                }
-                const env = envs[host];
-                if (!env.AIGNE_HUB_API_KEY) {
-                    throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-                }
-                accessKeyOptions = {
-                    accessKey: env.AIGNE_HUB_API_KEY,
-                    url: joinURL(env.AIGNE_HUB_API_URL),
-                };
+    const modelName = await formatModelName(models, options?.model || `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`, inquirerPrompt);
+    if (TEST_ENV && !actionOptions?.runTest) {
+        const model = await loadModel(models, parseModelOption(modelName), undefined, accessKeyOptions);
+        return await AIGNE.load(path, { models, memories: availableMemories, model });
+    }
+    if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
+        const { host } = new URL(AIGNE_HUB_URL);
+        try {
+            // aigne-hub access token
+            if (!existsSync(AIGNE_ENV_FILE)) {
+                throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
+            }
+            const data = await readFile(AIGNE_ENV_FILE, "utf8");
+            if (!data.includes("AIGNE_HUB_API_KEY")) {
+                throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+            }
+            const envs = parse(data);
+            if (!envs[host]) {
+                throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
             }
-            catch (error) {
-                if (error instanceof Error && error.message.includes("login first")) {
-                    // If none or invalid, prompt the user to proceed
-                    const subscribePrompt = await inquirerPrompt({
-                        type: "list",
-                        name: "subscribe",
-                        message: "No LLM API Keys or AIGNE Hub connections found, select your preferred way to continue:",
-                        choices: [
-                            {
-                                name: "Connect to AIGNE Hub with just a few clicks, free credits eligible for new users (Recommended)",
-                                value: true,
-                            },
-                            { name: "Exit and configure my own LLM API Keys", value: false },
-                        ],
-                        default: true,
-                    });
-                    if (!subscribePrompt.subscribe) {
-                        console.warn("The AIGNE Hub connection has been cancelled");
-                        process.exit(0);
-                    }
-                    const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
-                    const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
-                    const blocklet = await blockletInfo.json();
-                    const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === "z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ");
-                    try {
-                        const result = await createConnect({
-                            connectUrl: connectUrl,
-                            connectAction: "gen-simple-access-key",
-                            source: `@aigne/cli connect to AIGNE hub`,
-                            closeOnSuccess: true,
-                            openPage: (pageUrl) => open(pageUrl),
-                        });
-                        accessKeyOptions = {
-                            accessKey: result.accessKeySecret,
-                            url: joinURL(origin, aigneHubMount?.mountPoint || ""),
-                        };
-                        // After redirection, write the AIGNE Hub access token
-                        await appendFile(AIGNE_ENV_FILE, stringify({
-                            [host]: {
-                                AIGNE_HUB_API_KEY: accessKeyOptions.accessKey,
-                                AIGNE_HUB_API_URL: accessKeyOptions.url,
-                            },
-                        }));
-                    }
-                    catch (error) {
-                        console.error(error);
-                    }
+            const env = envs[host];
+            if (!env.AIGNE_HUB_API_KEY) {
+                throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+            }
+            accessKeyOptions = {
+                accessKey: env.AIGNE_HUB_API_KEY,
+                url: joinURL(env.AIGNE_HUB_API_URL),
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("login first")) {
+                // If none or invalid, prompt the user to proceed
+                const subscribePrompt = await inquirerPrompt({
+                    type: "list",
+                    name: "subscribe",
+                    message: "No LLM API Keys or AIGNE Hub connections found, select your preferred way to continue:",
+                    choices: [
+                        {
+                            name: "Connect to AIGNE Hub with just a few clicks, free credits eligible for new users (Recommended)",
+                            value: true,
+                        },
+                        { name: "Exit and configure my own LLM API Keys", value: false },
+                    ],
+                    default: true,
+                });
+                if (!subscribePrompt.subscribe) {
+                    console.warn("The AIGNE Hub connection has been cancelled");
+                    process.exit(0);
                 }
+                accessKeyOptions = await connectToAIGNEHub(connectUrl);
             }
         }
     }

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[];

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

@@ -4,67 +4,90 @@ 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 { 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
@@ -96,14 +119,12 @@ export async function parseAgentInputByCommander(agent, options = {}) {
     return input;
 }
 export const parseModelOption = (model) => {
-    const { provider, name } = (model || process.env.MODEL)?.match(/(?<provider>[^:]+)(:(?<name>(\S+)))?/)?.groups ?? {};
+    const { provider, name } = (model || process.env.MODEL)?.match(/(?<provider>[^:]*)(:(?<name>(\S+)))?/)?.groups ?? {};
     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,6 +155,8 @@ 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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.25.1",
+  "version": "1.26.1-0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -24,26 +24,60 @@
     "bunwrapper": "dist/bunwrapper.js"
   },
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
+    ".": "./dist/index.js",
     "./*": "./dist/*"
   },
   "typesVersions": {
     "*": {
+      ".": [
+        "./lib/dts/index.d.ts"
+      ],
       "*": [
         "./dist/*"
       ]
     }
   },
+  "scripts": {
+    "lint": "tsc --noEmit",
+    "build": "tsc --build tsconfig.build.json",
+    "clean": "rimraf dist test/coverage templates/coverage",
+    "prepublishOnly": "run-s clean build",
+    "test": "run-s test:src test:templates",
+    "test:coverage": "run-s test:src:coverage test:templates:coverage",
+    "test:src": "bun --cwd test test",
+    "test:src:coverage": "bun --cwd test test --coverage --coverage-reporter=lcov --coverage-reporter=text",
+    "test:templates": "cd templates && node --test",
+    "test:templates:coverage": "cd templates && mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info --test-reporter=spec --test-reporter-destination=stdout"
+  },
   "dependencies": {
+    "@aigne/agent-library": "workspace:^",
+    "@aigne/agentic-memory": "workspace:^",
+    "@aigne/aigne-hub": "workspace:^",
+    "@aigne/anthropic": "workspace:^",
+    "@aigne/bedrock": "workspace:^",
+    "@aigne/core": "workspace:^",
+    "@aigne/deepseek": "workspace:^",
+    "@aigne/default-memory": "workspace:^",
+    "@aigne/gemini": "workspace:^",
     "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.2",
+    "@aigne/observability-api": "workspace:^",
+    "@aigne/ollama": "workspace:^",
+    "@aigne/open-router": "workspace:^",
+    "@aigne/openai": "workspace:^",
+    "@aigne/xai": "workspace:^",
+    "@blocklet/aigne-hub": "^0.2.17",
     "@inquirer/prompts": "^7.6.0",
+    "@inquirer/type": "^3.0.8",
     "@listr2/prompt-adapter-inquirer": "^3.0.1",
     "@modelcontextprotocol/sdk": "^1.15.0",
     "@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",
@@ -61,21 +95,8 @@
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
-    "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.5",
-    "@aigne/agentic-memory": "^1.0.5",
-    "@aigne/aigne-hub": "^0.2.1",
-    "@aigne/anthropic": "^0.10.1",
-    "@aigne/core": "^1.38.1",
-    "@aigne/default-memory": "^1.0.5",
-    "@aigne/deepseek": "^0.7.5",
-    "@aigne/bedrock": "^0.8.5",
-    "@aigne/gemini": "^0.8.5",
-    "@aigne/ollama": "^0.7.5",
-    "@aigne/open-router": "^0.7.5",
-    "@aigne/observability-api": "^0.8.1",
-    "@aigne/openai": "^0.10.5",
-    "@aigne/xai": "^0.7.5"
+    "yargs": "^18.0.0",
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",
@@ -84,21 +105,12 @@
     "@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",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "ufo": "^1.6.1"
-  },
-  "scripts": {
-    "lint": "tsc --noEmit",
-    "build": "tsc --build tsconfig.build.json",
-    "clean": "rimraf dist test/coverage templates/coverage",
-    "test": "run-s test:src test:templates",
-    "test:coverage": "run-s test:src:coverage test:templates:coverage",
-    "test:src": "bun --cwd test test",
-    "test:src:coverage": "bun --cwd test test --coverage --coverage-reporter=lcov --coverage-reporter=text",
-    "test:templates": "cd templates && node --test",
-    "test:templates:coverage": "cd templates && mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info --test-reporter=spec --test-reporter-destination=stdout"
   }
-}
+}