@aigne/cli 1.2.0 → 1.3.1-0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.2.0...cli-v1.3.0) (2025-04-17)
+
+
+### Features
+
+* **ci:** support coverage examples with model matrix ([#59](https://github.com/AIGNE-io/aigne-framework/issues/59)) ([1edd704](https://github.com/AIGNE-io/aigne-framework/commit/1edd70426b80a69e3751b2d5fe818297711d0777))
+* **cli:** support convert agents from studio ([#64](https://github.com/AIGNE-io/aigne-framework/issues/64)) ([f544bc7](https://github.com/AIGNE-io/aigne-framework/commit/f544bc77a2fb07e034b317ceb6a46aadd35830c9))
+* **cli:** support model and download customization for aigne run ([#61](https://github.com/AIGNE-io/aigne-framework/issues/61)) ([51f6619](https://github.com/AIGNE-io/aigne-framework/commit/51f6619e6c591a84f1f2339b26ef66d89fa9486e))
+
 ## [1.2.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.1.0...cli-v1.2.0) (2025-04-15)
 
 

package/dist/commands/run.js

@@ -1,9 +1,13 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import assert from "node:assert";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { ExecutionEngine } from "@aigne/core";
+import { loadModel } from "@aigne/core/loader/index.js";
+import { isNonNullable } from "@aigne/core/utils/type-utils.js";
+import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { Command } from "commander";
+import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { runChatLoopInTerminal } from "../utils/run-chat-loop.js";
 export function createRunCommand() {
@@ -11,47 +15,117 @@ export function createRunCommand() {
         .description("Run a chat loop with the specified agent")
         .argument("[path]", "Path to the agents directory or URL to aigne project", ".")
         .option("--agent <agent>", "Name of the agent to use (defaults to the first agent found)")
+        .option("--download-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
+        .option("--model-provider <provider>", "Model provider to use, available providers: openai, claude, xai (defaults to the aigne.yaml definition or openai)")
+        .option("--model-name <model>", "Model name to use, available models depend on the provider (defaults to the aigne.yaml definition or gpt-4o-mini)")
         .action(async (path, options) => {
-        if (path.startsWith("http")) {
-            await downloadAndRunPackage(path, options);
-            return;
-        }
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        await runEngine(path, absolutePath, options);
+        const { downloadDir, dir } = prepareDirs(path, options);
+        const { engine, agent } = await new Listr([
+            {
+                title: "Prepare environment",
+                task: (_, task) => {
+                    if (downloadDir) {
+                        return task.newListr([
+                            {
+                                title: "Download package",
+                                task: () => downloadPackage(path, downloadDir),
+                            },
+                            {
+                                title: "Extract package",
+                                task: () => extractPackage(downloadDir, dir),
+                            },
+                        ]);
+                    }
+                },
+            },
+            {
+                title: "Initialize execution engine",
+                task: async (ctx) => {
+                    const engine = await runEngine(dir, options);
+                    ctx.engine = engine;
+                },
+            },
+            {
+                task: (ctx) => {
+                    const { engine } = ctx;
+                    assert(engine);
+                    let agent;
+                    if (options.agent) {
+                        agent = engine.agents[options.agent];
+                        if (!agent) {
+                            console.error(`Agent "${options.agent}" not found in ${path}`);
+                            console.log("Available agents:");
+                            for (const agent of engine.agents) {
+                                console.log(`- ${agent.name}`);
+                            }
+                            throw new Error(`Agent "${options.agent}" not found in ${path}`);
+                        }
+                    }
+                    else {
+                        agent = engine.agents[0];
+                        if (!agent)
+                            throw new Error(`No agents found in ${path}`);
+                    }
+                    ctx.agent = agent;
+                },
+            },
+        ], {
+            rendererOptions: {
+                collapseSubtasks: false,
+                timer: PRESET_TIMER,
+            },
+        }).run();
+        assert(engine);
+        assert(agent);
+        const user = engine.call(agent);
+        await runChatLoopInTerminal(user, {});
+        await engine.shutdown();
     })
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);
 }
-async function runEngine(originalPath, path, options) {
-    const engine = await ExecutionEngine.load({ path });
-    let agent;
-    if (options.agent) {
-        agent = engine.agents[options.agent];
-        if (!agent) {
-            console.error(`Agent "${options.agent}" not found in ${originalPath}`);
-            console.log("Available agents:");
-            for (const agent of engine.agents) {
-                console.log(`- ${agent.name}`);
-            }
-            throw new Error(`Agent "${options.agent}" not found in ${originalPath}`);
-        }
+async function runEngine(path, options) {
+    if (options.modelName && !options.modelProvider) {
+        throw new Error("please specify --model-provider when using the --model-name option");
+    }
+    const model = options.modelProvider
+        ? await loadModel({ provider: options.modelProvider, name: options.modelName })
+        : undefined;
+    return await ExecutionEngine.load({ path, model });
+}
+async function downloadPackage(url, downloadDir) {
+    await rm(downloadDir, { recursive: true, force: true });
+    await mkdir(downloadDir, { recursive: true });
+    await downloadAndExtract(url, downloadDir);
+}
+async function extractPackage(downloadDir, dir) {
+    if (await isV1Package(downloadDir)) {
+        await toAIGNEPackage(downloadDir, dir);
     }
     else {
-        agent = engine.agents[0];
-        if (!agent)
-            throw new Error(`No agents found in ${originalPath}`);
+        await cp(downloadDir, dir, { recursive: true, force: true });
     }
-    const user = engine.call(agent);
-    await runChatLoopInTerminal(user, {});
 }
-async function downloadAndRunPackage(url, options) {
-    const dir = join(tmpdir(), randomUUID());
-    try {
-        await mkdir(dir, { recursive: true });
-        await downloadAndExtract(url, dir);
-        await runEngine(url, dir, options);
+function prepareDirs(path, options) {
+    let dir;
+    let downloadDir;
+    if (!path.startsWith("http")) {
+        dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    finally {
-        await rm(dir, { recursive: true, force: true });
+    else if (options.downloadDir) {
+        dir = isAbsolute(options.downloadDir)
+            ? options.downloadDir
+            : resolve(process.cwd(), options.downloadDir);
+        downloadDir = join(dir, ".download");
     }
+    else {
+        dir = getLocalPackagePathFromUrl(path);
+        downloadDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });
+    }
+    return { downloadDir, dir };
+}
+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/utils/agent-v1.d.ts

@@ -0,0 +1,134 @@
+export declare function isV1Package(src: string): Promise<boolean>;
+export declare function toAIGNEPackage(src: string, dst: string): Promise<void>;
+export type Parameter = {
+    id: string;
+    key?: string;
+    hidden?: boolean;
+    required?: boolean;
+    placeholder?: string;
+} & ({
+    type?: "string" | "number" | "boolean" | "language";
+} | {
+    type?: "select";
+    options?: {
+        id: string;
+        label?: string;
+        value?: string;
+    }[];
+});
+export interface VariableTypeBase {
+    id: string;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    hidden?: boolean;
+}
+export type OutputVariable = VariableTypeBase & ({
+    type?: undefined;
+} | {
+    type: "string";
+    defaultValue?: string;
+} | {
+    type: "number";
+    defaultValue?: number;
+} | {
+    type: "boolean";
+    defaultValue?: boolean;
+} | {
+    type: "object";
+    properties?: OutputVariable[];
+} | {
+    type: "array";
+    element?: OutputVariable;
+});
+export type AgentV1 = {
+    id: string;
+    name?: string;
+    description?: string;
+    parameters?: Parameter[];
+    outputVariables?: OutputVariable[];
+} & ({
+    type: "prompt";
+    prompts?: Prompt[];
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+    model?: string;
+} | {
+    type: "router";
+    defaultToolId?: string;
+    prompt?: string;
+    decisionType?: "ai";
+    routes?: Tool[];
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+    model?: string;
+} | {
+    type: "image";
+    prompt?: string;
+    model?: string;
+    n?: number;
+    quality?: string;
+    style?: string;
+    size?: string;
+    modelSettings?: {
+        [key: string]: unknown;
+    };
+} | {
+    type: "api";
+    requestParameters?: {
+        id: string;
+        key?: string;
+        value?: string;
+    }[];
+    requestMethod?: string;
+    requestUrl?: string;
+    requestHeaders: {
+        id: string;
+        key?: string;
+        value?: string;
+    }[];
+} | {
+    type: "function";
+    code?: string;
+} | {
+    type: "callAgent";
+    agents?: Tool[];
+});
+export interface ProjectDefinitionV1 {
+    project: {
+        name?: string;
+        description?: string;
+    };
+    agents: AgentV1[];
+}
+export type Prompt = {
+    type: "message";
+    data: PromptMessage;
+    visibility?: "hidden";
+} | {
+    type: "executeBlock";
+    visibility?: "hidden";
+};
+export type PromptMessage = {
+    id: string;
+    role: Role;
+    content?: string;
+    name?: string;
+};
+export type Role = "system" | "user" | "assistant";
+export type Tool = {
+    blockletDid?: string;
+    projectId?: string;
+    id: string;
+    from?: "assistant" | "blockletAPI" | "knowledge";
+    parameters?: {
+        [key: string]: unknown;
+    };
+    functionName?: string;
+};

package/dist/utils/agent-v1.js

@@ -0,0 +1,209 @@
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { glob } from "glob";
+import { parse, stringify } from "yaml";
+export async function isV1Package(src) {
+    return stat(join(src, "project.yaml"))
+        .then((res) => res.isFile())
+        .catch((error) => {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    });
+}
+export async function toAIGNEPackage(src, dst) {
+    const definition = await loadAgentV1Package(src);
+    const aigne = {
+        chat_model: {
+            name: "gpt-4o-mini", // TODO: get from config
+        },
+        agents: [],
+    };
+    for (const agent of definition.agents) {
+        const { content } = await assistantToAigneV2(agent, definition);
+        const filename = getAgentFilename(agent);
+        await writeFile(join(dst, filename), content);
+        aigne.agents.push(filename);
+    }
+    await writeFile(join(dst, "aigne.yaml"), stringify(aigne));
+}
+async function loadAgentV1Package(path) {
+    const agentFilePaths = await glob("prompts/**/*.yaml", {
+        cwd: path,
+    });
+    const project = parse(await readFile(join(path, "project.yaml"), "utf8"));
+    const definition = {
+        project,
+        agents: [],
+    };
+    for (const filename of agentFilePaths) {
+        const agent = parse(await readFile(join(path, filename), "utf8"));
+        definition.agents.push(agent);
+    }
+    return definition;
+}
+function assistantToAigneV2(agent, project) {
+    const converter = RUNNABLE_MAP[agent.type];
+    if (!converter)
+        throw new Error(`Unsupported runnable type: ${agent.type}`);
+    return converter(agent, project);
+}
+const RUNNABLE_MAP = {
+    prompt: (agent) => {
+        if (agent.type !== "prompt")
+            throw new Error(`Expected runnable type 'prompt', but got '${agent.type}'`);
+        const obj = {
+            name: agent.name || agent.id,
+            description: agent.description,
+            input_schema: convertInputSchema(agent),
+            output_schema: convertOutputSchema(agent),
+            instructions: agent.prompts
+                ?.filter((i) => i.visibility !== "hidden" && i.type === "message")
+                .map((i) => i.data.content) // TODO: should support multiple messages with different roles
+                .join("\n"),
+        };
+        return {
+            content: stringify(obj),
+        };
+    },
+    function: async (agent) => {
+        if (agent.type !== "function")
+            throw new Error(`Expected runnable type 'function', but got '${agent.type}'`);
+        const inputNames = agent.parameters?.map((i) => i.key).filter(Boolean) ?? [];
+        return {
+            content: await formatCode(`\
+export default async function agent({${inputNames.join(", ")}}) {
+${agent.code}
+}
+
+agent.agent_name = ${JSON.stringify(agent.name || agent.id)};
+
+agent.description = ${agent.description ? JSON.stringify(agent.description) : "undefined"};
+
+agent.input_schema = ${JSON.stringify(convertInputSchema(agent))};
+
+agent.output_schema = ${JSON.stringify(convertOutputSchema(agent))};
+`),
+        };
+    },
+    router: (agent, project) => {
+        if (agent.type !== "router")
+            throw new Error(`Expected runnable type 'router', but got '${agent.type}'`);
+        return {
+            content: stringify({
+                name: agent.name || agent.id,
+                description: agent.description,
+                instructions: agent.prompt,
+                input_schema: convertInputSchema(agent),
+                output_schema: convertOutputSchema(agent),
+                tools: agent.routes?.map((i) => {
+                    const tool = project.agents.find((j) => j.id === i.id);
+                    if (!tool)
+                        throw new Error(`Tool ${i.id} not found in project definition`);
+                    return getAgentFilename(tool);
+                }),
+                tool_choice: "router",
+            }),
+        };
+    },
+};
+function getAgentFilename(agent) {
+    switch (agent.type) {
+        case "prompt":
+        case "router":
+            return `${agent.name || agent.id}.yaml`;
+        case "function":
+            return `${agent.name || agent.id}.js`;
+        default:
+            throw new Error(`Unsupported agent type: ${agent.type}`);
+    }
+}
+async function formatCode(code) {
+    const [prettier, typescriptPlugin, estreePlugin] = await Promise.all([
+        import("prettier"),
+        import("prettier/plugins/typescript"),
+        import("prettier/plugins/estree"),
+    ]);
+    return prettier.format(code, {
+        parser: "typescript",
+        plugins: [typescriptPlugin, estreePlugin.default],
+        printWidth: 120,
+        useTabs: false,
+        tabWidth: 2,
+        trailingComma: "es5",
+        bracketSameLine: true,
+        semi: true,
+        singleQuote: true,
+    });
+}
+function convertInputSchema(agent) {
+    const parameters = (agent.parameters ?? []).filter((i) => !!i.key && !i.hidden);
+    const properties = parameters.map((i) => [i.key, parameterToJsonSchema(i)]);
+    return {
+        type: "object",
+        properties: Object.fromEntries(properties),
+        required: parameters.filter((i) => i.required).map((i) => i.key),
+    };
+}
+function parameterToJsonSchema(parameter) {
+    switch (parameter.type) {
+        case undefined:
+        case "string":
+        case "language":
+            return {
+                type: "string",
+                description: parameter.placeholder,
+            };
+        case "select":
+            return {
+                type: "string",
+                enum: parameter.options?.map((i) => i.value),
+                description: parameter.placeholder,
+            };
+        case "number":
+        case "boolean":
+            return {
+                type: parameter.type,
+                description: parameter.placeholder,
+            };
+        default:
+            throw new Error(`Unsupported parameter type: ${parameter.type}`);
+    }
+}
+function convertOutputSchema(agent) {
+    const outputs = agent.outputVariables?.filter((i) => !!i.name && !i.hidden) ?? [];
+    const properties = outputs
+        .map((i) => [i.name, variableTypeToJsonSchema(i)])
+        .filter((i) => !!i[1]);
+    return {
+        type: "object",
+        properties: Object.fromEntries(properties),
+        required: outputs.filter((i) => i.required).map((i) => i.name),
+    };
+}
+function variableTypeToJsonSchema(output) {
+    if (output.type === "object") {
+        if (!output.properties)
+            return undefined;
+        return {
+            type: "object",
+            properties: Object.fromEntries(output.properties
+                .filter((i) => !!i.name)
+                .map((i) => [i.name, variableTypeToJsonSchema(i)])
+                .filter((i) => !!i[1])),
+            required: output.properties.filter((i) => i.required && i.name).map((i) => i.name),
+        };
+    }
+    if (output.type === "array") {
+        if (!output.element)
+            return undefined;
+        return {
+            type: "array",
+            items: variableTypeToJsonSchema(output.element),
+        };
+    }
+    return {
+        type: output.type || "string",
+        description: output.description,
+    };
+}

package/dist/utils/run-chat-loop.d.ts

@@ -5,5 +5,6 @@ export interface ChatLoopOptions {
     defaultQuestion?: string;
     inputKey?: string;
     verbose?: boolean;
+    skipLoop?: boolean;
 }
 export declare function runChatLoopInTerminal(userAgent: input, options?: ChatLoopOptions): Promise<void>;

package/dist/utils/run-chat-loop.js

@@ -6,14 +6,17 @@ import chalk from "chalk";
 import inquirer from "inquirer";
 import { TerminalTracer } from "../tracer/terminal.js";
 export async function runChatLoopInTerminal(userAgent, options = {}) {
+    const { initialCall = process.env.INITIAL_CALL, skipLoop = process.env.SKIP_LOOP === "true" } = options;
     options.verbose ??= logger.enabled("aigne:core");
     // Disable the logger, use TerminalTracer instead
     logger.disable();
     let prompt;
     if (options?.welcome)
         console.log(options.welcome);
-    if (options?.initialCall) {
-        await callAgent(userAgent, options.initialCall, { ...options });
+    if (initialCall) {
+        await callAgent(userAgent, initialCall, { ...options });
+        if (skipLoop)
+            return;
     }
     for (let i = 0;; i++) {
         prompt = inquirer.prompt([
@@ -51,7 +54,6 @@ async function callAgent(userAgent, input, options) {
         ? { [options.inputKey]: input }
         : createMessage(input));
     console.log(`
-${chalk.grey(figures.tick)} 💬 ${inspect(input, { colors: true })}
 ${chalk.grey(figures.tick)} 🤖 ${tracer.formatTokenUsage(context.usage)}
 ${formatAIResponse(result)}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.2.0",
+  "version": "1.3.1-0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -39,20 +39,23 @@
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "express": "^5.1.0",
+    "glob": "^11.0.1",
     "gradient-string": "^3.0.0",
     "inquirer": "^12.5.2",
-    "openai": "^4.93.0",
+    "openai": "^4.94.0",
+    "prettier": "^3.5.3",
     "pretty-error": "^4.0.0",
     "tar": "^7.4.3",
     "zod": "^3.24.2",
-    "@aigne/core": "^1.7.0"
+    "@aigne/core": "^1.8.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",
     "@types/bun": "^1.2.9",
     "@types/express": "^5.0.1",
+    "@types/glob": "^8.1.0",
     "@types/gradient-string": "^1.1.6",
-    "@types/node": "^22.14.0",
+    "@types/node": "^22.14.1",
     "archiver": "^7.0.1",
     "detect-port": "^2.1.0",
     "npm-run-all": "^4.1.5",