@qlingzzy/qling 1.0.0

package/dist/tools/url-fetch.js

@@ -0,0 +1,208 @@
+import { toolError, toolSuccess } from "./error-utils.js";
+import { appendGuardAudit, checkUrlFetchPolicy, redactText } from "../guard.js";
+import { guardConfigFromEnv } from "../config.js";
+const MAX_BODY_CHARS = 200_000;
+export const urlFetchTool = {
+    name: "url_fetch",
+    description: "Fetch HTTP/HTTPS resources with Guard policy (allowlist, private IP block, redirect policy, redaction).",
+    longDescription: `结构化网络请求工具，受 Guard 策略约束。
+
+**主要能力**:
+- 仅允许命中的 URL 前缀
+- 可拦截私网/本地 IP
+- 可禁用自动重定向
+- 输出内容自动脱敏
+
+**注意**:
+- 默认仅允许 https:// 前缀
+- 非 2xx 响应会返回带错误码的失败结果`,
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "Target URL (http/https)" },
+            method: { type: "string", description: "HTTP method (GET/POST/PUT/PATCH/DELETE)" },
+            headers: { type: "object", description: "Request headers" },
+            body: { type: "string", description: "Request body text" },
+            timeout_seconds: { type: "number", description: "Request timeout in seconds (default: 30)" },
+            follow_redirects: {
+                type: "boolean",
+                description: "Override redirect policy (when guard allows)",
+            },
+        },
+        required: ["url"],
+    },
+    paramSchema: {
+        url: {
+            type: "string",
+            description: "目标 URL（建议 https://）",
+            minLength: 8,
+        },
+        method: {
+            type: "string",
+            description: "HTTP 方法",
+            enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+            default: "GET",
+        },
+        headers: {
+            type: "object",
+            description: "请求头对象",
+        },
+        body: {
+            type: "string",
+            description: "请求体文本",
+        },
+        timeout_seconds: {
+            type: "number",
+            description: "超时秒数，默认 30，最大 120",
+            minimum: 1,
+            maximum: 120,
+            default: 30,
+        },
+        follow_redirects: {
+            type: "boolean",
+            description: "是否允许跟随重定向（若 guard 禁止则不可覆盖）",
+            default: false,
+        },
+    },
+    examples: [
+        'url_fetch url="https://example.com"',
+        'url_fetch url="https://api.example.com/v1" method="POST" body="{\\"x\\":1}"',
+    ],
+    scenes: ["web", "data"],
+    seeAlso: ["search", "read"],
+    priority: 6,
+    readOnly: true,
+    destructive: false,
+    concurrencySafe: true,
+    effortHint: "low",
+};
+export async function runUrlFetch(args) {
+    const rawUrl = String(args.url ?? "").trim();
+    if (!rawUrl) {
+        return toolError("URL_FETCH_MISSING_URL", "url is required");
+    }
+    let target;
+    try {
+        target = new URL(rawUrl);
+    }
+    catch {
+        return toolError("URL_FETCH_INVALID_URL", `invalid url: ${rawUrl}`);
+    }
+    if (target.protocol !== "https:" && target.protocol !== "http:") {
+        return toolError("URL_FETCH_UNSUPPORTED_PROTOCOL", `unsupported protocol: ${target.protocol}`);
+    }
+    const guard = guardConfigFromEnv();
+    const decision = await checkUrlFetchPolicy(target, guard);
+    if (!decision.allowed) {
+        await appendGuardAudit(guard, {
+            tool: "url_fetch",
+            action: "deny",
+            category: decision.category,
+            target: target.toString(),
+            reason: decision.reason,
+        });
+        return toolError("URL_FETCH_GUARD_BLOCKED", decision.reason ?? "guard denied url_fetch");
+    }
+    const method = String(args.method ?? "GET").toUpperCase();
+    const supportedMethods = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+    if (!supportedMethods.has(method)) {
+        return toolError("URL_FETCH_UNSUPPORTED_METHOD", `unsupported method: ${method}`);
+    }
+    const timeoutSeconds = Math.max(1, Math.min(120, Number(args.timeout_seconds ?? 30)));
+    const followRedirects = args.follow_redirects !== undefined
+        ? Boolean(args.follow_redirects) && guard.network.url_fetch.follow_redirects
+        : guard.network.url_fetch.follow_redirects;
+    const headers = sanitizeHeaders(args.headers ?? {});
+    const body = args.body !== undefined ? String(args.body) : undefined;
+    let response;
+    try {
+        response = await fetch(target.toString(), {
+            method,
+            headers,
+            body: body ?? undefined,
+            redirect: followRedirects ? "follow" : "manual",
+            signal: AbortSignal.timeout(timeoutSeconds * 1000),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await appendGuardAudit(guard, {
+            tool: "url_fetch",
+            action: "allow",
+            category: "network",
+            target: target.toString(),
+            reason: message,
+        });
+        return toolError("URL_FETCH_REQUEST_FAILED", message);
+    }
+    if (!followRedirects && isRedirect(response.status)) {
+        await appendGuardAudit(guard, {
+            tool: "url_fetch",
+            action: "deny",
+            category: "network",
+            target: target.toString(),
+            status: response.status,
+            reason: "redirect blocked by policy",
+        });
+        return toolError("URL_FETCH_REDIRECT_BLOCKED", `redirect blocked by policy (status=${response.status}, location=${response.headers.get("location") ?? ""})`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    let text = "";
+    try {
+        if (/^text\/|json|xml|javascript|yaml|html/i.test(contentType)) {
+            text = await response.text();
+        }
+        else {
+            const ab = await response.arrayBuffer();
+            text = `[binary response omitted] bytes=${ab.byteLength} content-type=${contentType}`;
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return toolError("URL_FETCH_READ_FAILED", message);
+    }
+    if (text.length > MAX_BODY_CHARS) {
+        text = text.slice(0, MAX_BODY_CHARS) + `\n... [truncated at ${MAX_BODY_CHARS} chars]`;
+    }
+    text = redactText(text, guard);
+    if (!response.ok) {
+        await appendGuardAudit(guard, {
+            tool: "url_fetch",
+            action: "allow",
+            category: "network",
+            target: target.toString(),
+            status: response.status,
+            reason: `http status ${response.status}`,
+        });
+        return toolError("URL_FETCH_HTTP_ERROR", `status=${response.status} ${response.statusText}\n${text}`);
+    }
+    await appendGuardAudit(guard, {
+        tool: "url_fetch",
+        action: "allow",
+        category: "network",
+        target: target.toString(),
+        status: response.status,
+    });
+    return toolSuccess([
+        `status=${response.status}`,
+        `content-type=${contentType || "unknown"}`,
+        "",
+        text,
+    ].join("\n"));
+}
+function sanitizeHeaders(input) {
+    const forbidden = new Set(["authorization", "proxy-authorization", "cookie", "set-cookie"]);
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+        const key = k.trim();
+        if (!key)
+            continue;
+        if (forbidden.has(key.toLowerCase()))
+            continue;
+        out[key] = String(v);
+    }
+    return out;
+}
+function isRedirect(status) {
+    return status >= 300 && status < 400;
+}

package/dist/tools/vision-analyze.d.ts

@@ -0,0 +1,9 @@
+import { ToolDefinition, ToolResult } from "../types.js";
+export declare const visionAnalyzeTool: ToolDefinition;
+export declare function runVisionAnalyze(args: {
+    image_path?: string;
+    image_url?: string;
+    prompt: string;
+    detail?: "low" | "high" | "auto";
+}): Promise<ToolResult>;
+//# sourceMappingURL=vision-analyze.d.ts.map

package/dist/tools/vision-analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision-analyze.d.ts","sourceRoot":"","sources":["../../src/tools/vision-analyze.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKzD,eAAO,MAAM,iBAAiB,EAAE,cAgE/B,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,UAAU,CAAC,CAkHtB"}

package/dist/tools/vision-analyze.js

@@ -0,0 +1,179 @@
+// ============================================================
+// 轻灵 - vision_analyze 工具 (v0.3)
+// 多模态视觉解析工具，支持分析图片、截图、网页 UI
+// ============================================================
+import axios from "axios";
+import * as fs from "fs/promises";
+import * as path from "path";
+export const visionAnalyzeTool = {
+    name: "vision_analyze",
+    description: "Analyze images, screenshots, or UI mockups using visual LLMs. Preserves rich artistic and structural details.",
+    longDescription: `多模态视觉解析工具。
+
+**重要指引**:
+- 当调用此工具后，Agent 应当在回答中**完整保留**模型返回的视觉意象、空间布局、风格描述和氛围分析。
+- 除非用户明确要求提取特定文字，否则不要将丰富的叙述性描述仅压缩为表格。
+- 艺术感和细节描述是此工具的核心产出。`,
+    parameters: {
+        type: "object",
+        properties: {
+            image_path: {
+                type: "string",
+                description: "Local path to the image file or base64 data",
+            },
+            image_url: {
+                type: "string",
+                description: "Public URL of the image",
+            },
+            prompt: {
+                type: "string",
+                description: "Specific instructions or questions for the visual analysis",
+            },
+            detail: {
+                type: "string",
+                enum: ["low", "high", "auto"],
+                description: "Level of detail for analysis",
+                default: "auto",
+            }
+        },
+        required: ["prompt"],
+    },
+    paramSchema: {
+        image_path: {
+            type: "string",
+            description: "本地图片路径。支持含空格路径。",
+        },
+        image_url: {
+            type: "string",
+            description: "远程图片 URL。确保 Agent 可出网。",
+        },
+        prompt: {
+            type: "string",
+            description: "具体的分析指令。例如：'分析这个登录页面的按钮是否居中'。",
+            minLength: 5,
+        },
+        detail: {
+            type: "string",
+            description: "解析精细度。",
+            enum: ["low", "high", "auto"],
+            default: "auto",
+        }
+    },
+    examples: [
+        'vision_analyze image_path="screenshots/login.png" prompt="分析页面布局错位原因"',
+        'vision_analyze image_url="https://example.com/chart.jpg" prompt="提取 2024 年 Q3 的收入数据"',
+    ],
+    scenes: ["visual", "debug", "frontend"],
+    priority: 7,
+    readOnly: true,
+    destructive: false,
+    concurrencySafe: true,
+    effortHint: "medium",
+};
+export async function runVisionAnalyze(args) {
+    // 1. 优先级：Vision 专用变量 > LLM 通用变量 > 默认值
+    const provider = process.env.QLING_VISION_PROVIDER || process.env.QLING_LLM_PROVIDER || "openai";
+    const model = process.env.QLING_VISION_MODEL || process.env.QLING_LLM_MODEL || "gpt-4o";
+    const apiKey = process.env.QLING_LLM_API_KEY || process.env.OPENAI_API_KEY || process.env.DEEPSEEK_API_KEY || "";
+    // 2. 解析 Endpoint
+    let endpoint = process.env.QLING_VISION_ENDPOINT || process.env.QLING_LLM_ENDPOINT;
+    if (!endpoint) {
+        endpoint = provider === "openai"
+            ? "https://api.openai.com/v1/chat/completions"
+            : provider === "deepseek"
+                ? "https://api.deepseek.com/chat/completions"
+                : "http://localhost:11434/v1/chat/completions";
+    }
+    else {
+        // 确保 endpoint 包含 chat/completions 路径
+        if (!endpoint.endsWith("/chat/completions")) {
+            endpoint = endpoint.replace(/\/$/, "") + "/chat/completions";
+        }
+    }
+    // 只有非本地提供商才强制要求 API Key
+    if (!apiKey && provider !== "local") {
+        return {
+            tool_call_id: "",
+            output: `Error: Missing API Key for vision analysis (${provider}). Please check your configuration.`,
+            is_error: true,
+        };
+    }
+    try {
+        let content = [{ type: "text", text: args.prompt }];
+        if (args.image_path) {
+            // 增强：处理含空格的路径并规范化
+            const rawPath = args.image_path.replace(/["']/g, "").trim();
+            const fullPath = path.isAbsolute(rawPath)
+                ? rawPath
+                : path.resolve(process.env.QLING_WORKSPACE_DIR || process.cwd(), rawPath);
+            try {
+                const buffer = await fs.readFile(fullPath);
+                const base64 = buffer.toString("base64");
+                const ext = path.extname(fullPath).toLowerCase().slice(1) || "png";
+                content.push({
+                    type: "image_url",
+                    image_url: { url: `data:image/${ext};base64,${base64}`, detail: args.detail || "auto" }
+                });
+            }
+            catch (e) {
+                return {
+                    tool_call_id: "",
+                    output: `Error: Cannot read image at "${fullPath}". Please check if the file exists and the path is correct.`,
+                    is_error: true,
+                };
+            }
+        }
+        else if (args.image_url) {
+            content.push({
+                type: "image_url",
+                image_url: { url: args.image_url, detail: args.detail || "auto" }
+            });
+        }
+        else {
+            return {
+                tool_call_id: "",
+                output: "Error: Either image_path or image_url must be provided.",
+                is_error: true,
+            };
+        }
+        const resp = await axios.post(endpoint, {
+            model,
+            messages: [{ role: "user", content }],
+            max_tokens: 1000,
+        }, {
+            headers: {
+                ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                "Content-Type": "application/json",
+            },
+            timeout: Number(process.env.QLING_VISION_TIMEOUT_MS) || 60000,
+        });
+        const result = resp.data.choices?.[0]?.message?.content || "";
+        // 自动重试机制：如果结果为空，尝试重新调用一次
+        const internalArgs = args;
+        if (!result && !internalArgs._is_retry) {
+            console.warn("⚠️ 视觉分析返回空结果，正在尝试自动重试...");
+            return runVisionAnalyze({ ...args, _is_retry: true });
+        }
+        return {
+            tool_call_id: "",
+            output: result ? `👁️ 视觉分析结果 (${model} @ ${provider}):\n\n${result}` : "[No analysis result]",
+            meta: { model, provider }
+        };
+    }
+    catch (err) {
+        const msg = err.response?.data?.error?.message || err.message;
+        let userHint = "";
+        if (msg.includes("Incorrect API key") || msg.includes("invalid_api_key") || err.response?.status === 401) {
+            userHint = `\n\n💡 提示: 检测到 API Key 鉴权失败。当前 Provider 为: ${provider}。 请确保您的 Key 能够访问该提供商的视觉模型。`;
+            if (provider !== "local") {
+                userHint += "\n如果您想使用本地模型，可设置 QLING_VISION_PROVIDER=local 并启动 Ollama。";
+            }
+        }
+        return {
+            tool_call_id: "",
+            output: `Error: Vision analysis failed (${provider}): ${msg}${userHint}`,
+            is_error: true,
+            error: { code: "VISION_FAILED", message: msg, category: "network" }
+        };
+    }
+}

package/dist/tools/write.d.ts

@@ -0,0 +1,7 @@
+import { ToolDefinition, ToolResult } from "../types.js";
+export declare const writeTool: ToolDefinition;
+export declare function runWrite(args: {
+    path: string;
+    content: string;
+}): Promise<ToolResult>;
+//# sourceMappingURL=write.d.ts.map

package/dist/tools/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/tools/write.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAWzD,eAAO,MAAM,SAAS,EAAE,cAsEvB,CAAC;AAqBF,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,UAAU,CAAC,CA6CtB"}

package/dist/tools/write.js

@@ -0,0 +1,128 @@
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { getErrorMessage, toolError, toolSuccess } from "./error-utils.js";
+import { checkSensitiveWriteTarget, getRuntimeRootsFromEnv, isPathAllowedForWrite, resolveToolPath, } from "../runtime-paths.js";
+const MAX_WRITE_BYTES = 256 * 1024; // 256KB
+export const writeTool = {
+    name: "write",
+    description: "Create or overwrite a file with given content. Parent directories are created automatically. Use for code, config, markdown, scripts, or any text files.",
+    longDescription: `创建或覆盖文件。**会修改磁盘文件**。
+
+**使用场景**:
+- 写入源代码文件（.ts, .js, .py, .java）
+- 写入配置文件（.json, .yaml, .env）
+- 写入 Markdown 文档（README.md, DESIGN.md）
+- 写入脚本文件（.sh, .ps1）
+
+**行为**:
+- 父目录不存在时自动创建（recursive: true）
+- 文件已存在时**覆盖**（无确认，无备份）
+- 返回成功消息（含写入路径）
+
+**危险警告**:
+- 覆盖系统文件（如 /etc/hosts）可能造成严重后果
+- 建议先 read 检查现有内容
+- Hook 会拦截可疑的目标路径
+
+**写入大文件**:
+- 单次写入建议不超过 50KB
+- 超大文件建议分多次写入`,
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Absolute or relative path to the file (directories created automatically)",
+            },
+            content: {
+                type: "string",
+                description: "The complete content to write to the file",
+            },
+        },
+        required: ["path", "content"],
+    },
+    paramSchema: {
+        path: {
+            type: "string",
+            description: "目标文件路径。父目录不存在时会自动创建。相对路径以当前工作目录为基准。",
+            minLength: 1,
+        },
+        content: {
+            type: "string",
+            description: "要写入的完整文件内容。建议不超过 50KB。超大型文件建议分多次写入。",
+        },
+    },
+    examples: [
+        'write path="src/utils.ts" content="export const foo = 1;"',
+        'write path="config.json" content=\'{"version": "1.0"}\'',
+        'write path="scripts/deploy.sh" content="#!/bin/bash\\necho done"',
+    ],
+    seeAlso: ["read", "bash"],
+    scenes: ["coding", "data"],
+    priority: 9, // 写入也是高频
+    readOnly: false,
+    destructive: false, // write 覆盖文件不等于破坏性（是预期行为）
+    concurrencySafe: false,
+    dangerousPatterns: [
+        "/etc/passwd",
+        "/etc/shadow",
+        "/etc/sudoers",
+        "C:\\Windows\\System32",
+        "/sys/",
+        "/proc/",
+    ],
+    effortHint: "medium",
+};
+const DANGEROUS_PATHS = [
+    "/etc/passwd",
+    "/etc/shadow",
+    "/etc/sudoers",
+    "C:\\Windows\\System32",
+    "/sys/",
+    "/proc/",
+];
+function isDangerousPath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+    for (const pattern of DANGEROUS_PATHS) {
+        if (normalized.includes(pattern.replace(/\\/g, "/").toLowerCase())) {
+            return pattern;
+        }
+    }
+    return null;
+}
+export async function runWrite(args) {
+    const inputPath = String(args.path ?? "").trim();
+    if (!inputPath) {
+        return toolError("WRITE_INVALID_PATH", "path is required");
+    }
+    const content = String(args.content ?? "");
+    const byteLength = Buffer.byteLength(content, "utf-8");
+    if (byteLength > MAX_WRITE_BYTES) {
+        return toolError("WRITE_CONTENT_TOO_LARGE", `content exceeds ${MAX_WRITE_BYTES} bytes (current: ${byteLength})`);
+    }
+    const roots = getRuntimeRootsFromEnv();
+    const resolvedPath = resolveToolPath(inputPath, roots, "workspace");
+    if (!isPathAllowedForWrite(resolvedPath, roots)) {
+        return toolError("WRITE_OUTSIDE_ALLOWED_ROOT", `${resolvedPath} is outside write sandbox (default: workspace only; set QLING_WRITE_SANDBOX=roots|off to relax)`);
+    }
+    const sensitive = checkSensitiveWriteTarget(resolvedPath);
+    if (sensitive?.blocked) {
+        return toolError(sensitive.code, sensitive.reason, { category: "permission" });
+    }
+    const danger = isDangerousPath(resolvedPath);
+    if (danger) {
+        return toolError("WRITE_DANGEROUS_PATH", `path "${resolvedPath}" matches dangerous pattern "${danger}"`);
+    }
+    try {
+        await mkdir(dirname(resolvedPath), { recursive: true });
+        await writeFile(resolvedPath, content, "utf-8");
+        return toolSuccess(`✅ 文件已写入: ${resolvedPath}`);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "EACCES" || code === "EPERM") {
+            return toolError("WRITE_PERMISSION_DENIED", `permission denied for ${resolvedPath}`);
+        }
+        return toolError("WRITE_FAILED", getErrorMessage(err));
+    }
+}

package/dist/tui/chrome.d.ts

@@ -0,0 +1,7 @@
+export interface TuiHeaderOptions {
+    model: string;
+    tools: number;
+    cwd: string;
+}
+export declare function formatTuiHeader(options: TuiHeaderOptions): string[];
+//# sourceMappingURL=chrome.d.ts.map

package/dist/tui/chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrome.d.ts","sourceRoot":"","sources":["../../src/tui/chrome.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAaD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAWnE"}

package/dist/tui/chrome.js

@@ -0,0 +1,22 @@
+function normalizeCwd(cwd) {
+    const normalized = cwd.trim();
+    if (!normalized)
+        return "-";
+    return normalized.replace(/\\/g, "/").replace(/^C:/, "C:");
+}
+function normalizeToolCount(tools) {
+    if (!Number.isFinite(tools) || tools <= 0)
+        return 0;
+    return Math.floor(tools);
+}
+export function formatTuiHeader(options) {
+    const model = options.model.trim() || "unknown";
+    const tools = normalizeToolCount(options.tools);
+    const workspace = normalizeCwd(options.cwd);
+    return [
+        "轻灵 · Agent CLI",
+        `model=${model}  tools=${tools}  mode=local-first`,
+        `workspace=${workspace}`,
+        "/help slash · Tab agents · Ctrl+Z restore · Ctrl+O output · /privacy boundary",
+    ];
+}

package/dist/tui/input-buffer.d.ts

@@ -0,0 +1,37 @@
+export declare class InputBuffer {
+    value: string;
+    cursorPos: number;
+    private history;
+    private historyIdx;
+    private historyDraft;
+    private historyDraftCursorPos;
+    constructor(initialHistory?: string[]);
+    setHistory(entries: string[]): void;
+    getHistory(): string[];
+    insertChar(ch: string): void;
+    insertNewline(): void;
+    backspace(): void;
+    moveLeft(): void;
+    moveRight(): void;
+    moveWordLeft(): void;
+    moveWordRight(): void;
+    moveLineUp(): void;
+    moveLineDown(): void;
+    moveStart(): void;
+    moveEnd(): void;
+    deleteBeforeCursor(): void;
+    deleteAfterCursor(): void;
+    deleteAfterCursorChar(): void;
+    deleteWordBeforeCursor(): void;
+    deleteWordAfterCursor(): void;
+    historyUp(): void;
+    historyDown(): void;
+    searchHistory(): boolean;
+    clear(): void;
+    submit(): string | null;
+    private saveHistoryDraft;
+    private restoreHistoryDraft;
+    private clearHistoryDraft;
+    private getLinePosition;
+}
+//# sourceMappingURL=input-buffer.d.ts.map

package/dist/tui/input-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-buffer.d.ts","sourceRoot":"","sources":["../../src/tui/input-buffer.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW;IACtB,KAAK,SAAM;IACX,SAAS,SAAK;IACd,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,qBAAqB,CAAK;gBAEtB,cAAc,GAAE,MAAM,EAAO;IAIzC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAMnC,UAAU,IAAI,MAAM,EAAE;IAItB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAK5B,aAAa,IAAI,IAAI;IAIrB,SAAS,IAAI,IAAI;IAMjB,QAAQ,IAAI,IAAI;IAMhB,SAAS,IAAI,IAAI;IAMjB,YAAY,IAAI,IAAI;IAcpB,aAAa,IAAI,IAAI;IAcrB,UAAU,IAAI,IAAI;IASlB,YAAY,IAAI,IAAI;IASpB,SAAS,IAAI,IAAI;IAIjB,OAAO,IAAI,IAAI;IAIf,kBAAkB,IAAI,IAAI;IAM1B,iBAAiB,IAAI,IAAI;IAKzB,qBAAqB,IAAI,IAAI;IAK7B,sBAAsB,IAAI,IAAI;IAe9B,qBAAqB,IAAI,IAAI;IAmB7B,SAAS,IAAI,IAAI;IASjB,WAAW,IAAI,IAAI;IAYnB,aAAa,IAAI,OAAO;IAuBxB,KAAK,IAAI,IAAI;IAOb,MAAM,IAAI,MAAM,GAAG,IAAI;IASvB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,eAAe;CAiCxB"}