@aigne/cli 1.26.0 → 1.26.1-0

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() {
@@ -16,7 +17,7 @@ function getAIGNEFilePath() {
 }
 const aigneFilePath = getAIGNEFilePath();
 createAIGNECommand({ aigneFilePath })
-    .parseAsync(["", "", ...process.argv.slice(aigneFilePath ? 3 : 2)])
+    .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,8 @@
-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";
 import { createRunCommand } from "./run.js";
@@ -8,15 +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())
-        .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,98 @@
+import assert from "node:assert";
+import { spawnSync } from "node:child_process";
+import { mkdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AIGNE } from "@aigne/core";
+import { joinURL } from "ufo";
+import { ZodObject, ZodString } from "zod";
+import { availableModels } from "../constants.js";
+import { downloadAndExtract } from "../utils/download.js";
+import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
+const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
+export function createAppCommands() {
+    return [
+        {
+            command: "doc-smith",
+            describe: "Generate professional documents by doc-smith",
+            aliases: ["docsmith", "doc"],
+            builder: async (yargs) => {
+                const aigne = await loadApplication({ name: "doc-smith" });
+                for (const agent of aigne.agents) {
+                    yargs.command(agent.name, agent.description || "", (yargs) => {
+                        const options = Object.entries(agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {});
+                        for (const [option, config] of options) {
+                            yargs.option(option, {
+                                // TODO: support more types
+                                type: config instanceof ZodString ? "string" : "string",
+                                description: config.description,
+                            });
+                            if (!(config.isNullable() || config.isOptional())) {
+                                yargs.demandOption(option);
+                            }
+                        }
+                    }, async (argv) => {
+                        try {
+                            await runAgentWithAIGNE(aigne, agent, { input: argv });
+                        }
+                        finally {
+                            await aigne.shutdown();
+                        }
+                    });
+                }
+                yargs.version('hello world');
+                return yargs.demandCommand();
+            },
+            handler: () => { },
+        },
+    ];
+}
+async function loadApplication({ name }) {
+    const info = await shouldDownloadNewVersion(name);
+    if (info.shouldDownload) {
+        assert(info.url, "Package URL should be defined when downloading");
+        // TODO: clean up old versions
+        await mkdir(info.dir, { recursive: true });
+        await downloadAndExtract(info.url.toString(), info.dir, { strip: 1 });
+        spawnSync("npm", ["install", "--omit", "dev"], { cwd: info.dir, stdio: "inherit" });
+    }
+    return AIGNE.load(info.dir, { models: availableModels() });
+}
+async function shouldDownloadNewVersion(name, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
+    const nameWithOrg = `@aigne/${name}`;
+    const dir = join(homedir(), ".aigne", "registry.npmjs.org", nameWithOrg);
+    const s = await stat(join(dir, "package.json")).catch((error) => {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+    if (!s)
+        return {
+            shouldDownload: true,
+            dir,
+            url: await getNpmTgzInfo(nameWithOrg).then((info) => info.tarballUrl),
+        };
+    const lastModified = s.mtimeMs;
+    const now = Date.now();
+    if (now - lastModified > cacheTimeMs) {
+        const version = JSON.parse(await readFile(join(dir, "package.json"), "utf-8")).version;
+        const latest = await getNpmTgzInfo(`@aigne/${name}`);
+        if (version !== latest.version) {
+            return { shouldDownload: true, url: latest.tarballUrl, dir };
+        }
+    }
+    return { shouldDownload: false, dir };
+}
+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 tarballUrl = data.versions[latestVersion].dist.tarball;
+    return {
+        version: latestVersion,
+        tarballUrl,
+    };
+}

package/dist/commands/connect.d.ts

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

package/dist/commands/connect.js

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { getUserInfo } from "@blocklet/aigne-hub/api/user";
+import chalk from "chalk";
+import { parse } from "yaml";
+import { AIGNE_ENV_FILE, connectToAIGNEHub } from "../utils/load-aigne.js";
+async function getConnectionStatus() {
+    if (!existsSync(AIGNE_ENV_FILE)) {
+        return [];
+    }
+    try {
+        const data = await readFile(AIGNE_ENV_FILE, "utf8");
+        const envs = parse(data);
+        const statusList = [];
+        for (const [host, config] of Object.entries(envs)) {
+            statusList.push({
+                host,
+                apiUrl: config.AIGNE_HUB_API_URL,
+                apiKey: config.AIGNE_HUB_API_KEY,
+            });
+        }
+        return statusList;
+    }
+    catch {
+        return [];
+    }
+}
+async function displayStatus(statusList) {
+    if (statusList.length === 0) {
+        console.log(chalk.yellow("No AIGNE Hub connections found."));
+        console.log("Use 'aigne connect <url>' to connect to a hub.");
+        return;
+    }
+    console.log(chalk.blue("AIGNE Hub Connection Status:\n"));
+    for (const status of statusList) {
+        const userInfo = await getUserInfo({
+            baseUrl: status.apiUrl,
+            accessKey: status.apiKey,
+        }).catch((e) => {
+            console.error(e);
+            return null;
+        });
+        const statusIcon = userInfo ? chalk.green("✓") : chalk.red("✗");
+        const statusText = userInfo ? "Connected" : "Disconnected";
+        console.log(`${statusIcon} ${chalk.bold(status.host)}`);
+        console.log(`   Status: ${statusText}`);
+        if (userInfo) {
+            console.log(`   User: ${userInfo?.user.fullName}`);
+            console.log(`   Email: ${userInfo?.user.email}`);
+            if (userInfo?.creditBalance) {
+                console.log(`   Plan: ${userInfo?.creditBalance?.balance}/${userInfo?.creditBalance?.total}`);
+            }
+            console.log(`   Billing URL: ${userInfo?.paymentLink}`);
+        }
+        console.log("");
+    }
+}
+export function createConnectCommand() {
+    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<{}, 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<{}, 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,7 @@
-import type { Command } from "commander";
-export declare function createRunCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+export declare function createRunCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule;
+export declare function getLocalPackagePathFromUrl(url: string, { subdir }?: {
+    subdir?: string;
+}): string;