@aigne/cli 1.27.1-0 → 1.27.1-1

package/dist/cli.d.ts

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
-export {};
+declare const _default: Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;
+export default _default;

package/dist/cli.js

@@ -16,7 +16,7 @@ function getAIGNEFilePath() {
     }
 }
 const aigneFilePath = getAIGNEFilePath();
-createAIGNECommand({ aigneFilePath })
+export default createAIGNECommand({ aigneFilePath })
     .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))
     .catch((error) => {
     console.log(""); // Add an empty line for better readability

package/dist/commands/app.js

@@ -1,66 +1,153 @@
 import assert from "node:assert";
 import { spawnSync } from "node:child_process";
-import { mkdir, readFile, stat } from "node:fs/promises";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { AIGNE } from "@aigne/core";
+import { extname, join } from "node:path";
+import { isatty } from "node:tty";
+import { AIAgent, AIGNE, readAllString } from "@aigne/core";
+import { pick } from "@aigne/core/utils/type-utils.js";
+import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
-import { ZodObject, ZodString } from "zod";
+import { parse } from "yaml";
+import { ZodObject } from "zod";
 import { availableModels } from "../constants.js";
 import { downloadAndExtract } from "../utils/download.js";
-import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
+import { loadAIGNE } from "../utils/load-aigne.js";
+import { runAgentWithAIGNE, stdinHasData } from "../utils/run-with-aigne.js";
 const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
+const builtinApps = [
+    {
+        name: "doc-smith",
+        describe: "Generate professional documents by doc-smith",
+        aliases: ["docsmith", "doc"],
+    },
+];
 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();
+    return builtinApps.map((app) => ({
+        command: app.name,
+        describe: app.describe,
+        aliases: app.aliases,
+        builder: async (yargs) => {
+            const { aigne, dir, version } = await loadApplication({ name: "doc-smith" });
+            for (const agent of aigne.agents) {
+                const inputSchema = Object.entries(agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {});
+                yargs.command(agent.name, agent.description || "", (yargs) => {
+                    for (const [option, config] of inputSchema) {
+                        yargs.option(option, {
+                            // TODO: support more types
+                            type: "string",
+                            description: config.description,
+                        });
+                        if (!(config.isNullable() || config.isOptional())) {
+                            yargs.demandOption(option);
                         }
+                    }
+                    yargs
+                        .option("input", {
+                        type: "array",
+                        description: "Input to the agent, use @<file> to read from a file",
+                        alias: ["i"],
+                    })
+                        .option("format", {
+                        type: "string",
+                        description: 'Input format, can be "json" or "yaml"',
+                        choices: ["json", "yaml"],
                     });
-                }
-                yargs.version('hello world');
-                return yargs.demandCommand();
-            },
-            handler: () => { },
+                }, async (argv) => {
+                    try {
+                        const aigne = await loadAIGNE(dir);
+                        const _agent = aigne.agents[agent.name];
+                        assert(_agent, `Agent ${agent.name} not found in ${app.name}`);
+                        const input = pick(argv, inputSchema.map(([key]) => key));
+                        const rawInput = argv.input ||
+                            (isatty(process.stdin.fd) || !(await stdinHasData())
+                                ? null
+                                : [await readAllString(process.stdin)].filter(Boolean));
+                        if (rawInput) {
+                            for (let raw of rawInput) {
+                                let format = argv.format;
+                                if (raw.startsWith("@")) {
+                                    raw = await readFile(raw.slice(1), "utf8");
+                                    if (!format) {
+                                        const ext = extname(raw);
+                                        if (ext === ".json")
+                                            format = "json";
+                                        else if (ext === ".yaml" || ext === ".yml")
+                                            format = "yaml";
+                                    }
+                                }
+                                const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
+                                if (format === "json") {
+                                    Object.assign(input, JSON.parse(raw));
+                                }
+                                else if (format === "yaml") {
+                                    Object.assign(input, parse(raw));
+                                }
+                                else if (inputKey) {
+                                    Object.assign(input, { [inputKey]: raw });
+                                }
+                            }
+                        }
+                        await runAgentWithAIGNE(aigne, _agent, { input });
+                    }
+                    finally {
+                        await aigne.shutdown();
+                    }
+                });
+            }
+            yargs.version(`${app.name} v${version}`);
+            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" });
+async function loadApplication({ name, }) {
+    name = `@aigne/${name}`;
+    const dir = join(homedir(), ".aigne", "registry.npmjs.org", name);
+    const check = await isInstallationAvailable(dir);
+    if (check?.available) {
+        return {
+            aigne: await AIGNE.load(dir, { models: availableModels() }),
+            dir,
+            version: check.version,
+        };
     }
-    return AIGNE.load(info.dir, { models: availableModels() });
+    const result = await new Listr([
+        {
+            title: "Fetching application metadata",
+            task: async (ctx) => {
+                const info = await getNpmTgzInfo(name);
+                Object.assign(ctx, info);
+            },
+        },
+        {
+            title: "Downloading application",
+            skip: (ctx) => ctx.version === check?.version,
+            task: async (ctx) => {
+                await downloadApplication({ url: ctx.url, dir });
+            },
+        },
+        {
+            title: "Installing dependencies",
+            skip: (ctx) => ctx.version === check?.version,
+            task: async () => {
+                await installDependencies(dir);
+            },
+        },
+    ], {
+        rendererOptions: {
+            collapseSubtasks: false,
+            showErrorMessage: false,
+            timer: PRESET_TIMER,
+        },
+    }).run();
+    return {
+        aigne: await AIGNE.load(dir, { models: availableModels() }),
+        dir,
+        version: result.version,
+    };
 }
-async function shouldDownloadNewVersion(name, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
-    const nameWithOrg = `@aigne/${name}`;
-    const dir = join(homedir(), ".aigne", "registry.npmjs.org", nameWithOrg);
+async function isInstallationAvailable(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
     const s = await stat(join(dir, "package.json")).catch((error) => {
         if (error.code === "ENOENT") {
             return null;
@@ -68,21 +155,31 @@ async function shouldDownloadNewVersion(name, { cacheTimeMs = NPM_PACKAGE_CACHE_
         throw error;
     });
     if (!s)
-        return {
-            shouldDownload: true,
-            dir,
-            url: await getNpmTgzInfo(nameWithOrg).then((info) => info.tarballUrl),
-        };
-    const lastModified = s.mtimeMs;
+        return null;
+    const version = safeParseJSON(await readFile(join(dir, "package.json"), "utf-8"))?.version;
+    if (!version)
+        return null;
+    const installedAt = safeParseJSON(await readFile(join(dir, ".aigne-cli.json"), "utf-8").catch(() => "{}"))?.installedAt;
+    if (!installedAt)
+        return null;
     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 };
-        }
+    const available = installedAt ? now - installedAt < cacheTimeMs : false;
+    return { version, available };
+}
+async function downloadApplication({ url, dir }) {
+    await mkdir(dir, { recursive: true });
+    await downloadAndExtract(url, dir, { strip: 1 });
+}
+async function installDependencies(dir) {
+    const { stderr, status } = spawnSync("npm", ["install", "--omit", "dev"], {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    if (status !== 0) {
+        console.error(stderr.toString());
+        throw new Error(`Failed to install dependencies in ${dir}`);
     }
-    return { shouldDownload: false, dir };
+    await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify({ installedAt: Date.now() }, null, 2));
 }
 async function getNpmTgzInfo(name) {
     const res = await fetch(joinURL("https://registry.npmjs.org", name));
@@ -90,9 +187,17 @@ async function getNpmTgzInfo(name) {
         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;
+    const url = data.versions[latestVersion].dist.tarball;
     return {
         version: latestVersion,
-        tarballUrl,
+        url,
     };
 }
+function safeParseJSON(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/connect.d.ts

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

package/dist/commands/create.d.ts

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

package/dist/commands/observe.d.ts

@@ -3,5 +3,5 @@ interface ServeMCPOptions {
     host: string;
     port?: number;
 }
-export declare function createObservabilityCommand(): CommandModule<{}, ServeMCPOptions>;
+export declare function createObservabilityCommand(): CommandModule<unknown, ServeMCPOptions>;
 export {};

package/dist/commands/serve-mcp.d.ts

@@ -7,5 +7,5 @@ interface ServeMCPOptions {
 }
 export declare function createServeMCPCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): CommandModule<{}, ServeMCPOptions>;
+}): CommandModule<unknown, ServeMCPOptions>;
 export {};

package/dist/commands/test.d.ts

@@ -4,5 +4,5 @@ interface TestOptions {
 }
 export declare function createTestCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): CommandModule<{}, TestOptions>;
+}): CommandModule<unknown, TestOptions>;
 export {};

package/dist/utils/run-with-aigne.d.ts

@@ -65,3 +65,4 @@ export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKe
 } & Omit<RunAIGNECommandOptions, "input">): Promise<{
     result: Message;
 } | undefined>;
+export declare function stdinHasData(): Promise<boolean>;

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

@@ -7,10 +7,11 @@ import { exists } from "@aigne/agent-library/utils/fs.js";
 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 { flat, isEmpty, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
+import { flat, isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
 import { parse } from "yaml";
 import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import { ZodError, ZodObject, z } from "zod";
 import { availableModels } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
@@ -157,7 +158,7 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
     })
         .alias("h", "help")
         .alias("v", "version")
-        .parseAsync(argv)
+        .parseAsync(hideBin(argv))
         .catch((error) => {
         console.error(`${chalk.red("Error:")} ${error.message}`);
         process.exit(1);
@@ -209,7 +210,7 @@ export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptio
     }
     return { result };
 }
-async function stdinHasData() {
+export async function stdinHasData() {
     const stats = await promisify(fstat)(0);
     return stats.isFIFO() || stats.isFile();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.27.1-0",
+  "version": "1.27.1-1",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -70,20 +70,20 @@
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.6",
     "@aigne/agentic-memory": "^1.0.6",
-    "@aigne/aigne-hub": "^0.3.0",
-    "@aigne/anthropic": "^0.10.2",
+    "@aigne/agent-library": "^1.21.6",
     "@aigne/bedrock": "^0.8.6",
+    "@aigne/aigne-hub": "^0.3.0",
     "@aigne/core": "^1.39.0",
     "@aigne/deepseek": "^0.7.6",
+    "@aigne/anthropic": "^0.10.2",
     "@aigne/default-memory": "^1.0.6",
     "@aigne/gemini": "^0.8.6",
-    "@aigne/ollama": "^0.7.6",
+    "@aigne/observability-api": "^0.8.2",
     "@aigne/open-router": "^0.7.6",
     "@aigne/openai": "^0.10.6",
     "@aigne/xai": "^0.7.6",
-    "@aigne/observability-api": "^0.8.2"
+    "@aigne/ollama": "^0.7.6"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",