@aigne/cli 1.3.0 → 1.3.1-1

package/dist/commands/run.js

@@ -1,9 +1,11 @@
+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";
@@ -17,69 +19,111 @@ export function createRunCommand() {
         .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) {
+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;
-    const engine = await ExecutionEngine.load({ path, model });
-    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}`);
-        }
+    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) {
+    await mkdir(dir, { recursive: true });
+    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) {
+function prepareDirs(path, options) {
     let dir;
     let downloadDir;
-    if (options.downloadDir) {
+    if (!path.startsWith("http")) {
+        dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
+    }
+    else if (options.downloadDir) {
         dir = isAbsolute(options.downloadDir)
             ? options.downloadDir
             : resolve(process.cwd(), options.downloadDir);
         downloadDir = join(dir, ".download");
     }
     else {
-        dir = getLocalPackagePathFromUrl(url);
-        downloadDir = getLocalPackagePathFromUrl(url, { subdir: ".download" });
-    }
-    // clean up the download directory
-    await rm(downloadDir, { recursive: true, force: true });
-    await mkdir(dir, { recursive: true });
-    await mkdir(downloadDir, { recursive: true });
-    await downloadAndExtract(url, downloadDir);
-    if (await isV1Package(downloadDir)) {
-        await toAIGNEPackage(downloadDir, dir);
-    }
-    else {
-        await cp(downloadDir, dir, { recursive: true, force: true });
+        dir = getLocalPackagePathFromUrl(path);
+        downloadDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });
     }
-    await runEngine(url, dir, options);
+    return { downloadDir, dir };
 }
 function getLocalPackagePathFromUrl(url, { subdir } = {}) {
     const root = [homedir(), ".aigne", subdir].filter(isNonNullable);

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

@@ -54,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.3.0",
+  "version": "1.3.1-1",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"