@aigne/cli 1.50.0-beta.1 → 1.50.0-beta.3

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.50.0-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.50.0-beta.2...cli-v1.50.0-beta.3) (2025-10-01)
+
+
+### Bug Fixes
+
+* **ui:** enhance terminal input with status indicators and layout options ([#573](https://github.com/AIGNE-io/aigne-framework/issues/573)) ([31b83df](https://github.com/AIGNE-io/aigne-framework/commit/31b83df86fa959a37e6df2df516d7fc3015dc63b))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.47-beta.2
+    * @aigne/agentic-memory bumped to 1.0.47-beta.2
+    * @aigne/aigne-hub bumped to 0.10.1-beta.2
+    * @aigne/core bumped to 1.62.0-beta.1
+    * @aigne/default-memory bumped to 1.2.10-beta.2
+    * @aigne/openai bumped to 0.16.1-beta.2
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.54-beta.2
+
+## [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)
 
 

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/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,5 @@
+export declare function terminalInput(options?: {
+    message?: string;
+    default?: string;
+    inline?: boolean;
+}): Promise<string>;

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

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import chalk from "chalk";
+import { Box, render, Text, useInput } from "ink";
+import { useState } from "react";
+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.unmount();
+                resolve(value);
+            }, onError: (error) => {
+                app.unmount();
+                reject(error);
+            } }), { exitOnCtrlC: false });
+    });
+}
+function Input(props) {
+    const buffer = useTextBuffer({
+        initialText: props.default || "",
+        initialCursorOffset: props.default?.length || 0,
+        isValidPath: () => false,
+        viewport: { width: 80, height: 1 },
+    });
+    const [status, setStatus] = useState("input");
+    useInput((character, key) => {
+        if (character === "c" && key.ctrl) {
+            setStatus("error");
+            setTimeout(() => {
+                props.onError(new SIGINTError("Input aborted by user"));
+            });
+            return;
+        }
+        if (key.return) {
+            setStatus("success");
+            setTimeout(() => {
+                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];
+    if (status === "input") {
+        const [row, col] = buffer.cursor;
+        const currentLine = lines[row] || "";
+        lines[row] =
+            currentLine.slice(0, col) +
+                chalk.inverse(currentLine[col] || " ") +
+                currentLine.slice(col + 1);
+    }
+    const label = props.message && chalk.bold(props.message);
+    const inline = props.inline !== false;
+    return (_jsxs(Box, { flexDirection: inline ? "row" : "column", children: [_jsxs(Text, { children: [PREFIX[status], " ", !inline && label] }), _jsx(Box, { flexShrink: 1, flexGrow: 1, marginLeft: inline ? 0 : 2, children: _jsxs(Text, { children: [!!label && inline && `${label} `, lines.join("\n")] }) })] }));
+}
+const PREFIX = {
+    input: chalk.blue("?"),
+    success: chalk.green("✔"),
+    error: chalk.red("✘"),
+};

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 {};