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

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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)
 
 

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