@aigne/cli 1.60.0-beta → 1.74.0-beta

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

@@ -1,37 +0,0 @@
-/**
- * Calculates the maximum width of a multi-line ASCII art string.
- * @param asciiArt The ASCII art string.
- * @returns The length of the longest line in the ASCII art.
- */
-export declare const getAsciiArtWidth: (asciiArt: string) => number;
-export declare function toCodePoints(str: string): string[];
-export declare function cpLen(str: string): number;
-export declare function cpSlice(str: string, start: number, end?: number): string;
-/**
- * Strip characters that can break terminal rendering.
- *
- * Uses Node.js built-in stripVTControlCharacters to handle VT sequences,
- * then filters remaining control characters that can disrupt display.
- *
- * Characters stripped:
- * - ANSI escape sequences (via strip-ansi)
- * - VT control sequences (via Node.js util.stripVTControlCharacters)
- * - C0 control chars (0x00-0x1F) except CR/LF which are handled elsewhere
- * - C1 control chars (0x80-0x9F) that can cause display issues
- *
- * Characters preserved:
- * - All printable Unicode including emojis
- * - DEL (0x7F) - handled functionally by applyOperations, not a display issue
- * - CR/LF (0x0D/0x0A) - needed for line breaks
- */
-export declare function stripUnsafeCharacters(str: string): string;
-/**
- * Cached version of stringWidth function for better performance
- * Follows Ink's approach with unlimited cache (no eviction)
- */
-export declare const getCachedStringWidth: (str: string) => number;
-/**
- * Clear the string width cache
- */
-export declare const clearStringWidthCache: () => void;
-export declare function escapeAnsiCtrlCodes<T>(obj: T): T;

package/dist/ui/utils/text-utils.js

@@ -1,185 +0,0 @@
-// biome-ignore-all lint/style/noNonNullAssertion: code is from gemini-cli
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { stripVTControlCharacters } from "node:util";
-import ansiRegex from "ansi-regex";
-import stringWidth from "string-width";
-import stripAnsi from "strip-ansi";
-/**
- * Calculates the maximum width of a multi-line ASCII art string.
- * @param asciiArt The ASCII art string.
- * @returns The length of the longest line in the ASCII art.
- */
-export const getAsciiArtWidth = (asciiArt) => {
-    if (!asciiArt) {
-        return 0;
-    }
-    const lines = asciiArt.split("\n");
-    return Math.max(...lines.map((line) => line.length));
-};
-/*
- * -------------------------------------------------------------------------
- *  Unicode‑aware helpers (work at the code‑point level rather than UTF‑16
- *  code units so that surrogate‑pair emoji count as one "column".)
- * ---------------------------------------------------------------------- */
-// Cache for code points to reduce GC pressure
-const codePointsCache = new Map();
-const MAX_STRING_LENGTH_TO_CACHE = 1000;
-export function toCodePoints(str) {
-    // ASCII fast path - check if all chars are ASCII (0-127)
-    let isAscii = true;
-    for (let i = 0; i < str.length; i++) {
-        if (str.charCodeAt(i) > 127) {
-            isAscii = false;
-            break;
-        }
-    }
-    if (isAscii) {
-        return str.split("");
-    }
-    // Cache short strings
-    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
-        const cached = codePointsCache.get(str);
-        if (cached) {
-            return cached;
-        }
-    }
-    const result = Array.from(str);
-    // Cache result (unlimited like Ink)
-    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
-        codePointsCache.set(str, result);
-    }
-    return result;
-}
-export function cpLen(str) {
-    return toCodePoints(str).length;
-}
-export function cpSlice(str, start, end) {
-    // Slice by code‑point indices and re‑join.
-    const arr = toCodePoints(str).slice(start, end);
-    return arr.join("");
-}
-/**
- * Strip characters that can break terminal rendering.
- *
- * Uses Node.js built-in stripVTControlCharacters to handle VT sequences,
- * then filters remaining control characters that can disrupt display.
- *
- * Characters stripped:
- * - ANSI escape sequences (via strip-ansi)
- * - VT control sequences (via Node.js util.stripVTControlCharacters)
- * - C0 control chars (0x00-0x1F) except CR/LF which are handled elsewhere
- * - C1 control chars (0x80-0x9F) that can cause display issues
- *
- * Characters preserved:
- * - All printable Unicode including emojis
- * - DEL (0x7F) - handled functionally by applyOperations, not a display issue
- * - CR/LF (0x0D/0x0A) - needed for line breaks
- */
-export function stripUnsafeCharacters(str) {
-    const strippedAnsi = stripAnsi(str);
-    const strippedVT = stripVTControlCharacters(strippedAnsi);
-    return toCodePoints(strippedVT)
-        .filter((char) => {
-        const code = char.codePointAt(0);
-        if (code === undefined)
-            return false;
-        // Preserve CR/LF for line handling
-        if (code === 0x0a || code === 0x0d)
-            return true;
-        // Remove C0 control chars (except CR/LF) that can break display
-        // Examples: BELL(0x07) makes noise, BS(0x08) moves cursor, VT(0x0B), FF(0x0C)
-        if (code >= 0x00 && code <= 0x1f)
-            return false;
-        // Remove C1 control chars (0x80-0x9f) - legacy 8-bit control codes
-        if (code >= 0x80 && code <= 0x9f)
-            return false;
-        // Preserve DEL (0x7f) - it's handled functionally by applyOperations as backspace
-        // and doesn't cause rendering issues when displayed
-        // Preserve all other characters including Unicode/emojis
-        return true;
-    })
-        .join("");
-}
-// String width caching for performance optimization
-const stringWidthCache = new Map();
-/**
- * Cached version of stringWidth function for better performance
- * Follows Ink's approach with unlimited cache (no eviction)
- */
-export const getCachedStringWidth = (str) => {
-    // ASCII printable chars have width 1
-    if (/^[\x20-\x7E]*$/.test(str)) {
-        return str.length;
-    }
-    if (stringWidthCache.has(str)) {
-        return stringWidthCache.get(str);
-    }
-    const width = stringWidth(str);
-    stringWidthCache.set(str, width);
-    return width;
-};
-/**
- * Clear the string width cache
- */
-export const clearStringWidthCache = () => {
-    stringWidthCache.clear();
-};
-const regex = ansiRegex();
-/* Recursively traverses a JSON-like structure (objects, arrays, primitives)
- * and escapes all ANSI control characters found in any string values.
- *
- * This function is designed to be robust, handling deeply nested objects and
- * arrays. It applies a regex-based replacement to all string values to
- * safely escape control characters.
- *
- * To optimize performance, this function uses a "copy-on-write" strategy.
- * It avoids allocating new objects or arrays if no nested string values
- * required escaping, returning the original object reference in such cases.
- *
- * @param obj The JSON-like value (object, array, string, etc.) to traverse.
- * @returns A new value with all nested string fields escaped, or the
- * original `obj` reference if no changes were necessary.
- */
-export function escapeAnsiCtrlCodes(obj) {
-    if (typeof obj === "string") {
-        if (obj.search(regex) === -1) {
-            return obj; // No changes return original string
-        }
-        regex.lastIndex = 0; // needed for global regex
-        return obj.replace(regex, (match) => JSON.stringify(match).slice(1, -1));
-    }
-    if (obj === null || typeof obj !== "object") {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        let newArr = null;
-        for (let i = 0; i < obj.length; i++) {
-            const value = obj[i];
-            const escapedValue = escapeAnsiCtrlCodes(value);
-            if (escapedValue !== value) {
-                if (newArr === null) {
-                    newArr = [...obj];
-                }
-                newArr[i] = escapedValue;
-            }
-        }
-        return (newArr !== null ? newArr : obj);
-    }
-    let newObj = null;
-    const keys = Object.keys(obj);
-    for (const key of keys) {
-        const value = obj[key];
-        const escapedValue = escapeAnsiCtrlCodes(value);
-        if (escapedValue !== value) {
-            if (newObj === null) {
-                newObj = { ...obj };
-            }
-            newObj[key] = escapedValue;
-        }
-    }
-    return newObj !== null ? newObj : obj;
-}

package/dist/utils/agent-v1.d.ts

@@ -1,134 +0,0 @@
-export declare function isV1Package(src: string): Promise<boolean>;
-export declare function toAIGNEPackage(src: string, dst: string): Promise<void>;
-export type Parameter = {
-    id: string;
-    key?: string;
-    hidden?: boolean;
-    required?: boolean;
-    placeholder?: string;
-} & ({
-    type?: "string" | "number" | "boolean" | "language";
-} | {
-    type?: "select";
-    options?: {
-        id: string;
-        label?: string;
-        value?: string;
-    }[];
-});
-export interface VariableTypeBase {
-    id: string;
-    name?: string;
-    description?: string;
-    required?: boolean;
-    hidden?: boolean;
-}
-export type OutputVariable = VariableTypeBase & ({
-    type?: undefined;
-} | {
-    type: "string";
-    defaultValue?: string;
-} | {
-    type: "number";
-    defaultValue?: number;
-} | {
-    type: "boolean";
-    defaultValue?: boolean;
-} | {
-    type: "object";
-    properties?: OutputVariable[];
-} | {
-    type: "array";
-    element?: OutputVariable;
-});
-export type AgentV1 = {
-    id: string;
-    name?: string;
-    description?: string;
-    parameters?: Parameter[];
-    outputVariables?: OutputVariable[];
-} & ({
-    type: "prompt";
-    prompts?: Prompt[];
-    temperature?: number;
-    topP?: number;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-    maxTokens?: number;
-    model?: string;
-} | {
-    type: "router";
-    defaultToolId?: string;
-    prompt?: string;
-    decisionType?: "ai";
-    routes?: Tool[];
-    temperature?: number;
-    topP?: number;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-    maxTokens?: number;
-    model?: string;
-} | {
-    type: "image";
-    prompt?: string;
-    model?: string;
-    n?: number;
-    quality?: string;
-    style?: string;
-    size?: string;
-    modelSettings?: {
-        [key: string]: unknown;
-    };
-} | {
-    type: "api";
-    requestParameters?: {
-        id: string;
-        key?: string;
-        value?: string;
-    }[];
-    requestMethod?: string;
-    requestUrl?: string;
-    requestHeaders: {
-        id: string;
-        key?: string;
-        value?: string;
-    }[];
-} | {
-    type: "function";
-    code?: string;
-} | {
-    type: "callAgent";
-    agents?: Tool[];
-});
-export interface ProjectDefinitionV1 {
-    project: {
-        name?: string;
-        description?: string;
-    };
-    agents: AgentV1[];
-}
-export type Prompt = {
-    type: "message";
-    data: PromptMessage;
-    visibility?: "hidden";
-} | {
-    type: "executeBlock";
-    visibility?: "hidden";
-};
-export type PromptMessage = {
-    id: string;
-    role: Role;
-    content?: string;
-    name?: string;
-};
-export type Role = "system" | "user" | "assistant";
-export type Tool = {
-    blockletDid?: string;
-    projectId?: string;
-    id: string;
-    from?: "assistant" | "blockletAPI" | "knowledge";
-    parameters?: {
-        [key: string]: unknown;
-    };
-    functionName?: string;
-};

package/dist/utils/agent-v1.js

@@ -1,213 +0,0 @@
-import { readFile, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { glob } from "glob";
-import { parse, stringify } from "yaml";
-export async function isV1Package(src) {
-    return stat(join(src, "project.yaml"))
-        .then((res) => res.isFile())
-        .catch((error) => {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    });
-}
-export async function toAIGNEPackage(src, dst) {
-    const definition = await loadAgentV1Package(src);
-    const aigne = {
-        chat_model: {
-            name: "gpt-4o-mini", // TODO: get from config
-        },
-        agents: [],
-        cli: {
-            agents: [],
-        },
-    };
-    for (const agent of definition.agents) {
-        const { content } = await assistantToAIGNEV2(agent, definition);
-        const filename = getAgentFilename(agent);
-        await writeFile(join(dst, filename), content);
-        aigne.agents.push(filename);
-        aigne.cli.agents.push(filename);
-    }
-    await writeFile(join(dst, "aigne.yaml"), stringify(aigne));
-}
-async function loadAgentV1Package(path) {
-    const agentFilePaths = await glob("prompts/**/*.yaml", {
-        cwd: path,
-    });
-    const project = parse(await readFile(join(path, "project.yaml"), "utf8"));
-    const definition = {
-        project,
-        agents: [],
-    };
-    for (const filename of agentFilePaths) {
-        const agent = parse(await readFile(join(path, filename), "utf8"));
-        definition.agents.push(agent);
-    }
-    return definition;
-}
-function assistantToAIGNEV2(agent, project) {
-    const converter = AGENT_MAP[agent.type];
-    if (!converter)
-        throw new Error(`Unsupported agent type: ${agent.type}`);
-    return converter(agent, project);
-}
-const AGENT_MAP = {
-    prompt: (agent) => {
-        if (agent.type !== "prompt")
-            throw new Error(`Expected agent type 'prompt', but got '${agent.type}'`);
-        const obj = {
-            name: agent.name || agent.id,
-            description: agent.description,
-            input_schema: convertInputSchema(agent),
-            output_schema: convertOutputSchema(agent),
-            instructions: agent.prompts
-                ?.filter((i) => i.visibility !== "hidden" && i.type === "message")
-                .map((i) => i.data.content) // TODO: should support multiple messages with different roles
-                .join("\n"),
-        };
-        return {
-            content: stringify(obj),
-        };
-    },
-    function: async (agent) => {
-        if (agent.type !== "function")
-            throw new Error(`Expected agent type 'function', but got '${agent.type}'`);
-        const inputNames = agent.parameters?.map((i) => i.key).filter(Boolean) ?? [];
-        return {
-            content: await formatCode(`\
-export default async function agent({${inputNames.join(", ")}}) {
-${agent.code}
-}
-
-agent.agent_name = ${JSON.stringify(agent.name || agent.id)};
-
-agent.description = ${agent.description ? JSON.stringify(agent.description) : "undefined"};
-
-agent.input_schema = ${JSON.stringify(convertInputSchema(agent))};
-
-agent.output_schema = ${JSON.stringify(convertOutputSchema(agent))};
-`),
-        };
-    },
-    router: (agent, project) => {
-        if (agent.type !== "router")
-            throw new Error(`Expected agent type 'router', but got '${agent.type}'`);
-        return {
-            content: stringify({
-                name: agent.name || agent.id,
-                description: agent.description,
-                instructions: agent.prompt,
-                input_schema: convertInputSchema(agent),
-                output_schema: convertOutputSchema(agent),
-                skills: agent.routes?.map((i) => {
-                    const tool = project.agents.find((j) => j.id === i.id);
-                    if (!tool)
-                        throw new Error(`Tool ${i.id} not found in project definition`);
-                    return getAgentFilename(tool);
-                }),
-                tool_choice: "router",
-            }),
-        };
-    },
-};
-function getAgentFilename(agent) {
-    switch (agent.type) {
-        case "prompt":
-        case "router":
-            return `${agent.name || agent.id}.yaml`;
-        case "function":
-            return `${agent.name || agent.id}.js`;
-        default:
-            throw new Error(`Unsupported agent type: ${agent.type}`);
-    }
-}
-async function formatCode(code) {
-    const [prettier, typescriptPlugin, estreePlugin] = await Promise.all([
-        import("prettier"),
-        import("prettier/plugins/typescript"),
-        import("prettier/plugins/estree"),
-    ]);
-    return prettier.format(code, {
-        parser: "typescript",
-        plugins: [typescriptPlugin, estreePlugin.default],
-        printWidth: 120,
-        useTabs: false,
-        tabWidth: 2,
-        trailingComma: "es5",
-        bracketSameLine: true,
-        semi: true,
-        singleQuote: true,
-    });
-}
-function convertInputSchema(agent) {
-    const parameters = (agent.parameters ?? []).filter((i) => !!i.key && !i.hidden);
-    const properties = parameters.map((i) => [i.key, parameterToJsonSchema(i)]);
-    return {
-        type: "object",
-        properties: Object.fromEntries(properties),
-        required: parameters.filter((i) => i.required).map((i) => i.key),
-    };
-}
-function parameterToJsonSchema(parameter) {
-    switch (parameter.type) {
-        case undefined:
-        case "string":
-        case "language":
-            return {
-                type: "string",
-                description: parameter.placeholder,
-            };
-        case "select":
-            return {
-                type: "string",
-                enum: parameter.options?.map((i) => i.value),
-                description: parameter.placeholder,
-            };
-        case "number":
-        case "boolean":
-            return {
-                type: parameter.type,
-                description: parameter.placeholder,
-            };
-        default:
-            throw new Error(`Unsupported parameter type: ${parameter.type}`);
-    }
-}
-function convertOutputSchema(agent) {
-    const outputs = agent.outputVariables?.filter((i) => !!i.name && !i.hidden) ?? [];
-    const properties = outputs
-        .map((i) => [i.name, variableTypeToJsonSchema(i)])
-        .filter((i) => !!i[1]);
-    return {
-        type: "object",
-        properties: Object.fromEntries(properties),
-        required: outputs.filter((i) => i.required).map((i) => i.name),
-    };
-}
-function variableTypeToJsonSchema(output) {
-    if (output.type === "object") {
-        if (!output.properties)
-            return undefined;
-        return {
-            type: "object",
-            properties: Object.fromEntries(output.properties
-                .filter((i) => !!i.name)
-                .map((i) => [i.name, variableTypeToJsonSchema(i)])
-                .filter((i) => !!i[1])),
-            required: output.properties.filter((i) => i.required && i.name).map((i) => i.name),
-        };
-    }
-    if (output.type === "array") {
-        if (!output.element)
-            return undefined;
-        return {
-            type: "array",
-            items: variableTypeToJsonSchema(output.element),
-        };
-    }
-    return {
-        type: output.type || "string",
-        description: output.description,
-    };
-}

package/dist/utils/aigne-hub/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
-export declare const ACCESS_KEY_SESSION_API = "/api/access-key/session";
-export declare const AIGNE_HUB_PROVIDER = "aignehub";
-export declare const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = "aignehub:openai/gpt-5-mini";
-export declare const isTest: string | boolean;
-export declare const AIGNE_ENV_FILE: string;

package/dist/utils/aigne-hub/constants.js

@@ -1,12 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-const ACCESS_KEY_PREFIX = "/api/access-key";
-export const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
-export const ACCESS_KEY_SESSION_API = `${ACCESS_KEY_PREFIX}/session`;
-const DEFAULT_AIGNE_HUB_MODEL = "openai/gpt-5-mini";
-export const AIGNE_HUB_PROVIDER = "aignehub";
-export const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = `${AIGNE_HUB_PROVIDER}:${DEFAULT_AIGNE_HUB_MODEL}`;
-export const isTest = process.env.CI || process.env.NODE_ENV === "test";
-const TEST_AIGNE_ENV_FILE = join(homedir(), ".aigne", "test-aigne-hub-connected.yaml");
-const PROD_AIGNE_ENV_FILE = join(homedir(), ".aigne", "aigne-hub-connected.yaml");
-export const AIGNE_ENV_FILE = isTest ? TEST_AIGNE_ENV_FILE : PROD_AIGNE_ENV_FILE;

package/dist/utils/aigne-hub/credential.d.ts

@@ -1,20 +0,0 @@
-import type { CreateConnectOptions, FetchResult, LoadCredentialOptions } from "./type.js";
-export declare const fetchConfigs: ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }: {
-    connectUrl: string;
-    sessionId: string;
-    fetchInterval: number;
-    fetchTimeout: number;
-}) => Promise<any>;
-export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, appName, appLogo, }: CreateConnectOptions): Promise<FetchResult>;
-export declare function connectToAIGNEHub(url: string): Promise<{
-    apiKey: string;
-    url: string;
-}>;
-export declare const checkConnectionStatus: (host: string) => Promise<{
-    apiKey: any;
-    url: any;
-}>;
-export declare function loadAIGNEHubCredential(options?: LoadCredentialOptions): Promise<{
-    apiKey?: string;
-    url?: string;
-} | undefined>;