@aigne/cli 1.41.3 → 1.42.1

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [1.42.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.42.0...cli-v1.42.1) (2025-08-29)
+
+
+### Bug Fixes
+
+* resolve checkbox multi-select issues and add comprehensive test ([#430](https://github.com/AIGNE-io/aigne-framework/issues/430)) ([a81be74](https://github.com/AIGNE-io/aigne-framework/commit/a81be74253923a1a2981f0780a15f175fd439210))
+
+## [1.42.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.41.3...cli-v1.42.0) (2025-08-28)
+
+
+### Features
+
+* **cli:** add searchable checkbox component with dynamic filtering ([#426](https://github.com/AIGNE-io/aigne-framework/issues/426)) ([1a76fe7](https://github.com/AIGNE-io/aigne-framework/commit/1a76fe7c2f7d91bc4041dfcd73850b39a18a036b))
+
+
+### Bug Fixes
+
+* **cli:** only show ascii logo on help and errors ([#425](https://github.com/AIGNE-io/aigne-framework/issues/425)) ([1279376](https://github.com/AIGNE-io/aigne-framework/commit/1279376b7ca9c1c38148dcde581ee4730771a4ad))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.31
+    * @aigne/agentic-memory bumped to 1.0.31
+    * @aigne/aigne-hub bumped to 0.8.1
+    * @aigne/core bumped to 1.57.0
+    * @aigne/default-memory bumped to 1.1.13
+    * @aigne/openai bumped to 0.13.2
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.38
+
 ## [1.41.3](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.41.2...cli-v1.41.3) (2025-08-27)
 
 

package/dist/cli.js

@@ -23,6 +23,7 @@ export default createAIGNECommand({ aigneFilePath })
     if (!error) {
         yargs.showHelp();
         console.error(`\n${message}`);
+        process.exit(1);
     }
 })
     .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))

package/dist/commands/aigne.js

@@ -10,10 +10,9 @@ import { createRunCommand } from "./run.js";
 import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
-    console.log(asciiLogo);
     return yargs()
         .scriptName("aigne")
-        .usage("CLI for AIGNE framework")
+        .usage(`${asciiLogo}\n$0 <command> [options]`)
         .version(AIGNE_CLI_VERSION)
         .command(createRunCommand(options))
         .command(createTestCommand(options))
@@ -26,5 +25,6 @@ export function createAIGNECommand(options) {
         .demandCommand()
         .alias("help", "h")
         .alias("version", "v")
+        .wrap(null)
         .strict();
 }

package/dist/tracer/terminal.js

@@ -9,6 +9,7 @@ import * as prompts from "@inquirer/prompts";
 import chalk from "chalk";
 import { Marked } from "marked";
 import { AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE } from "../constants.js";
+import checkbox from "../utils/inquirer/checkbox.js";
 import { AIGNEListr, AIGNEListrRenderer } from "../utils/listr.js";
 import { highlightUrl } from "../utils/string-utils.js";
 import { parseDuration } from "../utils/time.js";
@@ -188,10 +189,12 @@ export class TerminalTracer {
     listr;
     proxiedPrompts = new Proxy({}, {
         get: (_target, prop) => {
-            // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
-            const method = prompts[prop];
+            const method = prop === "checkbox"
+                ? checkbox
+                : // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
+                    prompts[prop];
             if (typeof method !== "function")
-                return undefined;
+                throw new Error(`Unsupported prompt method ${String(prop)}`);
             return async (config) => {
                 const renderer = this.listr?.["renderer"] instanceof AIGNEListrRenderer
                     ? this.listr["renderer"]

package/dist/utils/inquirer/checkbox.d.ts

@@ -0,0 +1,55 @@
+import { Separator, type Theme } from "@inquirer/core";
+import type { PartialDeep } from "@inquirer/type";
+type CheckboxTheme = {
+    icon: {
+        checked: string;
+        unchecked: string;
+        cursor: string;
+    };
+    style: {
+        disabledChoice: (text: string) => string;
+        renderSelectedChoices: <T>(selectedChoices: ReadonlyArray<NormalizedChoice<T>>, allChoices: ReadonlyArray<NormalizedChoice<T> | Separator>) => string;
+        description: (text: string) => string;
+        searchTerm: (text: string) => string;
+    };
+    helpMode: "always" | "never" | "auto";
+};
+type CheckboxShortcuts = {
+    all?: string | null;
+    invert?: string | null;
+};
+type Choice<Value> = {
+    value: Value;
+    name?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+    checked?: boolean;
+    type?: never;
+};
+type NormalizedChoice<Value> = {
+    value: Value;
+    name: string;
+    description?: string;
+    short: string;
+    disabled: boolean | string;
+    checked: boolean;
+};
+declare const _default: <Value>(config: {
+    message: string;
+    prefix?: string | undefined;
+    pageSize?: number | undefined;
+    instructions?: string | boolean | undefined;
+    choices?: readonly (string | Separator)[] | readonly (Separator | Choice<Value>)[] | undefined;
+    source?: ((term: string | undefined, opt: {
+        signal: AbortSignal;
+    }) => readonly (string | Separator)[] | Promise<readonly (string | Separator)[]> | readonly (Separator | Choice<Value>)[] | Promise<readonly (Separator | Choice<Value>)[]>) | undefined;
+    loop?: boolean | undefined;
+    required?: boolean | undefined;
+    validate?: ((choices: readonly Choice<Value>[]) => boolean | string | Promise<string | boolean>) | undefined;
+    theme?: PartialDeep<Theme<CheckboxTheme>> | undefined;
+    shortcuts?: CheckboxShortcuts | undefined;
+}, context?: import("@inquirer/type").Context) => Promise<Value[]> & {
+    cancel: () => void;
+};
+export default _default;

package/dist/utils/inquirer/checkbox.js

@@ -0,0 +1,303 @@
+import { createPrompt, isDownKey, isEnterKey, isNumberKey, isSpaceKey, isUpKey, makeTheme, Separator, useEffect, useKeypress, useMemo, usePagination, usePrefix, useRef, useState, ValidationError, } from "@inquirer/core";
+import figures from "@inquirer/figures";
+import ansiEscapes from "ansi-escapes";
+import colors from "yoctocolors-cjs";
+const checkboxTheme = {
+    icon: {
+        checked: colors.green(figures.circleFilled),
+        unchecked: figures.circle,
+        cursor: figures.pointer,
+    },
+    style: {
+        disabledChoice: (text) => colors.dim(`- ${text}`),
+        renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+        description: (text) => colors.cyan(text),
+        searchTerm: (text) => colors.cyan(text),
+    },
+    helpMode: "auto",
+};
+function isSelectable(item) {
+    return !Separator.isSeparator(item) && !item.disabled;
+}
+function toggle(item) {
+    return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+    return (item) => isSelectable(item) ? { ...item, checked } : item;
+}
+function normalizeChoices(choices) {
+    return choices.map((choice) => {
+        if (Separator.isSeparator(choice))
+            return choice;
+        if (typeof choice === "string") {
+            return {
+                value: choice,
+                name: choice,
+                short: choice,
+                disabled: false,
+                checked: false,
+            };
+        }
+        const name = choice.name ?? String(choice.value);
+        const normalizedChoice = {
+            value: choice.value,
+            name,
+            short: choice.short ?? name,
+            disabled: choice.disabled ?? false,
+            checked: choice.checked ?? false,
+        };
+        if (choice.description) {
+            normalizedChoice.description = choice.description;
+        }
+        return normalizedChoice;
+    });
+}
+export default createPrompt((config, done) => {
+    const { instructions, pageSize = 7, loop = true, required, validate = () => true } = config;
+    const shortcuts = { all: "a", invert: "i", ...config.shortcuts };
+    const theme = makeTheme(checkboxTheme, config.theme);
+    const firstRender = useRef(true);
+    const [status, setStatus] = useState(config.source ? "loading" : "idle");
+    const prefix = usePrefix({ status, theme });
+    const [searchTerm, setSearchTerm] = useState("");
+    const [searchError, setSearchError] = useState();
+    const initialItems = config.choices ? normalizeChoices(config.choices) : [];
+    const initialSelectedChoices = new Map(initialItems
+        .filter((item) => !Separator.isSeparator(item) && item.checked)
+        .map((item) => [item.value, item]));
+    const [selectedChoices, setSelectedChoices] = useState(initialSelectedChoices);
+    const [items, setItems] = useState(initialItems);
+    useEffect(() => {
+        const { source } = config;
+        if (!source)
+            return;
+        const controller = new AbortController();
+        setStatus("loading");
+        setSearchError(undefined);
+        const fetchResults = async () => {
+            try {
+                const results = await source(searchTerm || undefined, {
+                    signal: controller.signal,
+                });
+                if (!controller.signal.aborted) {
+                    const normalizedResults = normalizeChoices(results);
+                    // Preserve selected state from selectedChoices
+                    const itemsWithSelection = normalizedResults.map((item) => {
+                        if (!Separator.isSeparator(item)) {
+                            return {
+                                ...item,
+                                checked: selectedChoices.has(item.value),
+                            };
+                        }
+                        return item;
+                    });
+                    setItems(itemsWithSelection);
+                    // Reset active to first selectable item after search
+                    const firstSelectable = itemsWithSelection.findIndex(isSelectable);
+                    if (firstSelectable >= 0) {
+                        setActive(firstSelectable);
+                    }
+                    setSearchError(undefined);
+                    setStatus("idle");
+                }
+            }
+            catch (error) {
+                if (!controller.signal.aborted && error instanceof Error) {
+                    setSearchError(error.message);
+                }
+            }
+        };
+        void fetchResults();
+        return () => {
+            controller.abort();
+        };
+    }, [searchTerm, config.source, selectedChoices]);
+    const bounds = useMemo(() => {
+        const first = items.findIndex(isSelectable);
+        const last = items.findLastIndex(isSelectable);
+        if (first === -1 && !config.source && status !== "loading") {
+            throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+        }
+        return { first, last };
+    }, [items, config.source, status]);
+    const [active, setActive] = useState(bounds.first >= 0 ? bounds.first : 0);
+    const [showHelpTip, setShowHelpTip] = useState(true);
+    const [errorMsg, setError] = useState();
+    useKeypress(async (key, rl) => {
+        if (isEnterKey(key)) {
+            const selectionChoices = Array.from(selectedChoices.values());
+            const isValid = await validate(selectionChoices);
+            if (required && selectedChoices.size === 0) {
+                setError("At least one choice must be selected");
+            }
+            else if (isValid === true) {
+                setStatus("done");
+                done(selectionChoices.map((choice) => choice.value));
+            }
+            else {
+                setError(isValid || "You must select a valid value");
+            }
+        }
+        else if (isUpKey(key) || isDownKey(key)) {
+            if (loop ||
+                (isUpKey(key) && active !== bounds.first) ||
+                (isDownKey(key) && active !== bounds.last)) {
+                const offset = isUpKey(key) ? -1 : 1;
+                let next = active;
+                do {
+                    next = (next + offset + items.length) % items.length;
+                    // biome-ignore lint/style/noNonNullAssertion: we need to access items dynamically
+                } while (!isSelectable(items[next]));
+                setActive(next);
+            }
+        }
+        else if (isSpaceKey(key)) {
+            setError(undefined);
+            setShowHelpTip(false);
+            if (config.source) {
+                // In search mode, prevent space from being added to search term
+                rl.clearLine(0);
+                rl.write(searchTerm); // Restore search term without the space
+            }
+            const activeItem = items[active];
+            if (activeItem && isSelectable(activeItem)) {
+                const newSelectedChoices = new Map(selectedChoices);
+                if (selectedChoices.has(activeItem.value)) {
+                    newSelectedChoices.delete(activeItem.value);
+                }
+                else {
+                    newSelectedChoices.set(activeItem.value, activeItem);
+                }
+                setSelectedChoices(newSelectedChoices);
+                setItems(items.map((choice, i) => (i === active ? toggle(choice) : choice)));
+            }
+        }
+        else if (key.name === shortcuts.all && !config.source) {
+            const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+            const newSelectedChoices = new Map();
+            if (selectAll) {
+                items.forEach((item) => {
+                    if (isSelectable(item)) {
+                        newSelectedChoices.set(item.value, item);
+                    }
+                });
+            }
+            setSelectedChoices(newSelectedChoices);
+            setItems(items.map(check(selectAll)));
+        }
+        else if (key.name === shortcuts.invert && !config.source) {
+            const newSelectedChoices = new Map();
+            items.forEach((item) => {
+                if (isSelectable(item)) {
+                    if (!selectedChoices.has(item.value)) {
+                        newSelectedChoices.set(item.value, item);
+                    }
+                }
+            });
+            setSelectedChoices(newSelectedChoices);
+            setItems(items.map(toggle));
+        }
+        else if (isNumberKey(key) && !config.source) {
+            const selectedIndex = Number(key.name) - 1;
+            // Find the nth item (ignoring separators)
+            let selectableIndex = -1;
+            const position = items.findIndex((item) => {
+                if (Separator.isSeparator(item))
+                    return false;
+                selectableIndex++;
+                return selectableIndex === selectedIndex;
+            });
+            const selectedItem = items[position];
+            if (selectedItem && isSelectable(selectedItem)) {
+                setActive(position);
+                const newSelectedChoices = new Map(selectedChoices);
+                if (selectedChoices.has(selectedItem.value)) {
+                    newSelectedChoices.delete(selectedItem.value);
+                }
+                else {
+                    newSelectedChoices.set(selectedItem.value, selectedItem);
+                }
+                setSelectedChoices(newSelectedChoices);
+                setItems(items.map((choice, i) => (i === position ? toggle(choice) : choice)));
+            }
+        }
+        else if (config.source && !isSpaceKey(key)) {
+            setSearchTerm(rl.line);
+        }
+    });
+    const message = theme.style.message(config.message, status);
+    let description;
+    const page = usePagination({
+        items,
+        active,
+        renderItem({ item, isActive }) {
+            if (Separator.isSeparator(item)) {
+                return ` ${item.separator}`;
+            }
+            if (item.disabled) {
+                const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+                return theme.style.disabledChoice(`${item.name} ${disabledLabel}`);
+            }
+            if (isActive) {
+                description = item.description;
+            }
+            const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+            const color = isActive ? theme.style.highlight : (x) => x;
+            const cursor = isActive ? theme.icon.cursor : " ";
+            return color(`${cursor}${checkbox} ${item.name}`);
+        },
+        pageSize,
+        loop,
+    });
+    if (status === "done") {
+        const selection = Array.from(selectedChoices.values());
+        const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+        return `${prefix} ${message} ${answer}`;
+    }
+    let helpTipTop = "";
+    let helpTipBottom = "";
+    if (theme.helpMode === "always" ||
+        (theme.helpMode === "auto" && showHelpTip && (instructions === undefined || instructions))) {
+        if (typeof instructions === "string") {
+            helpTipTop = instructions;
+        }
+        else {
+            const keys = [
+                `${theme.style.key("space")} to select`,
+                !config.source && shortcuts.all ? `${theme.style.key(shortcuts.all)} to toggle all` : "",
+                !config.source && shortcuts.invert
+                    ? `${theme.style.key(shortcuts.invert)} to invert selection`
+                    : "",
+                `and ${theme.style.key("enter")} to proceed`,
+            ];
+            helpTipTop = ` (Press ${keys.filter((key) => key !== "").join(", ")})`;
+        }
+        if (items.length > pageSize &&
+            (theme.helpMode === "always" ||
+                (theme.helpMode === "auto" && (firstRender.current || config.source)))) {
+            helpTipBottom = `\n${theme.style.help("(Use arrow keys to reveal more choices)")}`;
+            if (!config.source) {
+                firstRender.current = false;
+            }
+        }
+    }
+    const choiceDescription = description ? `\n${theme.style.description(description)}` : ``;
+    let error = "";
+    if (searchError) {
+        error = `\n${theme.style.error(searchError)}`;
+    }
+    else if (config.source && items.length === 0 && searchTerm !== "" && status === "idle") {
+        error = `\n${theme.style.error("No results found")}`;
+    }
+    else if (errorMsg) {
+        error = `\n${theme.style.error(errorMsg)}`;
+    }
+    if (config.source) {
+        const searchStr = theme.style.searchTerm(searchTerm);
+        return [
+            [prefix, message, searchStr].filter(Boolean).join(" "),
+            `${error || page}${helpTipBottom}${choiceDescription}`,
+        ];
+    }
+    return `${prefix} ${message}${helpTipTop}\n${page}${helpTipBottom}${choiceDescription}${error}${ansiEscapes.cursorHide}`;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.41.3",
+  "version": "1.42.1",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -47,12 +47,15 @@
   "dependencies": {
     "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.2",
-    "@inquirer/prompts": "^7.6.0",
+    "@inquirer/core": "^10.2.0",
+    "@inquirer/figures": "^1.0.13",
+    "@inquirer/prompts": "^7.8.4",
     "@inquirer/type": "^3.0.8",
-    "@listr2/prompt-adapter-inquirer": "^3.0.1",
+    "@listr2/prompt-adapter-inquirer": "^3.0.2",
     "@modelcontextprotocol/sdk": "^1.15.0",
     "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
+    "ansi-escapes": "^7.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
@@ -62,7 +65,7 @@
     "glob": "^11.0.3",
     "gradient-string": "^3.0.0",
     "https-proxy-agent": "^7.0.6",
-    "inquirer": "^12.7.0",
+    "inquirer": "^12.9.4",
     "log-update": "^6.1.0",
     "marked": "^16.0.0",
     "nunjucks": "^3.2.4",
@@ -74,16 +77,18 @@
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
+    "yoctocolors-cjs": "^2.1.3",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.30",
-    "@aigne/agentic-memory": "^1.0.30",
-    "@aigne/core": "^1.56.0",
-    "@aigne/aigne-hub": "^0.8.0",
-    "@aigne/default-memory": "^1.1.12",
+    "@aigne/agent-library": "^1.21.31",
+    "@aigne/agentic-memory": "^1.0.31",
+    "@aigne/aigne-hub": "^0.8.1",
+    "@aigne/core": "^1.57.0",
     "@aigne/observability-api": "^0.10.1",
-    "@aigne/openai": "^0.13.1"
+    "@aigne/default-memory": "^1.1.13",
+    "@aigne/openai": "^0.13.2"
   },
   "devDependencies": {
+    "@inquirer/testing": "^2.1.49",
     "@types/archiver": "^6.0.3",
     "@types/bun": "^1.2.18",
     "@types/express": "^5.0.3",
@@ -97,7 +102,7 @@
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "ufo": "^1.6.1",
-    "@aigne/test-utils": "^0.5.37"
+    "@aigne/test-utils": "^0.5.38"
   },
   "scripts": {
     "lint": "tsc --noEmit",