@aigne/cli 1.36.4 → 1.37.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [1.37.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.36.4...cli-v1.37.0) (2025-08-18)
+
+
+### Features
+
+* **cli:** add support for array inputs in CLI arguments ([#378](https://github.com/AIGNE-io/aigne-framework/issues/378)) ([827ae11](https://github.com/AIGNE-io/aigne-framework/commit/827ae112de8d1a2e997b272b759090b6e5b8d395))
+* **cli:** support hide or collapse task for agents in CLI ([#381](https://github.com/AIGNE-io/aigne-framework/issues/381)) ([05b372d](https://github.com/AIGNE-io/aigne-framework/commit/05b372d431a862f7cdfa2a90bb4b7b2379bf97ab))
+
+
+### Bug Fixes
+
+* **cli:** only log API requests at info level and above ([#376](https://github.com/AIGNE-io/aigne-framework/issues/376)) ([03fc4d9](https://github.com/AIGNE-io/aigne-framework/commit/03fc4d9aad6e81aeae3b2eb02a62f7acade3bd77))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.22
+    * @aigne/agentic-memory bumped to 1.0.22
+    * @aigne/aigne-hub bumped to 0.6.4
+    * @aigne/core bumped to 1.51.0
+    * @aigne/default-memory bumped to 1.1.4
+    * @aigne/openai bumped to 0.11.4
+
 ## [1.36.4](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.36.3...cli-v1.36.4) (2025-08-16)
 
 

package/dist/commands/app.js

@@ -2,18 +2,15 @@ import assert from "node:assert";
 import { spawn } from "node:child_process";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { extname, join } from "node:path";
-import { isatty } from "node:tty";
+import { join } from "node:path";
 import { loadModel } from "@aigne/aigne-hub";
-import { AIAgent, AIGNE, readAllString } from "@aigne/core";
-import { pick } from "@aigne/core/utils/type-utils.js";
+import { AIGNE } from "@aigne/core";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
-import { parse } from "yaml";
-import { ZodBoolean, ZodNumber, ZodObject, ZodString, ZodType } from "zod";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
-import { runAgentWithAIGNE, stdinHasData } from "../utils/run-with-aigne.js";
+import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
+import { parseAgentInput, withAgentInputSchema } from "../utils/yargs.js";
 import { serveMCPServerFromDir } from "./serve-mcp.js";
 const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
 const builtinApps = [
@@ -85,50 +82,16 @@ const upgradeCommandModule = ({ name, dir, isLatest, version, }) => ({
     },
 });
 const agentCommandModule = ({ dir, agent, }) => {
-    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
     return {
         command: agent.name,
         aliases: agent.alias || [],
         describe: agent.description || "",
-        builder: (yargs) => {
-            for (const [option, config] of Object.entries(inputSchema)) {
-                const innerType = innerZodType(config);
-                yargs.option(option, {
-                    // TODO: support more types
-                    type: innerType instanceof ZodBoolean
-                        ? "boolean"
-                        : innerType instanceof ZodNumber
-                            ? "number"
-                            : "string",
-                    description: config.description,
-                });
-                if (!(config.isNullable() || config.isOptional())) {
-                    yargs.demandOption(option);
-                }
-            }
-            return 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"],
-            });
-        },
+        builder: async (yargs) => withAgentInputSchema(yargs, agent),
         handler: async (input) => {
             await invokeCLIAgentFromDir({ dir, agent: agent.name, input });
         },
     };
 };
-function innerZodType(type) {
-    if ("innerType" in type._def && type._def.innerType instanceof ZodType) {
-        return innerZodType(type._def.innerType);
-    }
-    return type;
-}
 export async function invokeCLIAgentFromDir(options) {
     const aigne = await loadAIGNE({
         path: options.dir,
@@ -137,61 +100,13 @@ export async function invokeCLIAgentFromDir(options) {
     try {
         const agent = aigne.cli.agents[options.agent];
         assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
-        const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
-        const input = Object.fromEntries(await Promise.all(Object.entries(pick(options.input, Object.keys(inputSchema))).map(async ([key, val]) => {
-            if (typeof val === "string" && val.startsWith("@")) {
-                const schema = inputSchema[key];
-                val = await readFileAsInput(val, {
-                    format: schema instanceof ZodString ? "raw" : undefined,
-                });
-            }
-            return [key, val];
-        })));
-        const rawInput = options.input.input ||
-            (isatty(process.stdin.fd) || !(await stdinHasData())
-                ? null
-                : [await readAllString(process.stdin)].filter(Boolean));
-        if (rawInput) {
-            for (const raw of rawInput) {
-                const parsed = raw.startsWith("@")
-                    ? await readFileAsInput(raw, { format: options.input.format })
-                    : raw;
-                if (typeof parsed !== "string") {
-                    Object.assign(input, parsed);
-                }
-                else {
-                    const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
-                    if (inputKey) {
-                        Object.assign(input, { [inputKey]: parsed });
-                    }
-                }
-            }
-        }
+        const input = await parseAgentInput(options.input, agent);
         await runAgentWithAIGNE(aigne, agent, { input });
     }
     finally {
         await aigne.shutdown();
     }
 }
-async function readFileAsInput(value, { format } = {}) {
-    if (value.startsWith("@")) {
-        const ext = extname(value);
-        value = await readFile(value.slice(1), "utf8");
-        if (!format) {
-            if (ext === ".json")
-                format = "json";
-            else if (ext === ".yaml" || ext === ".yml")
-                format = "yaml";
-        }
-    }
-    if (format === "json") {
-        return JSON.parse(value);
-    }
-    else if (format === "yaml") {
-        return parse(value);
-    }
-    return value;
-}
 export async function loadApplication({ name, dir, forceUpgrade = false, }) {
     name = `@aigne/${name}`;
     dir ??= join(homedir(), ".aigne", "registry.npmjs.org", name);

package/dist/tracer/terminal.d.ts

@@ -45,6 +45,8 @@ type Task = ReturnType<typeof promiseWithResolvers<void>> & {
         subtask: Listr;
         taskWrapper: AIGNEListrTaskWrapper;
     }>>;
+    agent: Agent;
+    input: Message;
     startTime?: number;
     endTime?: number;
     usage?: Partial<ContextUsage>;

package/dist/tracer/terminal.js

@@ -1,6 +1,6 @@
 import { EOL } from "node:os";
 import { inspect } from "node:util";
-import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
+import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, mergeContextUsage, newEmptyContextUsage, UserAgent, } from "@aigne/core";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
 import { flat, omit } from "@aigne/core/utils/type-utils.js";
 import { figures } from "@aigne/listr2";
@@ -28,13 +28,39 @@ export class TerminalTracer {
             formatResult: (result, options) => [this.formatResult(agent, context, result, options)].filter(Boolean),
         }, [], { concurrent: true });
         this.listr = listr;
+        const collapsedMap = new Map();
+        const hideContextIds = new Set();
         const onStart = async ({ context, agent, ...event }) => {
             if (agent instanceof UserAgent)
                 return;
+            if (agent.taskRenderMode === "hide") {
+                hideContextIds.add(context.id);
+                return;
+            }
+            else if (agent.taskRenderMode === "collapse") {
+                collapsedMap.set(context.id, {
+                    ancestor: { contextId: context.id },
+                    usage: newEmptyContextUsage(),
+                    models: new Set(),
+                });
+            }
+            if (context.parentId) {
+                if (hideContextIds.has(context.parentId)) {
+                    hideContextIds.add(context.id);
+                    return;
+                }
+                const collapsed = collapsedMap.get(context.parentId);
+                if (collapsed) {
+                    collapsedMap.set(context.id, collapsed);
+                    return;
+                }
+            }
             const contextId = context.id;
             const parentContextId = context.parentId;
             const task = {
                 ...promiseWithResolvers(),
+                agent,
+                input: event.input,
                 listr: promiseWithResolvers(),
                 startTime: Date.now(),
             };
@@ -66,6 +92,34 @@ export class TerminalTracer {
         const onSuccess = async ({ context, agent, output, ...event }) => {
             const contextId = context.id;
             const parentContextId = context.parentId;
+            const collapsed = collapsedMap.get(contextId);
+            if (collapsed) {
+                if (agent instanceof ChatModel) {
+                    const { usage, model } = output;
+                    if (usage)
+                        mergeContextUsage(collapsed.usage, usage);
+                    if (model)
+                        collapsed.models.add(model);
+                }
+                const task = this.tasks[collapsed.ancestor.contextId];
+                if (task) {
+                    task.usage = collapsed.usage;
+                    task.extraTitleMetadata ??= {};
+                    if (collapsed.models.size)
+                        task.extraTitleMetadata.model = [...collapsed.models].join(",");
+                    const { taskWrapper } = await task.listr.promise;
+                    taskWrapper.title = await this.formatTaskTitle(task.agent, {
+                        input: task.input,
+                        task,
+                        usage: Boolean(task.usage.inputTokens || task.usage.outputTokens || task.usage.aigneHubCredits),
+                        time: context.id === collapsed.ancestor.contextId,
+                    });
+                    if (context.id === collapsed.ancestor.contextId) {
+                        task?.resolve();
+                    }
+                    return;
+                }
+            }
             const task = this.tasks[contextId];
             if (!task)
                 return;
@@ -173,6 +227,9 @@ export class TerminalTracer {
         const items = [
             [chalk.yellow(usage.inputTokens), chalk.grey("input tokens")],
             [chalk.cyan(usage.outputTokens), chalk.grey("output tokens")],
+            usage.aigneHubCredits
+                ? [chalk.blue(usage.aigneHubCredits.toFixed()), chalk.grey("AIGNE Hub credits")]
+                : undefined,
             usage.agentCalls ? [chalk.magenta(usage.agentCalls), chalk.grey("agent calls")] : undefined,
         ];
         const content = items.filter((i) => !!i).map((i) => i.join(" "));

package/dist/utils/listr.js

@@ -51,9 +51,11 @@ export class AIGNEListr extends Listr {
         try {
             this.ctx = {};
             this.spinner.start();
-            const request = this.myOptions.formatRequest();
-            if (request)
-                console.log(request);
+            if (logger.enabled(LogLevel.INFO)) {
+                const request = this.myOptions.formatRequest();
+                if (request)
+                    console.log(request);
+            }
             logger.logMessage = (...args) => this.logs.push(format(...args));
             for (const method of ["debug", "log", "info", "warn", "error"]) {
                 console[method] = (...args) => {

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

@@ -63,4 +63,3 @@ 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

@@ -1,21 +1,19 @@
-import { fstat } from "node:fs";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
-import { promisify } from "node:util";
 import { exists } from "@aigne/agent-library/utils/fs.js";
 import { availableModels, parseModelOption } from "@aigne/aigne-hub";
-import { AIAgent, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+import { DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { flat, isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { 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 { ZodError, z } from "zod";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { loadAIGNE } from "./load-aigne.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
+import { parseAgentInput, withAgentInputSchema } from "./yargs.js";
 export const createRunAIGNECommand = (yargs) => yargs
     .option("chat", {
     describe: "Run chat loop in terminal",
@@ -80,7 +78,7 @@ export const createRunAIGNECommand = (yargs) => yargs
     .option("log-level", {
     describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
     type: "string",
-    default: getLevelFromEnv(logger.options.ns) || LogLevel.INFO,
+    default: getLevelFromEnv(logger.options.ns) || LogLevel.SILENT,
     coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
 })
     .option("aigne-hub-url", {
@@ -88,38 +86,11 @@ export const createRunAIGNECommand = (yargs) => yargs
     type: "string",
 });
 export async function parseAgentInputByCommander(agent, options = {}) {
-    const inputSchemaShape = flat(agent instanceof AIAgent ? agent.inputKey : undefined, agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : []);
-    const parsedInput = await yargs().parseAsync(options.argv ?? process.argv);
-    const input = Object.fromEntries(await Promise.all(inputSchemaShape.map(async (key) => {
-        const k = `input${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-        let value = parsedInput[k];
-        if (typeof value === "string" && value.startsWith("@")) {
-            value = await readFile(value.slice(1), "utf8");
-        }
-        return [key, value];
-    })));
-    const rawInput = options.input ||
-        (isatty(process.stdin.fd) || !(await stdinHasData())
-            ? null
-            : [await readAllString(process.stdin)].filter(Boolean));
-    if (rawInput?.length) {
-        for (let raw of rawInput) {
-            if (raw.startsWith("@")) {
-                raw = await readFile(raw.slice(1), "utf8");
-            }
-            if (options.format === "json") {
-                Object.assign(input, JSON.parse(raw));
-            }
-            else if (options.format === "yaml") {
-                Object.assign(input, parse(raw));
-            }
-            else {
-                Object.assign(input, typeof options.inputKey === "string"
-                    ? { [options.inputKey]: raw }
-                    : { [DEFAULT_CHAT_INPUT_KEY]: raw });
-            }
-        }
-    }
+    const args = await withAgentInputSchema(yargs(), agent)
+        .showHelpOnFail(false)
+        .fail(() => { })
+        .parseAsync(options.argv ?? process.argv);
+    const input = await parseAgentInput({ ...args, input: options.input || args.input }, agent);
     if (isEmpty(input)) {
         const defaultInput = options.defaultInput || process.env.INITIAL_CALL;
         Object.assign(input, typeof defaultInput === "string"
@@ -214,7 +185,3 @@ export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptio
     }
     return { result };
 }
-export async function stdinHasData() {
-    const stats = await promisify(fstat)(0);
-    return stats.isFIFO() || stats.isFile();
-}

package/dist/utils/yargs.d.ts

@@ -0,0 +1,20 @@
+import { type Agent, type Message } from "@aigne/core";
+import type { Argv } from "yargs";
+import { ZodType } from "zod";
+export declare function inferZodType(type: ZodType, opts?: {
+    array?: boolean;
+    optional?: boolean;
+}): {
+    type: "string" | "number" | "boolean";
+    array?: boolean;
+    optional?: boolean;
+};
+export declare function withAgentInputSchema(yargs: Argv, agent: Agent): Argv<{
+    input?: string[];
+    format?: "json" | "yaml";
+}>;
+export declare function parseAgentInput(i: Message & {
+    input?: string[];
+    format?: "json" | "yaml";
+}, agent: Agent): Promise<any>;
+export declare function stdinHasData(): Promise<boolean>;

package/dist/utils/yargs.js

@@ -0,0 +1,107 @@
+import { fstat } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { isatty } from "node:tty";
+import { promisify } from "node:util";
+import { AIAgent, readAllString } from "@aigne/core";
+import { pick } from "@aigne/core/utils/type-utils.js";
+import { parse } from "yaml";
+import { ZodAny, ZodArray, ZodBoolean, ZodNumber, ZodObject, ZodString, ZodType, ZodUnknown, } from "zod";
+export function inferZodType(type, opts = {}) {
+    if (type instanceof ZodUnknown || type instanceof ZodAny) {
+        return { type: "string", optional: true };
+    }
+    opts.optional ??= type.isNullable() || type.isOptional();
+    if ("innerType" in type._def && type._def.innerType instanceof ZodType) {
+        return inferZodType(type._def.innerType, opts);
+    }
+    if (type instanceof ZodArray) {
+        return inferZodType(type.element, { ...opts, array: true });
+    }
+    return {
+        ...opts,
+        array: opts.array || undefined,
+        optional: opts.optional || undefined,
+        type: type instanceof ZodBoolean ? "boolean" : type instanceof ZodNumber ? "number" : "string",
+    };
+}
+export function withAgentInputSchema(yargs, agent) {
+    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
+    for (const [option, config] of Object.entries(inputSchema)) {
+        const type = inferZodType(config);
+        yargs.option(option, {
+            type: type.type,
+            description: config.description,
+            array: type.array,
+        });
+        if (!type.optional) {
+            yargs.demandOption(option);
+        }
+    }
+    return yargs
+        .option("input", {
+        type: "string",
+        array: true,
+        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"],
+    });
+}
+export async function parseAgentInput(i, agent) {
+    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
+    const input = Object.fromEntries(await Promise.all(Object.entries(pick(i, Object.keys(inputSchema))).map(async ([key, val]) => {
+        if (typeof val === "string" && val.startsWith("@")) {
+            const schema = inputSchema[key];
+            val = await readFileAsInput(val, {
+                format: schema instanceof ZodString ? "raw" : undefined,
+            });
+        }
+        return [key, val];
+    })));
+    const rawInput = i.input ||
+        (isatty(process.stdin.fd) || !(await stdinHasData())
+            ? null
+            : [await readAllString(process.stdin)].filter(Boolean));
+    if (rawInput) {
+        for (const raw of rawInput) {
+            const parsed = raw.startsWith("@") ? await readFileAsInput(raw, { format: i.format }) : raw;
+            if (typeof parsed !== "string") {
+                Object.assign(input, parsed);
+            }
+            else {
+                const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
+                if (inputKey) {
+                    Object.assign(input, { [inputKey]: parsed });
+                }
+            }
+        }
+    }
+    return input;
+}
+async function readFileAsInput(value, { format } = {}) {
+    if (value.startsWith("@")) {
+        const ext = extname(value);
+        value = await readFile(value.slice(1), "utf8");
+        if (!format) {
+            if (ext === ".json")
+                format = "json";
+            else if (ext === ".yaml" || ext === ".yml")
+                format = "yaml";
+        }
+    }
+    if (format === "json") {
+        return JSON.parse(value);
+    }
+    else if (format === "yaml") {
+        return parse(value);
+    }
+    return value;
+}
+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.36.4",
+  "version": "1.37.0",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -72,13 +72,13 @@
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.21",
-    "@aigne/aigne-hub": "^0.6.3",
-    "@aigne/agentic-memory": "^1.0.21",
-    "@aigne/core": "^1.50.1",
-    "@aigne/default-memory": "^1.1.3",
-    "@aigne/openai": "^0.11.3",
-    "@aigne/observability-api": "^0.9.0"
+    "@aigne/agent-library": "^1.21.22",
+    "@aigne/aigne-hub": "^0.6.4",
+    "@aigne/agentic-memory": "^1.0.22",
+    "@aigne/core": "^1.51.0",
+    "@aigne/default-memory": "^1.1.4",
+    "@aigne/observability-api": "^0.9.0",
+    "@aigne/openai": "^0.11.4"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",