@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/commands/app.js

@@ -1,54 +0,0 @@
-import { fork } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { NeedReinstallBetaError, NeedReinstallError } from "./app/upgrade.js";
-const builtinApps = [
-    {
-        name: "doc-smith",
-        packageName: "@aigne/doc-smith",
-        describe: "Generate and maintain project docs — powered by agents.",
-        aliases: ["docsmith", "doc"],
-    },
-    {
-        name: "web-smith",
-        packageName: "@aigne/web-smith",
-        describe: "Generate and maintain project website pages — powered by agents.",
-        aliases: ["websmith", "web"],
-    },
-];
-export function createAppCommands({ argv } = {}) {
-    return builtinApps.map((app) => ({
-        command: app.name,
-        describe: app.describe,
-        aliases: app.aliases,
-        builder: async (y) => y.help(false).version(false).strict(false),
-        handler: async () => {
-            let retried = false;
-            let retryWithBeta = false;
-            while (true) {
-                const child = fork(join(dirname(fileURLToPath(import.meta.url)), "./app/cli.js"), argv, {
-                    stdio: "inherit",
-                    env: {
-                        ...process.env,
-                        AIGNE_APP_NAME: app.name,
-                        AIGNE_APP_PACKAGE_NAME: app.packageName,
-                        AIGNE_APP_DESCRIPTION: app.describe,
-                        AIGNE_APP_USE_BETA_APPS: retryWithBeta ? "1" : "0",
-                    },
-                });
-                const code = await new Promise((resolve) => {
-                    child.on("exit", (code) => resolve(code));
-                });
-                if (code === NeedReinstallError.code || code === NeedReinstallBetaError.code) {
-                    if (retried)
-                        process.exit(1);
-                    retryWithBeta = code === NeedReinstallBetaError.code;
-                    retried = true;
-                }
-                else {
-                    process.exit(code);
-                }
-            }
-        },
-    }));
-}

package/dist/commands/create.d.ts

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

package/dist/commands/create.js

@@ -1,74 +0,0 @@
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
-import { cp } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import inquirer from "inquirer";
-export function createCreateCommand() {
-    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([
-                    {
-                        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: "list",
-                    name: "template",
-                    message: "Select a template:",
-                    choices: templates.map((t) => t.name),
-                    default: "default",
-                },
-            ]);
-            mkdirSync(path, { recursive: true });
-            const templatePath = join(dirname(fileURLToPath(import.meta.url)), "../../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`);
-        },
-    };
-}

package/dist/commands/deploy.d.ts

@@ -1,11 +0,0 @@
-import type { CommandModule } from "yargs";
-interface DeployOptions {
-    path?: string;
-    endpoint?: string;
-}
-export declare function fileExists(p: string): Promise<boolean>;
-export declare const DEPLOYED_FILE: string;
-export declare function run(cmd: string, args?: string[], opts?: any): Promise<string>;
-export declare function createDeployCommands(): CommandModule<unknown, DeployOptions>;
-export declare const deploy: (path: string, endpoint: string) => Promise<void>;
-export {};

package/dist/commands/deploy.js

@@ -1,255 +0,0 @@
-import { spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access, copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Listr } from "@aigne/listr2";
-import { input as inputInquirer, select as selectInquirer } from "@inquirer/prompts";
-import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
-import { parse, stringify } from "yaml";
-import { isTest } from "../utils/aigne-hub/constants.js";
-export async function fileExists(p) {
-    try {
-        await access(p, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export const DEPLOYED_FILE = isTest ? "deployed.test.yaml" : "deployed.yaml";
-export async function run(cmd, args = [], opts = {}) {
-    return new Promise((resolve, reject) => {
-        const { catchOutput = true, ...rest } = opts;
-        const spawnOpts = { shell: true, ...rest, stdio: catchOutput ? "pipe" : "inherit" };
-        const child = spawn(cmd, args, spawnOpts);
-        if (catchOutput) {
-            let stdout = "";
-            let stderr = "";
-            child.stdout?.on("data", (data) => {
-                stdout += data.toString();
-            });
-            child.stderr?.on("data", (data) => {
-                stderr += data.toString();
-            });
-            child.on("close", (code) => {
-                if (code === 0) {
-                    resolve(stdout.trim());
-                }
-                else {
-                    reject(new Error(stderr.trim() || `Process failed with code ${code}`));
-                }
-            });
-        }
-        else {
-            child.on("close", (code) => {
-                if (code === 0) {
-                    resolve("");
-                }
-                else {
-                    reject(new Error(`${cmd} ${args.join(" ")} failed with code ${code}`));
-                }
-            });
-        }
-    });
-}
-export function createDeployCommands() {
-    return {
-        command: "deploy",
-        describe: "Deploy an aigne application",
-        builder: (yargs) => {
-            return yargs
-                .option("path", {
-                type: "string",
-            })
-                .option("endpoint", {
-                type: "string",
-                describe: "Deploy an aigne application to a specified endpoint.",
-            });
-        },
-        handler: async (argv) => {
-            const path = argv.path;
-            const endpoint = argv.endpoint;
-            if (!path) {
-                console.error("path is required");
-                process.exit(1);
-            }
-            if (!endpoint) {
-                console.error("endpoint is required");
-                process.exit(1);
-            }
-            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            await deploy(absolutePath, endpoint);
-        },
-    };
-}
-async function copyDir(src, dest) {
-    await mkdir(dest, { recursive: true });
-    const entries = await readdir(src, { withFileTypes: true });
-    const skip = [".deploy", "node_modules"];
-    for (const entry of entries) {
-        const srcPath = join(src, entry.name);
-        const destPath = join(dest, entry.name);
-        if (skip.includes(entry.name))
-            continue;
-        if (entry.isDirectory()) {
-            await copyDir(srcPath, destPath);
-        }
-        else {
-            await copyFile(srcPath, destPath);
-        }
-    }
-}
-export const deploy = async (path, endpoint) => {
-    const aigneHomeDir = join(homedir(), ".aigne");
-    if (!(await fileExists(aigneHomeDir))) {
-        await mkdir(aigneHomeDir, { recursive: true });
-    }
-    const deployRoot = join(path, ".deploy");
-    const agentDest = join(deployRoot, "agent");
-    const tasks = new Listr([
-        {
-            title: "Prepare deploy environment",
-            task: async (ctx, task) => {
-                ctx.logs = [];
-                task.output = "Preparing deploy environment...";
-                const entryFile = join(path, "aigne.yaml");
-                if (!(await fileExists(entryFile))) {
-                    throw new Error(`Entry file not found: ${entryFile}`);
-                }
-                await rm(deployRoot, { recursive: true, force: true });
-                task.output = "Copying template files...";
-                const templatePath = join(dirname(fileURLToPath(import.meta.url)), "../../templates/blocklet");
-                await copyDir(templatePath, deployRoot);
-                await copyDir(path, agentDest);
-                const specialFiles = [
-                    "package.json",
-                    "package-lock.json",
-                    "README.md",
-                    "CHANGELOG.md",
-                    "biome.json",
-                ];
-                for (const file of specialFiles) {
-                    const srcFile = join(path, file);
-                    if (await fileExists(srcFile)) {
-                        await copyFile(srcFile, join(deployRoot, file));
-                        await rm(join(deployRoot, file), { force: true });
-                    }
-                }
-                if (await fileExists(join(deployRoot, "package.json"))) {
-                    task.output = "Running npm install...";
-                    await run("npm", ["install"], { cwd: deployRoot });
-                }
-            },
-        },
-        {
-            title: "Check Blocklet CLI",
-            task: async (_, task) => {
-                try {
-                    task.output = "Checking Blocklet CLI Version...";
-                    await run("blocklet", ["--version"], { cwd: deployRoot });
-                }
-                catch {
-                    task.output = "Blocklet CLI not installed, asking to install...";
-                    const { install } = await task
-                        .prompt(ListrInquirerPromptAdapter)
-                        .run(selectInquirer, {
-                        type: "list",
-                        name: "install",
-                        message: "Install Blocklet CLI?",
-                        choices: ["yes", "no"],
-                        default: "yes",
-                    });
-                    if (install === "yes") {
-                        task.output = "Installing Blocklet CLI...";
-                        await run("npm", ["install", "-g", "@blocklet/cli"], { cwd: deployRoot });
-                    }
-                    else {
-                        throw new Error("Blocklet CLI not found, please install manually: npm install -g @blocklet/cli");
-                    }
-                }
-            },
-        },
-        {
-            title: "Configure Blocklet",
-            task: async (ctx, task) => {
-                task.output = "Configuring Blocklet...";
-                if (await fileExists(join(deployRoot, "blocklet.yml"))) {
-                    const entryFile = join(path, "aigne.yaml");
-                    const aigneFile = await readFile(entryFile, "utf-8");
-                    const aigneData = parse(aigneFile);
-                    const agentName = aigneData.name;
-                    const deployed = parse(await readFile(join(aigneHomeDir, DEPLOYED_FILE), "utf-8").catch(() => stringify({})));
-                    let blockletName = deployed[path]?.name;
-                    if (!blockletName) {
-                        task.output = "Asking for Blocklet name...";
-                        blockletName = await task
-                            .prompt(ListrInquirerPromptAdapter)
-                            .run(inputInquirer, {
-                            type: "input",
-                            name: "blockletName",
-                            message: "Please input agent blocklet name:",
-                            default: deployed[path]?.name || agentName || basename(path),
-                            validate: (input) => {
-                                if (input.trim() === "")
-                                    return "Blocklet name cannot be empty.";
-                                return true;
-                            },
-                        });
-                    }
-                    let did = deployed[path]?.did;
-                    if (!did) {
-                        task.output = "Creating DID...";
-                        const info = await run("blocklet", ["create", "--did-only"], {
-                            cwd: deployRoot,
-                            catchOutput: true,
-                        });
-                        const match = info.match(/Created Blocklet DID:\s+(\S+)/);
-                        if (match?.[1]) {
-                            did = match[1];
-                        }
-                        else {
-                            throw new Error(`DID not found. Output content: ${info}`);
-                        }
-                    }
-                    task.output = `Blocklet name: ${blockletName}, DID: ${did}`;
-                    ctx.logs.push(task.output);
-                    const yml = await readFile(join(deployRoot, "blocklet.yml"), "utf-8");
-                    const data = parse(yml);
-                    data.name = blockletName;
-                    data.title = blockletName;
-                    data.did = did;
-                    await writeFile(join(deployRoot, "blocklet.yml"), stringify(data));
-                    await writeFile(join(aigneHomeDir, DEPLOYED_FILE), stringify({ ...deployed, [path]: { name: blockletName, did } }));
-                }
-            },
-        },
-        {
-            title: "Bundle Blocklet",
-            task: async (_, task) => {
-                task.output = "Running blocklet bundle...";
-                await run("blocklet", ["bundle", "--create-release"], { cwd: deployRoot });
-            },
-        },
-    ], {
-        concurrent: false,
-        exitOnError: true,
-        rendererOptions: {
-            collapseSubtasks: false,
-        },
-    });
-    try {
-        await tasks.run();
-        await run("blocklet", ["deploy", "--endpoint", endpoint, ".blocklet/bundle"], {
-            cwd: deployRoot,
-            catchOutput: false,
-        });
-        await rm(deployRoot, { recursive: true, force: true });
-        console.log(`✅ Deploy completed: ${path} -> ${endpoint}`);
-    }
-    catch (error) {
-        console.error(`❌ Deploy failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-};

package/dist/commands/eval.d.ts

@@ -1,11 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare function createEvalCommand({ aigneFilePath, }?: {
-    aigneFilePath?: string;
-}): CommandModule<unknown, {
-    path?: string;
-    agent?: string;
-    dataset?: string;
-    evaluator?: string;
-    concurrency?: number;
-    output?: string;
-}>;

package/dist/commands/eval.js

@@ -1,110 +0,0 @@
-import { isAbsolute, resolve } from "node:path";
-import { exists } from "@aigne/agent-library/utils/fs.js";
-import { findCliAgent } from "@aigne/core/utils/agent-utils.js";
-import { z } from "zod";
-import { runEvaluationPipeline } from "../utils/evaluation/core.js";
-import { FileDataset } from "../utils/evaluation/dataset.js";
-import { LLMEvaluator } from "../utils/evaluation/evaluator.js";
-import { ConsoleReporter, CsvReporter } from "../utils/evaluation/reporter.js";
-import { DefaultRunnerWithConcurrency } from "../utils/evaluation/runner.js";
-import { loadAIGNE } from "../utils/load-aigne.js";
-const schema = z.object({
-    path: z.string().optional(),
-    agent: z.string(),
-    dataset: z.string(),
-    evaluator: z.string().optional(),
-    concurrency: z.number().optional(),
-    output: z.string().optional(),
-});
-const getResolvePath = (path) => {
-    return isAbsolute(path) ? path : resolve(process.cwd(), path);
-};
-export function createEvalCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "eval [path] [agent]",
-        describe: "Evaluate AIGNE for the specified path",
-        builder: async (yargs) => {
-            return yargs
-                .positional("path", {
-                type: "string",
-                describe: "Path to the agents directory or URL to an aigne project",
-                default: ".",
-            })
-                .positional("agent", {
-                type: "string",
-                describe: "Name of the agent to evaluate",
-            })
-                .positional("dataset", {
-                type: "string",
-                describe: "Path to the dataset file",
-            })
-                .positional("evaluator", {
-                type: "string",
-                describe: "Name of the evaluator to use",
-            })
-                .positional("output", {
-                alias: "o",
-                type: "string",
-                describe: "Path to the output file",
-            })
-                .positional("concurrency", {
-                type: "number",
-                describe: "Concurrency level",
-                default: 1,
-            })
-                .help(false)
-                .version(false)
-                .strict(false);
-        },
-        handler: async (options) => {
-            const parsedOptions = await schema.safeParseAsync(options);
-            if (!parsedOptions.success) {
-                throw new Error(`Invalid options: ${JSON.stringify(parsedOptions.error.format())}`);
-            }
-            const { agent: entryAgent, dataset: datasetPath, evaluator: evaluatorName, concurrency, } = parsedOptions.data;
-            const path = parsedOptions.data?.path;
-            const aigne = await loadAIGNE({ path: aigneFilePath || path || "." });
-            const resolvedDatasetPath = getResolvePath(datasetPath);
-            if (!(await exists(resolvedDatasetPath))) {
-                throw new Error("Dataset file does not exist");
-            }
-            const { chat } = aigne.cli;
-            const agent = chat && chat.name === entryAgent
-                ? chat
-                : findCliAgent(aigne.cli, "*", entryAgent) ||
-                    aigne.agents[entryAgent] ||
-                    aigne.skills[entryAgent] ||
-                    aigne.mcpServer.agents[entryAgent];
-            if (!agent)
-                throw new Error("Entry agent does not exist");
-            agent.model = agent.model ?? aigne.model;
-            let evaluatorAgent;
-            if (evaluatorName) {
-                evaluatorAgent =
-                    findCliAgent(aigne.cli, "*", evaluatorName) ||
-                        aigne.agents[evaluatorName] ||
-                        aigne.skills[evaluatorName] ||
-                        aigne.mcpServer.agents[evaluatorName];
-            }
-            if (evaluatorAgent) {
-                evaluatorAgent.model = evaluatorAgent.model ?? aigne.model;
-            }
-            const dataset = new FileDataset(resolvedDatasetPath);
-            const runner = new DefaultRunnerWithConcurrency(agent, aigne);
-            const evaluator = new LLMEvaluator(aigne, evaluatorAgent);
-            const reporters = [new ConsoleReporter()];
-            if (options.output) {
-                const resolvedReporterPath = getResolvePath(options.output);
-                const reporter = new CsvReporter(resolvedReporterPath);
-                reporters.push(reporter);
-            }
-            await runEvaluationPipeline({
-                dataset,
-                runner,
-                evaluators: [evaluator],
-                reporters: reporters,
-                options: { concurrency },
-            });
-        },
-    };
-}

package/dist/commands/hub.d.ts

@@ -1,3 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare const formatNumber: (balance: string) => string;
-export declare function createHubCommand(): CommandModule;