@aigne/cli 1.49.2-beta.1 → 1.50.0-beta.2

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.50.0-beta.2](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.50.0-beta.1...cli-v1.50.0-beta.2) (2025-09-30)
+
+
+### Features
+
+* add multiline support for prompts.input ([#570](https://github.com/AIGNE-io/aigne-framework/issues/570)) ([520d985](https://github.com/AIGNE-io/aigne-framework/commit/520d9859770cc553b551a4a58c7e392b39f53b37))
+
+## [1.50.0-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.49.2-beta.1...cli-v1.50.0-beta.1) (2025-09-30)
+
+
+### Features
+
+* **cli:** support define nested commands for sub apps ([#568](https://github.com/AIGNE-io/aigne-framework/issues/568)) ([0693b80](https://github.com/AIGNE-io/aigne-framework/commit/0693b807e0f8d335010e6ad00763b07cf095e65b))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.47-beta.1
+    * @aigne/agentic-memory bumped to 1.0.47-beta.1
+    * @aigne/aigne-hub bumped to 0.10.1-beta.1
+    * @aigne/core bumped to 1.62.0-beta
+    * @aigne/default-memory bumped to 1.2.10-beta.1
+    * @aigne/openai bumped to 0.16.1-beta.1
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.54-beta.1
+
 ## [1.49.2-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.49.2-beta...cli-v1.49.2-beta.1) (2025-09-29)
 
 

package/dist/commands/aigne.d.ts

@@ -1,5 +1,4 @@
-import yargs from "yargs";
 export declare function createAIGNECommand(options?: {
     argv?: string[];
     aigneFilePath?: string;
-}): yargs.Argv<{}>;
+}): import("yargs").Argv<{}>;

package/dist/commands/app.d.ts

@@ -1,5 +1,5 @@
 import type { CommandModule } from "yargs";
-import { type AgentInChildProcess, type LoadAIGNEInChildProcessResult } from "../utils/workers/run-aigne-in-child-process.js";
+import { type AgentInChildProcess, type CLIAgentInChildProcess, type LoadAIGNEInChildProcessResult } from "../utils/workers/run-aigne-in-child-process.js";
 import { type AgentRunCommonOptions } from "../utils/yargs.js";
 export declare function createAppCommands({ argv }?: {
     argv?: string[];
@@ -8,6 +8,11 @@ export declare const agentCommandModule: ({ dir, agent, }: {
     dir: string;
     agent: AgentInChildProcess;
 }) => CommandModule<unknown, AgentRunCommonOptions>;
+export declare const cliAgentCommandModule: ({ dir, parent, cliAgent, }: {
+    dir: string;
+    parent?: string[];
+    cliAgent: CLIAgentInChildProcess;
+}) => CommandModule<unknown, AgentRunCommonOptions>;
 interface LoadApplicationOptions {
     packageName: string;
     dir: string;

package/dist/commands/app.js

@@ -1,3 +1,4 @@
+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";
@@ -53,8 +54,8 @@ export function createAppCommands({ argv } = {}) {
                         command: "$0",
                     });
                 }
-                for (const agent of aigne.cli?.agents ?? []) {
-                    y.command(agentCommandModule({ dir, agent }));
+                for (const cliAgent of aigne.cli?.agents ?? []) {
+                    y.command(cliAgentCommandModule({ dir, cliAgent }));
                 }
                 y.option("model", {
                     type: "string",
@@ -152,6 +153,42 @@ export const agentCommandModule = ({ dir, agent, }) => {
         },
     };
 };
+export const cliAgentCommandModule = ({ dir, parent, cliAgent, }) => {
+    const { agent, agents } = cliAgent;
+    const name = cliAgent.name || agent?.name;
+    assert(name, "CLI agent must have a name");
+    return {
+        command: name,
+        aliases: cliAgent.alias || agent?.alias || [],
+        describe: cliAgent.description || agent?.description || "",
+        builder: async (yargs) => {
+            if (agent) {
+                withAgentInputSchema(yargs, { inputSchema: jsonSchemaToZod(agent.inputSchema) });
+            }
+            if (agents?.length) {
+                for (const cmd of agents) {
+                    yargs.command(cliAgentCommandModule({ dir, parent: (parent ?? []).concat(name), cliAgent: cmd }));
+                }
+            }
+            if (!agent)
+                yargs.demandCommand();
+            return yargs;
+        },
+        handler: async (options) => {
+            if (!agent)
+                throw new Error("CLI agent is not defined");
+            if (options.logLevel)
+                logger.level = options.logLevel;
+            await runAIGNEInChildProcess("invokeCLIAgentFromDir", {
+                dir,
+                parent,
+                agent: name,
+                input: options,
+            });
+            process.exit(0);
+        },
+    };
+};
 export async function loadApplication(options) {
     const { dir, packageName } = options;
     const check = await checkInstallation(dir);

package/dist/commands/eval.js

@@ -1,5 +1,6 @@
 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";
@@ -70,7 +71,7 @@ export function createEvalCommand({ aigneFilePath, } = {}) {
             const { chat } = aigne.cli;
             const agent = chat && chat.name === entryAgent
                 ? chat
-                : aigne.cli.agents[entryAgent] ||
+                : findCliAgent(aigne.cli, "*", entryAgent) ||
                     aigne.agents[entryAgent] ||
                     aigne.skills[entryAgent] ||
                     aigne.mcpServer.agents[entryAgent];
@@ -80,7 +81,7 @@ export function createEvalCommand({ aigneFilePath, } = {}) {
             let evaluatorAgent;
             if (evaluatorName) {
                 evaluatorAgent =
-                    aigne.cli.agents[evaluatorName] ||
+                    findCliAgent(aigne.cli, "*", evaluatorName) ||
                         aigne.agents[evaluatorName] ||
                         aigne.skills[evaluatorName] ||
                         aigne.mcpServer.agents[evaluatorName];

package/dist/commands/run.js

@@ -2,6 +2,7 @@ import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { exists } from "@aigne/agent-library/utils/fs.js";
+import { mapCliAgent } from "@aigne/core/utils/agent-utils.js";
 import { flat, isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { config } from "dotenv-flow";
@@ -11,7 +12,7 @@ import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { isUrl } from "../utils/url.js";
 import { serializeAgent } from "../utils/workers/run-aigne-in-child-process.js";
-import { agentCommandModule } from "./app.js";
+import { agentCommandModule, cliAgentCommandModule } from "./app.js";
 export function createRunCommand({ aigneFilePath, } = {}) {
     return {
         command: "run [path] [entry-agent]",
@@ -47,10 +48,16 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                 });
             }
             // Allow user to run all of agents in the AIGNE instances
-            const allAgents = flat(aigne.cli.agents, aigne.agents, aigne.skills, aigne.cli.chat, aigne.mcpServer.agents);
+            const allAgents = flat(aigne.agents, aigne.skills, aigne.cli.chat, aigne.mcpServer.agents);
             for (const agent of allAgents) {
                 subYargs.command(agentCommandModule({ dir: path, agent: serializeAgent(agent) }));
             }
+            for (const cliAgent of aigne.cli.agents ?? []) {
+                subYargs.command(cliAgentCommandModule({
+                    dir: path,
+                    cliAgent: mapCliAgent(cliAgent, (a) => (a ? serializeAgent(a) : undefined)),
+                }));
+            }
             const argv = process.argv.slice(aigneFilePath ? 3 : 2);
             if (argv[0] === "run")
                 argv.shift(); // remove 'run' command
@@ -62,8 +69,9 @@ export function createRunCommand({ aigneFilePath, } = {}) {
             if (argv[0] === "--entry-agent")
                 argv.shift();
             const firstAgent = aigne.agents[0]?.name;
-            if (!options.entryAgent && firstAgent)
+            if (!options.entryAgent && firstAgent && !argv.some((i) => ["-h", "--help"].includes(i))) {
                 argv.unshift(firstAgent);
+            }
             await subYargs
                 .strict()
                 .demandCommand()

package/dist/tracer/terminal.js

@@ -12,6 +12,7 @@ import terminalImage from "terminal-image";
 import terminalLink from "terminal-link";
 import { withProtocol } from "ufo";
 import { AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE } from "../constants.js";
+import { terminalInput } from "../ui/utils/terminal-input.js";
 import checkbox from "../utils/inquirer/checkbox.js";
 import { AIGNEListr, AIGNEListrRenderer } from "../utils/listr.js";
 import { highlightUrl } from "../utils/string-utils.js";
@@ -195,8 +196,10 @@ export class TerminalTracer {
         get: (_target, prop) => {
             const method = prop === "checkbox"
                 ? checkbox
-                : // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
-                    prompts[prop];
+                : prop === "input"
+                    ? terminalInput
+                    : // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
+                        prompts[prop];
             if (typeof method !== "function")
                 throw new Error(`Unsupported prompt method ${String(prop)}`);
             return async (config) => {

package/dist/ui/utils/error.d.ts

@@ -0,0 +1,2 @@
+export declare class SIGINTError extends Error {
+}

package/dist/ui/utils/error.js

@@ -0,0 +1,2 @@
+export class SIGINTError extends Error {
+}

package/dist/ui/utils/terminal-input.d.ts

@@ -0,0 +1,4 @@
+export declare function terminalInput(options?: {
+    message?: string;
+    default?: string;
+}): Promise<string>;

package/dist/ui/utils/terminal-input.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import chalk from "chalk";
+import { render, Text, useInput } from "ink";
+import { SIGINTError } from "./error.js";
+import { useTextBuffer } from "./text-buffer.js";
+export async function terminalInput(options = {}) {
+    return new Promise((resolve, reject) => {
+        process.addListener("SIGINT", () => {
+            reject(new Error("Input aborted"));
+        });
+        const app = render(_jsx(Input, { ...options, onSubmit: (value) => {
+                app.clear();
+                app.unmount();
+                console.log(`${options.message} ${value}`); // echo the input back to terminal
+                resolve(value);
+            }, onError: (error) => {
+                app.unmount();
+                reject(error);
+            } }), { exitOnCtrlC: false });
+    });
+}
+function Input(props) {
+    const buffer = useTextBuffer({
+        initialText: props.default || "",
+        isValidPath: () => false,
+        viewport: { width: 80, height: 1 },
+    });
+    useInput((character, key) => {
+        if (character === "c" && key.ctrl) {
+            props.onError(new SIGINTError("Input aborted by user"));
+            return;
+        }
+        if (key.return) {
+            props.onSubmit(buffer.text);
+            return;
+        }
+        else if (key.backspace)
+            buffer.backspace();
+        else if (key.delete)
+            buffer.backspace();
+        else if (key.downArrow)
+            buffer.move("down");
+        else if (key.upArrow)
+            buffer.move("up");
+        else if (key.leftArrow)
+            buffer.move("left");
+        else if (key.rightArrow)
+            buffer.move("right");
+        else if (character === "a" && key.ctrl)
+            buffer.move("home");
+        else if (character === "e" && key.ctrl)
+            buffer.move("end");
+        else {
+            buffer.handleInput({ ...key, name: character, sequence: character, paste: false });
+        }
+    });
+    const lines = [...buffer.lines];
+    const [row, col] = buffer.cursor;
+    const currentLine = lines[row] || "";
+    lines[row] =
+        currentLine.slice(0, col) + chalk.inverse(currentLine[col] || " ") + currentLine.slice(col + 1);
+    return (_jsxs(Text, { children: [props.message, " ", lines.join("\n")] }));
+}

package/dist/ui/utils/text-buffer.d.ts

@@ -0,0 +1,87 @@
+export type Direction = "left" | "right" | "up" | "down" | "wordLeft" | "wordRight" | "home" | "end";
+interface Viewport {
+    height: number;
+    width: number;
+}
+interface UseTextBufferProps {
+    initialText?: string;
+    initialCursorOffset?: number;
+    viewport: Viewport;
+    onChange?: (text: string) => void;
+    isValidPath: (path: string) => boolean;
+    shellModeActive?: boolean;
+}
+export declare function useTextBuffer({ initialText, initialCursorOffset, viewport, onChange, isValidPath, shellModeActive, }: UseTextBufferProps): TextBuffer;
+export interface TextBuffer {
+    lines: string[];
+    text: string;
+    cursor: [number, number];
+    /**
+     * When the user moves the caret vertically we try to keep their original
+     * horizontal column even when passing through shorter lines.  We remember
+     * that *preferred* column in this field while the user is still travelling
+     * vertically.  Any explicit horizontal movement resets the preference.
+     */
+    preferredCol: number | null;
+    selectionAnchor: [number, number] | null;
+    allVisualLines: string[];
+    viewportVisualLines: string[];
+    visualCursor: [number, number];
+    visualScrollRow: number;
+    /**
+     * For each visual line (by absolute index in allVisualLines) provides a tuple
+     * [logicalLineIndex, startColInLogical] that maps where that visual line
+     * begins within the logical buffer. Indices are code-point based.
+     */
+    visualToLogicalMap: Array<[number, number]>;
+    /**
+     * Replaces the entire buffer content with the provided text.
+     * The operation is undoable.
+     */
+    setText: (text: string) => void;
+    /**
+     * Insert a single character or string without newlines.
+     */
+    insert: (ch: string, opts?: {
+        paste?: boolean;
+    }) => void;
+    newline: () => void;
+    backspace: () => void;
+    del: () => void;
+    move: (dir: Direction) => void;
+    undo: () => void;
+    redo: () => void;
+    /**
+     * Delete the word to the *left* of the caret, mirroring common
+     * Ctrl/Alt+Backspace behaviour in editors & terminals. Both the adjacent
+     * whitespace *and* the word characters immediately preceding the caret are
+     * removed.  If the caret is already at column‑0 this becomes a no-op.
+     */
+    deleteWordLeft: () => void;
+    /**
+     * Delete the word to the *right* of the caret, akin to many editors'
+     * Ctrl/Alt+Delete shortcut.  Removes any whitespace/punctuation that
+     * follows the caret and the next contiguous run of word characters.
+     */
+    deleteWordRight: () => void;
+    /**
+     * Deletes text from the cursor to the end of the current line.
+     */
+    killLineRight: () => void;
+    /**
+     * Deletes text from the start of the current line to the cursor.
+     */
+    killLineLeft: () => void;
+    /**
+     * High level "handleInput" – receives what Ink gives us.
+     */
+    handleInput: (key: {
+        name: string;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+        paste: boolean;
+        sequence: string;
+    }) => void;
+}
+export {};