@qlingzzy/qling 1.0.0

package/dist/tui/input-buffer.js

@@ -0,0 +1,228 @@
+export class InputBuffer {
+    value = "";
+    cursorPos = 0;
+    history = [];
+    historyIdx = -1;
+    historyDraft = null;
+    historyDraftCursorPos = 0;
+    constructor(initialHistory = []) {
+        this.setHistory(initialHistory);
+    }
+    setHistory(entries) {
+        this.history = entries.filter((entry) => typeof entry === "string" && entry.trim()).map((entry) => entry.trim());
+        this.historyIdx = this.history.length;
+        this.clearHistoryDraft();
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    insertChar(ch) {
+        this.value = this.value.slice(0, this.cursorPos) + ch + this.value.slice(this.cursorPos);
+        this.cursorPos += ch.length;
+    }
+    insertNewline() {
+        this.insertChar("\n");
+    }
+    backspace() {
+        if (this.cursorPos <= 0)
+            return;
+        this.value = this.value.slice(0, this.cursorPos - 1) + this.value.slice(this.cursorPos);
+        this.cursorPos--;
+    }
+    moveLeft() {
+        if (this.cursorPos > 0) {
+            this.cursorPos--;
+        }
+    }
+    moveRight() {
+        if (this.cursorPos < this.value.length) {
+            this.cursorPos++;
+        }
+    }
+    moveWordLeft() {
+        if (this.cursorPos <= 0)
+            return;
+        let nextPos = this.cursorPos;
+        while (nextPos > 0 && /\s/.test(this.value[nextPos - 1] ?? "")) {
+            nextPos--;
+        }
+        while (nextPos > 0 && !/\s/.test(this.value[nextPos - 1] ?? "")) {
+            nextPos--;
+        }
+        this.cursorPos = nextPos;
+    }
+    moveWordRight() {
+        if (this.cursorPos >= this.value.length)
+            return;
+        let nextPos = this.cursorPos;
+        while (nextPos < this.value.length && !/\s/.test(this.value[nextPos] ?? "")) {
+            nextPos++;
+        }
+        while (nextPos < this.value.length && /\s/.test(this.value[nextPos] ?? "")) {
+            nextPos++;
+        }
+        this.cursorPos = nextPos;
+    }
+    moveLineUp() {
+        const position = this.getLinePosition();
+        if (position.lineIndex <= 0)
+            return;
+        const targetLine = position.lines[position.lineIndex - 1] ?? "";
+        const targetColumn = Math.min(position.column, targetLine.length);
+        this.cursorPos = position.lineStartOffsets[position.lineIndex - 1] + targetColumn;
+    }
+    moveLineDown() {
+        const position = this.getLinePosition();
+        if (position.lineIndex >= position.lines.length - 1)
+            return;
+        const targetLine = position.lines[position.lineIndex + 1] ?? "";
+        const targetColumn = Math.min(position.column, targetLine.length);
+        this.cursorPos = position.lineStartOffsets[position.lineIndex + 1] + targetColumn;
+    }
+    moveStart() {
+        this.cursorPos = 0;
+    }
+    moveEnd() {
+        this.cursorPos = this.value.length;
+    }
+    deleteBeforeCursor() {
+        if (this.cursorPos <= 0)
+            return;
+        this.value = this.value.slice(this.cursorPos);
+        this.cursorPos = 0;
+    }
+    deleteAfterCursor() {
+        if (this.cursorPos >= this.value.length)
+            return;
+        this.value = this.value.slice(0, this.cursorPos);
+    }
+    deleteAfterCursorChar() {
+        if (this.cursorPos >= this.value.length)
+            return;
+        this.value = this.value.slice(0, this.cursorPos) + this.value.slice(this.cursorPos + 1);
+    }
+    deleteWordBeforeCursor() {
+        if (this.cursorPos <= 0)
+            return;
+        let start = this.cursorPos;
+        while (start > 0 && /\s/.test(this.value[start - 1] ?? "")) {
+            start--;
+        }
+        while (start > 0 && !/\s/.test(this.value[start - 1] ?? "")) {
+            start--;
+        }
+        this.value = this.value.slice(0, start) + this.value.slice(this.cursorPos);
+        this.cursorPos = start;
+    }
+    deleteWordAfterCursor() {
+        if (this.cursorPos >= this.value.length)
+            return;
+        let start = this.cursorPos;
+        while (start < this.value.length && /\s/.test(this.value[start] ?? "")) {
+            start++;
+        }
+        let end = start;
+        while (end < this.value.length && /\s/.test(this.value[end] ?? "")) {
+            end++;
+        }
+        while (end < this.value.length && !/\s/.test(this.value[end] ?? "")) {
+            end++;
+        }
+        this.value = this.value.slice(0, start) + this.value.slice(end);
+    }
+    historyUp() {
+        if (this.historyIdx > 0) {
+            this.saveHistoryDraft();
+            this.historyIdx--;
+            this.value = this.history[this.historyIdx] ?? "";
+            this.cursorPos = this.value.length;
+        }
+    }
+    historyDown() {
+        if (this.historyIdx < this.history.length - 1) {
+            this.historyIdx++;
+            this.value = this.history[this.historyIdx] ?? "";
+        }
+        else {
+            this.historyIdx = this.history.length;
+            this.restoreHistoryDraft();
+            return;
+        }
+        this.cursorPos = this.value.length;
+    }
+    searchHistory() {
+        const query = this.value.trim();
+        if (!query) {
+            const before = this.value;
+            const beforeIdx = this.historyIdx;
+            this.historyUp();
+            return this.value !== before || this.historyIdx !== beforeIdx;
+        }
+        for (let i = this.history.length - 1; i >= 0; i--) {
+            const entry = this.history[i] ?? "";
+            if (entry.includes(query)) {
+                this.saveHistoryDraft();
+                this.historyIdx = i;
+                this.value = entry;
+                this.cursorPos = entry.length;
+                return true;
+            }
+        }
+        return false;
+    }
+    clear() {
+        this.value = "";
+        this.cursorPos = 0;
+        this.historyIdx = this.history.length;
+        this.clearHistoryDraft();
+    }
+    submit() {
+        const cmd = this.value.trim();
+        if (!cmd)
+            return null;
+        this.history = [...this.history.filter((entry) => entry !== cmd), cmd];
+        this.historyIdx = this.history.length;
+        this.clear();
+        return cmd;
+    }
+    saveHistoryDraft() {
+        if (this.historyIdx !== this.history.length || this.historyDraft !== null)
+            return;
+        this.historyDraft = this.value;
+        this.historyDraftCursorPos = this.cursorPos;
+    }
+    restoreHistoryDraft() {
+        this.value = this.historyDraft ?? "";
+        this.cursorPos = this.historyDraft === null ? this.value.length : this.historyDraftCursorPos;
+        this.clearHistoryDraft();
+    }
+    clearHistoryDraft() {
+        this.historyDraft = null;
+        this.historyDraftCursorPos = 0;
+    }
+    getLinePosition() {
+        const lines = this.value.split("\n");
+        const lineStartOffsets = [];
+        let offset = 0;
+        for (const line of lines) {
+            lineStartOffsets.push(offset);
+            offset += line.length + 1;
+        }
+        let lineIndex = 0;
+        for (let i = 0; i < lineStartOffsets.length; i++) {
+            const start = lineStartOffsets[i];
+            const line = lines[i] ?? "";
+            const end = start + line.length;
+            if (this.cursorPos <= end || i === lineStartOffsets.length - 1) {
+                lineIndex = i;
+                break;
+            }
+        }
+        return {
+            lines,
+            lineStartOffsets,
+            lineIndex,
+            column: this.cursorPos - lineStartOffsets[lineIndex],
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+export interface InputHistoryOptions {
+    stateDir: string;
+    maxEntries?: number;
+    maxEntryChars?: number;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}
+export declare function resolveInputHistoryPath(stateDir: string): string;
+export declare function shouldPersistInputHistory(input: string, maxEntryChars?: number): boolean;
+export declare function loadInputHistory(options: InputHistoryOptions): Promise<string[]>;
+export declare function appendInputHistory(input: string, options: InputHistoryOptions): Promise<string[]>;
+//# sourceMappingURL=input-history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-history.d.ts","sourceRoot":"","sources":["../../src/tui/input-history.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC9D;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE;AAUD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,SAA0B,GAAG,OAAO,CAKzG;AAiBD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUtF;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBvG"}

package/dist/tui/input-history.js

@@ -0,0 +1,69 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+const DEFAULT_MAX_ENTRIES = 200;
+const DEFAULT_MAX_ENTRY_CHARS = 8000;
+const SENSITIVE_INPUT_PATTERN = /\b(api[_-]?key|token|password|passwd|secret|authorization|bearer)\b|sk-[A-Za-z0-9_-]{8,}/i;
+export function resolveInputHistoryPath(stateDir) {
+    return join(stateDir, "input-history.json");
+}
+function isHistoryEnabled(env = process.env) {
+    return String(env.QLING_TUI_HISTORY_ENABLED ?? "true").toLowerCase() !== "false";
+}
+function resolveLimit(value, fallback) {
+    return Number.isFinite(value) && Number(value) > 0 ? Math.floor(Number(value)) : fallback;
+}
+export function shouldPersistInputHistory(input, maxEntryChars = DEFAULT_MAX_ENTRY_CHARS) {
+    const value = input.trim();
+    if (!value)
+        return false;
+    if (value.length > maxEntryChars)
+        return false;
+    return !SENSITIVE_INPUT_PATTERN.test(value);
+}
+function normalizeHistory(entries, options) {
+    const maxEntries = resolveLimit(options.maxEntries, DEFAULT_MAX_ENTRIES);
+    const maxEntryChars = resolveLimit(options.maxEntryChars, DEFAULT_MAX_ENTRY_CHARS);
+    let deduped = [];
+    for (const entry of entries) {
+        if (typeof entry !== "string")
+            continue;
+        const value = entry.trim();
+        if (!shouldPersistInputHistory(value, maxEntryChars))
+            continue;
+        deduped = [...deduped.filter((item) => item !== value), value];
+    }
+    return deduped.slice(-maxEntries);
+}
+export async function loadInputHistory(options) {
+    if (!isHistoryEnabled(options.env))
+        return [];
+    try {
+        const raw = await readFile(resolveInputHistoryPath(options.stateDir), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return normalizeHistory(parsed, options);
+    }
+    catch {
+        return [];
+    }
+}
+export async function appendInputHistory(input, options) {
+    if (!isHistoryEnabled(options.env))
+        return [];
+    const maxEntryChars = resolveLimit(options.maxEntryChars, DEFAULT_MAX_ENTRY_CHARS);
+    const value = input.trim();
+    const current = await loadInputHistory(options);
+    if (!shouldPersistInputHistory(value, maxEntryChars))
+        return current;
+    const next = normalizeHistory([...current, value], options);
+    const file = resolveInputHistoryPath(options.stateDir);
+    try {
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    }
+    catch {
+        return current;
+    }
+    return next;
+}

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

@@ -0,0 +1,27 @@
+export interface SerialInputQueueOptions {
+    onError?: (error: unknown, input: string) => void | Promise<void>;
+    onQueued?: (event: {
+        pendingCount: number;
+    }) => void;
+    onRejected?: (event: {
+        pendingCount: number;
+        maxPending: number;
+    }) => void;
+    maxPending?: number;
+}
+export declare class SerialInputQueue {
+    private readonly onError?;
+    private readonly onQueued?;
+    private readonly onRejected?;
+    private readonly maxPending;
+    private readonly queue;
+    private draining;
+    constructor(options?: SerialInputQueueOptions);
+    get pendingCount(): number;
+    get isProcessing(): boolean;
+    get maxPendingCount(): number;
+    clearPending(): number;
+    enqueue(input: string, handler: (input: string) => Promise<void>): Promise<boolean>;
+    private drain;
+}
+//# sourceMappingURL=input-queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-queue.d.ts","sourceRoot":"","sources":["../../src/tui/input-queue.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACrD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAQD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA0D;IACnF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAA4C;IACtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAgE;IAC5F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,uBAA4B;IASjD,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,YAAY,IAAI,MAAM;IAQtB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;YAwBrE,KAAK;CAuBpB"}

package/dist/tui/input-queue.js

@@ -0,0 +1,85 @@
+export class SerialInputQueue {
+    onError;
+    onQueued;
+    onRejected;
+    maxPending;
+    queue = [];
+    draining = false;
+    constructor(options = {}) {
+        this.onError = options.onError;
+        this.onQueued = options.onQueued;
+        this.onRejected = options.onRejected;
+        this.maxPending = Number.isFinite(options.maxPending) && Number(options.maxPending) >= 0
+            ? Math.floor(Number(options.maxPending))
+            : Number.POSITIVE_INFINITY;
+    }
+    get pendingCount() {
+        return this.queue.length;
+    }
+    get isProcessing() {
+        return this.draining;
+    }
+    get maxPendingCount() {
+        return this.maxPending;
+    }
+    clearPending() {
+        const pending = this.queue.splice(0);
+        for (const item of pending) {
+            item.resolve(false);
+        }
+        return pending.length;
+    }
+    enqueue(input, handler) {
+        const wasBusy = this.draining || this.queue.length > 0;
+        if (wasBusy && this.queue.length >= this.maxPending) {
+            try {
+                this.onRejected?.({ pendingCount: this.queue.length, maxPending: this.maxPending });
+            }
+            catch {
+                // Backpressure visibility must not affect the active queue.
+            }
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve) => {
+            this.queue.push({ input, handler, resolve });
+            if (wasBusy) {
+                try {
+                    this.onQueued?.({ pendingCount: this.queue.length });
+                }
+                catch {
+                    // Queue visibility must not affect input delivery.
+                }
+            }
+            void this.drain();
+        });
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            while (this.queue.length > 0) {
+                const item = this.queue.shift();
+                if (!item)
+                    continue;
+                try {
+                    await item.handler(item.input);
+                }
+                catch (error) {
+                    try {
+                        await this.onError?.(error, item.input);
+                    }
+                    catch {
+                        // Error reporting must not wedge the input queue.
+                    }
+                }
+                finally {
+                    item.resolve(true);
+                }
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+}

package/dist/tui/markdown.d.ts

@@ -0,0 +1,10 @@
+export interface ParsedTable {
+    headers: string[];
+    rows: string[][];
+}
+export declare function parseMarkdownTable(lines: string[]): ParsedTable | null;
+export declare function renderTable(table: ParsedTable, width: number): string[];
+export declare function formatMarkdownForTerminal(text: string, options: {
+    width: number;
+}): string[];
+//# sourceMappingURL=markdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/tui/markdown.ts"],"names":[],"mappings":"AAqCA,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;CAClB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,WAAW,GAAG,IAAI,CA8DtE;AAuDD,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAqGvE;AAaD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAmK5F"}