@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/commands/serve-mcp.d.ts

@@ -1,20 +0,0 @@
-import type { AIGNE } from "@aigne/core";
-import type { CommandModule } from "yargs";
-interface ServeMCPOptions {
-    path: string;
-    host: string;
-    port?: number;
-    pathname: string;
-    aigneHubUrl?: string;
-}
-export declare const DEFAULT_PORT: () => number;
-export declare function createServeMCPCommand({ aigneFilePath, }?: {
-    aigneFilePath?: string;
-}): CommandModule<unknown, ServeMCPOptions>;
-export declare function serveMCPServerFromDir(options: {
-    aigne: AIGNE;
-    host: string;
-    port?: number;
-    pathname: string;
-}): Promise<void>;
-export {};

package/dist/commands/serve-mcp.js

@@ -1,67 +0,0 @@
-import { isAbsolute, resolve } from "node:path";
-import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
-import { loadAIGNE } from "../utils/load-aigne.js";
-import { serveMCPServer } from "../utils/serve-mcp.js";
-export const DEFAULT_PORT = () => tryOrThrow(() => {
-    const { PORT } = process.env;
-    if (!PORT)
-        return 3000;
-    const port = Number.parseInt(PORT, 10);
-    if (!port || !Number.isInteger(port))
-        throw new Error(`Invalid PORT: ${PORT}`);
-    return port;
-}, (error) => new Error(`parse PORT error ${error.message}`));
-export function createServeMCPCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "serve-mcp",
-        describe: "Serve the agents in the specified directory as a MCP server (streamable http)",
-        builder: (yargs) => {
-            return yargs
-                .option("path", {
-                describe: "Path to the agents directory or URL to aigne project",
-                type: "string",
-                default: ".",
-                alias: ["url"],
-            })
-                .option("host", {
-                describe: "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server",
-                type: "string",
-                default: "localhost",
-            })
-                .option("port", {
-                describe: "Port to run the MCP server on",
-                type: "number",
-            })
-                .option("pathname", {
-                describe: "Pathname to the service",
-                type: "string",
-                default: "/mcp",
-            })
-                .option("aigne-hub-url", {
-                describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models. ",
-                type: "string",
-            });
-        },
-        handler: async (options) => {
-            const path = aigneFilePath || options.path;
-            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const aigne = await loadAIGNE({
-                path: absolutePath,
-                modelOptions: { aigneHubUrl: options.aigneHubUrl },
-            });
-            await serveMCPServerFromDir({ ...options, aigne });
-        },
-    };
-}
-export async function serveMCPServerFromDir(options) {
-    const port = options.port || DEFAULT_PORT();
-    await serveMCPServer({
-        aigne: options.aigne,
-        host: options.host,
-        port,
-        pathname: options.pathname,
-    });
-    console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
-    if (!process.env.CI && process.env.NODE_ENV !== "test")
-        await new Promise(() => { }); // Keep the server running
-}

package/dist/commands/test.d.ts

@@ -1,9 +0,0 @@
-import type { CommandModule } from "yargs";
-interface TestOptions {
-    path: string;
-    aigneHubUrl?: string;
-}
-export declare function createTestCommand({ aigneFilePath, }?: {
-    aigneFilePath?: string;
-}): CommandModule<unknown, TestOptions>;
-export {};

package/dist/commands/test.js

@@ -1,33 +0,0 @@
-import assert from "node:assert";
-import { spawnSync } from "node:child_process";
-import { isAbsolute, resolve } from "node:path";
-import { loadAIGNE } from "../utils/load-aigne.js";
-export function createTestCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "test",
-        describe: "Run tests in the specified agents directory",
-        builder: (yargs) => {
-            return yargs
-                .option("path", {
-                describe: "Path to the agents directory or URL to aigne project",
-                type: "string",
-                default: ".",
-                alias: ["url"],
-            })
-                .option("aigne-hub-url", {
-                describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models. ",
-                type: "string",
-            });
-        },
-        handler: async (options) => {
-            const path = aigneFilePath || options.path;
-            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const aigne = await loadAIGNE({
-                path: absolutePath,
-                modelOptions: { aigneHubUrl: options?.aigneHubUrl },
-            });
-            assert(aigne.rootDir);
-            spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
-        },
-    };
-}

package/dist/constants.d.ts

@@ -1,7 +0,0 @@
-import { DefaultMemory } from "@aigne/default-memory";
-export declare const AIGNE_CLI_VERSION: any;
-export declare const availableMemories: (typeof DefaultMemory)[];
-export declare const AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE = "NOT_ENOUGH";
-export declare const CHAT_MODEL_OPTIONS: string[];
-export declare const DEFAULT_USER_ID = "cli-user";
-export declare const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/constants.js

@@ -1,21 +0,0 @@
-import { createRequire } from "node:module";
-import { AgenticMemory } from "@aigne/agentic-memory";
-import { DefaultMemory } from "@aigne/default-memory";
-const require = createRequire(import.meta.url);
-export const AIGNE_CLI_VERSION = require("../package.json").version;
-export const availableMemories = [DefaultMemory, AgenticMemory];
-export const AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE = "NOT_ENOUGH";
-export const CHAT_MODEL_OPTIONS = [
-    "aigneHubUrl",
-    "model",
-    "temperature",
-    "topP",
-    "frequencyPenalty",
-    "presencePenalty",
-    "parallelToolCalls",
-    "modalities",
-    "preferInputFileType",
-    "reasoningEffort",
-];
-export const DEFAULT_USER_ID = "cli-user";
-export const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/index.d.ts

@@ -1 +0,0 @@
-export * from "./type.js";

package/dist/index.js

@@ -1 +0,0 @@
-export * from "./type.js";

package/dist/tracer/terminal.d.ts

@@ -1,62 +0,0 @@
-import { type InspectOptions } from "node:util";
-import { type Agent, type Context, type ContextUsage, type InvokeOptions, type Message } from "@aigne/core";
-import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
-import { type Listr } from "@aigne/listr2";
-import { type AIGNEListrTaskWrapper } from "../utils/listr.js";
-export interface TerminalTracerOptions {
-    outputKey?: string;
-    outputFileKey?: string;
-}
-export declare class TerminalTracer {
-    readonly context: Context;
-    readonly options: TerminalTracerOptions;
-    constructor(context: Context, options?: TerminalTracerOptions);
-    private tasks;
-    run(agent: Agent, input: Message, options?: InvokeOptions): Promise<{
-        result: Message;
-        context: Context<import("@aigne/core").UserContext>;
-    }>;
-    private listr?;
-    private proxiedPrompts;
-    private buyCreditsPromptPromise;
-    private promptBuyCredits;
-    formatAigneHubCredits(credits: number, creditPrefix?: string): [string, string];
-    formatTokenUsage(usage: Partial<ContextUsage>, extra?: {
-        [key: string]: string;
-    }): string;
-    formatTimeUsage(startTime: number, endTime: number): string;
-    formatTaskTitle(agent: Agent, { task, usage, time, input }: {
-        task?: Task;
-        usage?: boolean;
-        time?: boolean;
-        input: Message;
-    }): Promise<string>;
-    private marked;
-    get outputKey(): string;
-    get outputFileKey(): string;
-    formatRequest(agent: Agent, _context: Context, m?: Message, { running }?: {
-        running?: boolean | undefined;
-    }): string | undefined;
-    formatResult(agent: Agent, context: Context, m?: Message, { running, renderImage }?: {
-        running?: boolean | undefined;
-        renderImage?: boolean | undefined;
-    }): string | Promise<string>;
-    formatResultData(output: Message): Promise<string | undefined>;
-    protected runningInspectOptions: InspectOptions;
-}
-type Task = ReturnType<typeof promiseWithResolvers<void>> & {
-    listr: ReturnType<typeof promiseWithResolvers<{
-        ctx: object;
-        subtask: Listr;
-        taskWrapper: AIGNEListrTaskWrapper;
-    }>>;
-    agent: Agent;
-    input: Message;
-    startTime?: number;
-    endTime?: number;
-    usage?: Partial<ContextUsage>;
-    extraTitleMetadata?: {
-        [key: string]: string;
-    };
-};
-export {};

package/dist/tracer/terminal.js

@@ -1,404 +0,0 @@
-import { EOL } from "node:os";
-import { inspect } from "node:util";
-import { AIAgent, ChatModel, DEFAULT_OUTPUT_FILE_KEY, 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";
-import { markedTerminal } from "@aigne/marked-terminal";
-import * as prompts from "@inquirer/prompts";
-import chalk from "chalk";
-import { Marked } from "marked";
-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";
-import { parseDuration } from "../utils/time.js";
-const CREDITS_ERROR_PROCESSED_FLAG = "$credits_error_processed";
-export class TerminalTracer {
-    context;
-    options;
-    constructor(context, options = {}) {
-        this.context = context;
-        this.options = options;
-    }
-    tasks = {};
-    async run(agent, input, options) {
-        await this.context.observer?.serve();
-        const context = this.context.newContext({ reset: true });
-        const listr = new AIGNEListr({
-            formatRequest: (options) => this.formatRequest(agent, context, input, options),
-            formatResult: (result, options) => this.formatResult(agent, context, result, options),
-        }, [], { concurrent: true, exitOnError: false, registerSignalListeners: false });
-        this.listr = listr;
-        const collapsedMap = new Map();
-        const hideContextIds = new Set();
-        const onStart = async ({ context, agent, ...event }) => {
-            const result = { options: { prompts: this.proxiedPrompts } };
-            if (agent instanceof UserAgent)
-                return result;
-            if (agent.taskRenderMode === "hide") {
-                hideContextIds.add(context.id);
-                return result;
-            }
-            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 result;
-                }
-                const collapsed = collapsedMap.get(context.parentId);
-                if (collapsed) {
-                    collapsedMap.set(context.id, collapsed);
-                    return result;
-                }
-            }
-            const contextId = context.id;
-            const parentContextId = context.parentId;
-            const task = {
-                ...promiseWithResolvers(),
-                agent,
-                input: event.input,
-                listr: promiseWithResolvers(),
-                startTime: Date.now(),
-            };
-            this.tasks[contextId] = task;
-            const listrTask = {
-                title: await this.formatTaskTitle(agent, { ...event }),
-                task: (ctx, taskWrapper) => {
-                    const subtask = taskWrapper.newListr([{ task: () => task.promise }]);
-                    task.listr.resolve({ subtask, taskWrapper, ctx });
-                    return subtask;
-                },
-                rendererOptions: {
-                    persistentOutput: true,
-                    outputBar: Number.POSITIVE_INFINITY,
-                    bottomBar: Number.POSITIVE_INFINITY,
-                },
-            };
-            const parentTask = parentContextId ? this.tasks[parentContextId] : undefined;
-            if (parentTask) {
-                parentTask.listr.promise.then(({ subtask }) => {
-                    subtask.add(listrTask);
-                });
-            }
-            else {
-                listr.add(listrTask);
-            }
-            return result;
-        };
-        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 ||
-                            task.usage.cacheCreationInputTokens ||
-                            task.usage.cacheReadInputTokens),
-                        time: context.id === collapsed.ancestor.contextId,
-                    });
-                    if (context.id === collapsed.ancestor.contextId) {
-                        task?.resolve();
-                    }
-                    return;
-                }
-            }
-            const task = this.tasks[contextId];
-            if (!task)
-                return;
-            task.endTime = Date.now();
-            const { taskWrapper, ctx } = await task.listr.promise;
-            if (agent instanceof ChatModel) {
-                const { usage, model } = output;
-                task.usage = usage;
-                task.extraTitleMetadata ??= {};
-                if (model)
-                    task.extraTitleMetadata.model = model;
-            }
-            taskWrapper.title = await this.formatTaskTitle(agent, {
-                ...event,
-                task,
-                usage: true,
-                time: true,
-            });
-            if (!parentContextId || !this.tasks[parentContextId]) {
-                Object.assign(ctx, output);
-            }
-            task.resolve();
-        };
-        let retryPromptPromise;
-        const onError = async ({ context, agent, error, ...event }) => {
-            if ("type" in error && error.type === AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE) {
-                if (!Object.hasOwn(error, CREDITS_ERROR_PROCESSED_FLAG)) {
-                    Object.defineProperty(error, CREDITS_ERROR_PROCESSED_FLAG, {
-                        value: true,
-                        enumerable: false,
-                    });
-                    const retry = await this.promptBuyCredits(error);
-                    console.log("");
-                    if (retry === "retry") {
-                        return { retry: true };
-                    }
-                }
-            }
-            if (agent instanceof ChatModel) {
-                retryPromptPromise ??= this.proxiedPrompts
-                    .select({
-                    message: chalk.red(`Error: ${error.message}`),
-                    choices: [
-                        { value: "retry", name: "Retry" },
-                        { value: "exit", name: "Exit" },
-                    ],
-                })
-                    .then((result) => ({ retry: result === "retry" }))
-                    .finally(() => {
-                    retryPromptPromise = undefined;
-                });
-                const { retry } = await retryPromptPromise;
-                if (retry)
-                    return { retry: true };
-            }
-            const contextId = context.id;
-            const task = this.tasks[contextId];
-            if (!task)
-                return;
-            task.endTime = Date.now();
-            const { taskWrapper } = await task.listr.promise;
-            taskWrapper.title = await this.formatTaskTitle(agent, {
-                ...event,
-                task,
-                usage: true,
-                time: true,
-            });
-            task.reject(error);
-        };
-        const result = await listr.run(() => context.invoke(agent, input, {
-            ...options,
-            hooks: flat({
-                priority: "high",
-                onStart,
-                onSuccess,
-                onError,
-            }, options?.hooks),
-            streaming: true,
-            newContext: false,
-        }));
-        return { result, context };
-    }
-    listr;
-    proxiedPrompts = new Proxy({}, {
-        get: (_target, prop) => {
-            const method = prop === "checkbox"
-                ? checkbox
-                : 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) => {
-                const renderer = this.listr?.["renderer"] instanceof AIGNEListrRenderer
-                    ? this.listr["renderer"]
-                    : undefined;
-                await renderer?.pause();
-                try {
-                    return await method({ ...config });
-                }
-                finally {
-                    await renderer?.resume();
-                }
-            };
-        },
-    });
-    buyCreditsPromptPromise;
-    async promptBuyCredits(error) {
-        // Avoid multiple agents asking for credits, we will only show the prompt once
-        this.buyCreditsPromptPromise ??= (async () => {
-            const retry = await this.proxiedPrompts.select({
-                message: highlightUrl(error.message),
-                choices: [
-                    {
-                        name: "I have bought some credits, try again",
-                        value: "retry",
-                    },
-                    {
-                        name: "Exit",
-                        value: "exit",
-                    },
-                ],
-            });
-            return retry;
-        })();
-        return this.buyCreditsPromptPromise
-            .catch(() => "exit")
-            .finally(() => {
-            // Clear the promise so that we can show the prompt again if needed
-            this.buyCreditsPromptPromise = undefined;
-        });
-    }
-    formatAigneHubCredits(credits, creditPrefix) {
-        const hasDecimal = credits % 1 !== 0;
-        const formattedCredits = hasDecimal
-            ? parseFloat(credits.toFixed(6)).toString()
-            : credits.toFixed();
-        if (creditPrefix) {
-            return [chalk.grey("cost:"), chalk.blue(`${creditPrefix}${formattedCredits}`)];
-        }
-        return [chalk.blue(formattedCredits), chalk.grey("AIGNE Hub credits")];
-    }
-    formatTokenUsage(usage, extra) {
-        const items = [
-            [chalk.yellow(usage.inputTokens), chalk.grey("input tokens")],
-            usage.cacheReadInputTokens
-                ? [chalk.green(usage.cacheReadInputTokens), chalk.grey("cached")]
-                : undefined,
-            usage.cacheCreationInputTokens
-                ? [chalk.yellow(usage.cacheCreationInputTokens), chalk.grey("cache write")]
-                : undefined,
-            [chalk.cyan(usage.outputTokens), chalk.grey("output tokens")],
-            usage.aigneHubCredits
-                ? this.formatAigneHubCredits(usage.aigneHubCredits, usage.creditPrefix)
-                : undefined,
-            usage.agentCalls ? [chalk.magenta(usage.agentCalls), chalk.grey("agent calls")] : undefined,
-        ];
-        const content = items.filter((i) => !!i).map((i) => i.join(" "));
-        if (extra) {
-            content.unshift(...Object.entries(extra)
-                .filter(([k, v]) => k && v)
-                .map(([k, v]) => `${chalk.grey(k)}: ${v}`));
-        }
-        return `${chalk.grey("(")}${content.join(chalk.green(", "))}${chalk.grey(")")}`;
-    }
-    formatTimeUsage(startTime, endTime) {
-        const duration = endTime - startTime;
-        return chalk.grey(`[${parseDuration(duration)}]`);
-    }
-    async formatTaskTitle(agent, { task, usage, time, input }) {
-        let title = agent.name;
-        if (agent.taskTitle) {
-            title += ` ${chalk.cyan(await agent.renderTaskTitle(input))}`;
-        }
-        if (usage && task?.usage)
-            title += ` ${this.formatTokenUsage(task.usage, task.extraTitleMetadata)}`;
-        if (time && task?.startTime && task.endTime)
-            title += ` ${this.formatTimeUsage(task.startTime, task.endTime)}`;
-        return title;
-    }
-    marked = new Marked().use({
-        // marked-terminal does not support code block meta, so we need to strip it
-        walkTokens: (token) => {
-            if (token.type === "code") {
-                if (typeof token.lang === "string") {
-                    token.lang = token.lang.trim().split(/\s+/)[0];
-                }
-            }
-        },
-    }, markedTerminal({ forceHyperLink: false }, {
-        theme: {
-            string: chalk.green,
-        },
-    }));
-    get outputKey() {
-        return this.options.outputKey || DEFAULT_OUTPUT_KEY;
-    }
-    get outputFileKey() {
-        return this.options.outputFileKey || DEFAULT_OUTPUT_FILE_KEY;
-    }
-    formatRequest(agent, _context, m = {}, { running = false } = {}) {
-        const prefix = `${chalk.grey(figures.pointer)} 💬 `;
-        const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
-        const msg = inputKey ? m[inputKey] : undefined;
-        const message = inputKey ? omit(m, inputKey) : m;
-        const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
-        const json = Object.keys(message).length > 0
-            ? inspect(message, { colors: true, ...(running ? this.runningInspectOptions : undefined) })
-            : undefined;
-        const r = [text, json].filter(Boolean).join(EOL).trim();
-        if (!r)
-            return undefined;
-        return `${prefix}${r}`;
-    }
-    formatResult(agent, context, m = {}, { running = false, renderImage = false } = {}) {
-        const { isTTY } = process.stdout;
-        const outputKey = this.outputKey || (agent instanceof AIAgent ? agent.outputKey : undefined);
-        const prefix = `${chalk.grey(figures.tick)} 🤖 ${this.formatTokenUsage(context.usage)}`;
-        const msg = outputKey ? m[outputKey] : undefined;
-        const message = outputKey ? omit(m, outputKey, this.outputFileKey) : m;
-        const text = msg && typeof msg === "string"
-            ? isTTY
-                ? this.marked.parse(msg, { async: false }).trim()
-                : msg
-            : undefined;
-        const json = Object.keys(message).length > 0
-            ? inspect(message, { colors: isTTY, ...(running ? this.runningInspectOptions : undefined) })
-            : undefined;
-        if (renderImage) {
-            return this.formatResultData(m).then((images) => {
-                return [prefix, text, images, json].filter(Boolean).join(EOL.repeat(2));
-            });
-        }
-        return [prefix, text, json].filter(Boolean).join(EOL.repeat(2));
-    }
-    async formatResultData(output) {
-        const files = output[this.outputFileKey];
-        if (!Array.isArray(files))
-            return;
-        const options = {
-            height: 30,
-        };
-        return (await Promise.all(files.map(async (item) => {
-            const image = item.type === "local"
-                ? await terminalImage.file(item.path, options)
-                : item.type === "file"
-                    ? await terminalImage.buffer(Buffer.from(item.data, "base64"), options)
-                    : undefined;
-            const link = item.type === "local"
-                ? withProtocol(item.path, "file://")
-                : item.type === "url"
-                    ? item.url
-                    : undefined;
-            const text = [
-                link ? chalk.cyan(terminalLink(link, link)) : undefined,
-                item.filename,
-                item.mimeType ? chalk.gray(item.mimeType) : undefined,
-            ]
-                .filter(Boolean)
-                .join(" ");
-            return [image, text].filter(Boolean).join(EOL);
-        })))
-            .filter(Boolean)
-            .join(EOL);
-    }
-    runningInspectOptions = {
-        maxArrayLength: 3,
-        maxStringLength: 200,
-    };
-}

package/dist/type.d.ts

@@ -1,5 +0,0 @@
-import type { AgentInvokeOptions as _AgentInvokeOptions, UserContext } from "@aigne/core";
-import type * as prompts from "@inquirer/prompts";
-export interface AgentInvokeOptions<U extends UserContext = UserContext> extends _AgentInvokeOptions<U> {
-    prompts: typeof prompts;
-}

package/dist/type.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,19 +0,0 @@
-import { render } from "ink";
-export declare function terminalInput({ render: r, ...options }?: {
-    message?: string;
-    default?: string;
-    inline?: boolean;
-    required?: boolean;
-    validate?: (input: string) => string | boolean | Promise<string | boolean>;
-    render?: typeof render;
-    clear?: boolean;
-}): Promise<string>;
-export declare function TerminalInput(props: {
-    message?: string;
-    default?: string;
-    inline?: boolean;
-    required?: boolean;
-    validate?: (input: string) => string | boolean | Promise<string | boolean>;
-    onSubmit: (input: string) => void;
-    onError: (error: Error) => void;
-}): import("react/jsx-runtime").JSX.Element;