@sheepbun/yips 0.1.1

package/dist/ui/prompt/prompt-composer.js

@@ -0,0 +1,498 @@
+"use strict";
+/** Bounded multiline prompt composer state machine. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptComposer = void 0;
+exports.buildPromptComposerLayout = buildPromptComposerLayout;
+const DEFAULT_PREFIX = ">>> ";
+function toChars(text) {
+    return Array.from(text);
+}
+function charLength(text) {
+    return Array.from(text).length;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function takeLeftChars(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    const chars = toChars(text);
+    return chars.slice(0, maxWidth).join("");
+}
+function rowCapacity(rowIndex, firstRowContentWidth, interiorWidth) {
+    return rowIndex === 0 ? firstRowContentWidth : interiorWidth;
+}
+function buildPromptComposerLayout(text, cursor, interiorWidth, prefix = DEFAULT_PREFIX) {
+    const safeInteriorWidth = Math.max(0, interiorWidth);
+    const visiblePrefix = takeLeftChars(prefix, safeInteriorWidth);
+    const firstRowContentWidth = Math.max(0, safeInteriorWidth - charLength(visiblePrefix));
+    const textChars = toChars(text);
+    const safeCursor = clamp(cursor, 0, textChars.length);
+    const rowChars = [[]];
+    const rowStarts = [0];
+    const rowEnds = [];
+    if (safeInteriorWidth > 0) {
+        let rowIndex = 0;
+        for (let textIndex = 0; textIndex < textChars.length; textIndex++) {
+            const char = textChars[textIndex] ?? "";
+            if (char === "\n") {
+                rowEnds[rowIndex] = textIndex;
+                rowIndex += 1;
+                rowChars[rowIndex] = [];
+                rowStarts[rowIndex] = textIndex + 1;
+                continue;
+            }
+            let placed = false;
+            while (!placed) {
+                const capacity = rowCapacity(rowIndex, firstRowContentWidth, safeInteriorWidth);
+                if (capacity <= 0) {
+                    rowEnds[rowIndex] = textIndex;
+                    rowIndex += 1;
+                    rowChars[rowIndex] = rowChars[rowIndex] ?? [];
+                    rowStarts[rowIndex] = rowStarts[rowIndex] ?? textIndex;
+                    continue;
+                }
+                if ((rowChars[rowIndex]?.length ?? 0) < capacity) {
+                    rowChars[rowIndex]?.push(char);
+                    placed = true;
+                    continue;
+                }
+                rowEnds[rowIndex] = textIndex;
+                rowIndex += 1;
+                rowChars[rowIndex] = rowChars[rowIndex] ?? [];
+                rowStarts[rowIndex] = rowStarts[rowIndex] ?? textIndex;
+            }
+        }
+        rowEnds[rowIndex] = textChars.length;
+    }
+    else {
+        for (let textIndex = 0; textIndex < textChars.length; textIndex++) {
+            if (textChars[textIndex] !== "\n")
+                continue;
+            rowEnds[rowStarts.length - 1] = textIndex;
+            rowStarts.push(textIndex + 1);
+            rowChars.push([]);
+        }
+        rowEnds[rowStarts.length - 1] = textChars.length;
+    }
+    const rows = rowChars.map((chars) => chars.join(""));
+    if (rows.length === 0)
+        rows.push("");
+    let cursorRow = rows.length - 1;
+    let cursorCol = charLength(rows[cursorRow] ?? "");
+    for (let i = 0; i < rows.length; i++) {
+        const rowStart = rowStarts[i] ?? 0;
+        const rowEnd = rowEnds[i] ?? 0;
+        if (safeCursor >= rowStart && safeCursor <= rowEnd) {
+            cursorRow = i;
+            cursorCol = safeCursor - rowStart;
+            break;
+        }
+    }
+    return {
+        text,
+        cursor: safeCursor,
+        rows,
+        rowStarts,
+        rowEnds,
+        rowCount: rows.length,
+        cursorRow,
+        cursorCol,
+        interiorWidth: safeInteriorWidth,
+        prefix: visiblePrefix,
+        firstRowContentWidth
+    };
+}
+function textFromChars(chars) {
+    return chars.join("");
+}
+function whitespace(char) {
+    return char === undefined || /\s/.test(char);
+}
+function noneEvent() {
+    return { type: "none" };
+}
+function menuStateKey(token, options) {
+    return `${token}\u0000${options.join("\u0001")}`;
+}
+class PromptComposer {
+    chars;
+    cursor;
+    prefix;
+    interiorWidth;
+    history;
+    commandAutoComplete;
+    modelAutoComplete;
+    historyIndex;
+    historyDraft;
+    preferredColumn;
+    layout;
+    autocompleteSelection;
+    suppressAutocompleteMenu;
+    constructor(options) {
+        const initialText = options.text ?? "";
+        this.chars = toChars(initialText);
+        this.cursor = clamp(options.cursor ?? this.chars.length, 0, this.chars.length);
+        this.prefix = options.prefix ?? DEFAULT_PREFIX;
+        this.interiorWidth = Math.max(0, options.interiorWidth);
+        this.history = options.history;
+        this.commandAutoComplete = options.commandAutoComplete ?? options.autoComplete ?? [];
+        this.modelAutoComplete = options.modelAutoComplete ?? [];
+        this.historyIndex = this.history.length;
+        this.historyDraft = initialText;
+        this.preferredColumn = null;
+        this.autocompleteSelection = null;
+        this.suppressAutocompleteMenu = false;
+        this.layout = buildPromptComposerLayout(textFromChars(this.chars), this.cursor, this.interiorWidth, this.prefix);
+    }
+    getText() {
+        return textFromChars(this.chars);
+    }
+    getCursor() {
+        return this.cursor;
+    }
+    getLayout() {
+        return this.layout;
+    }
+    setInteriorWidth(width) {
+        this.interiorWidth = Math.max(0, width);
+        this.recomputeLayout();
+    }
+    setModelAutocompleteCandidates(candidates) {
+        this.modelAutoComplete = [...candidates];
+        this.markAutocompleteDirty();
+    }
+    applyAutocompleteChoice(tokenStart, tokenEnd, selection) {
+        this.replaceRange(tokenStart, tokenEnd, selection);
+    }
+    clearAutocompleteSelection() {
+        this.autocompleteSelection = null;
+        this.suppressAutocompleteMenu = false;
+    }
+    moveAutocompleteSelection(direction) {
+        const menu = this.getAutocompleteMenuState();
+        if (!menu || menu.options.length === 0) {
+            return noneEvent();
+        }
+        const nextIndex = (menu.selectedIndex + direction + menu.options.length) % menu.options.length;
+        this.autocompleteSelection = {
+            key: menuStateKey(menu.token, menu.options),
+            selectedIndex: nextIndex
+        };
+        return noneEvent();
+    }
+    acceptAutocompleteSelection() {
+        const menu = this.getAutocompleteMenuState();
+        if (!menu) {
+            return noneEvent();
+        }
+        const selection = menu.options[menu.selectedIndex] ?? menu.token;
+        this.applyAutocompleteChoice(menu.tokenStart, menu.tokenEnd, selection);
+        this.autocompleteSelection = null;
+        this.suppressAutocompleteMenu = true;
+        return noneEvent();
+    }
+    getAutocompleteMenuState() {
+        if (this.suppressAutocompleteMenu) {
+            return null;
+        }
+        const suggestions = this.computeAutocompleteSuggestions();
+        if (!suggestions) {
+            this.autocompleteSelection = null;
+            return null;
+        }
+        const key = menuStateKey(suggestions.token, suggestions.options);
+        if (!this.autocompleteSelection || this.autocompleteSelection.key !== key) {
+            this.autocompleteSelection = { key, selectedIndex: 0 };
+        }
+        const maxIndex = Math.max(0, suggestions.options.length - 1);
+        const selectedIndex = clamp(this.autocompleteSelection.selectedIndex, 0, maxIndex);
+        this.autocompleteSelection = { key, selectedIndex };
+        return {
+            ...suggestions,
+            selectedIndex
+        };
+    }
+    getAutocompleteSuggestions() {
+        const menu = this.getAutocompleteMenuState();
+        if (!menu) {
+            return null;
+        }
+        return {
+            token: menu.token,
+            tokenStart: menu.tokenStart,
+            tokenEnd: menu.tokenEnd,
+            options: [...menu.options]
+        };
+    }
+    handleKey(key, data) {
+        if (data?.isCharacter) {
+            this.detachFromHistory();
+            this.preferredColumn = null;
+            this.insertText(key);
+            return noneEvent();
+        }
+        switch (key) {
+            case "ENTER":
+            case "KP_ENTER":
+            case "CTRL_M":
+                return { type: "submit", value: this.getText() };
+            case "CTRL_ENTER":
+                this.detachFromHistory();
+                this.preferredColumn = null;
+                this.insertText("\n");
+                return noneEvent();
+            case "ESCAPE":
+                return { type: "cancel" };
+            case "BACKSPACE":
+                this.detachFromHistory();
+                this.preferredColumn = null;
+                this.backspace();
+                return noneEvent();
+            case "DELETE":
+                this.detachFromHistory();
+                this.preferredColumn = null;
+                this.deleteForward();
+                return noneEvent();
+            case "LEFT":
+                this.preferredColumn = null;
+                this.moveCursor(-1);
+                return noneEvent();
+            case "RIGHT":
+                this.preferredColumn = null;
+                this.moveCursor(1);
+                return noneEvent();
+            case "HOME":
+                this.preferredColumn = null;
+                this.moveToLineBoundary("start");
+                return noneEvent();
+            case "END":
+                this.preferredColumn = null;
+                this.moveToLineBoundary("end");
+                return noneEvent();
+            case "UP":
+                if (this.moveVertical(-1))
+                    return noneEvent();
+                this.historyPrevious();
+                return noneEvent();
+            case "DOWN":
+                if (this.moveVertical(1))
+                    return noneEvent();
+                this.historyNext();
+                return noneEvent();
+            case "TAB":
+                return this.handleAutoComplete();
+            default:
+                return noneEvent();
+        }
+    }
+    recomputeLayout() {
+        this.layout = buildPromptComposerLayout(textFromChars(this.chars), this.cursor, this.interiorWidth, this.prefix);
+    }
+    detachFromHistory() {
+        if (this.historyIndex === this.history.length)
+            return;
+        this.historyIndex = this.history.length;
+        this.historyDraft = this.getText();
+    }
+    insertText(text) {
+        const insert = toChars(text);
+        if (insert.length === 0)
+            return;
+        this.markAutocompleteDirty();
+        this.chars.splice(this.cursor, 0, ...insert);
+        this.cursor += insert.length;
+        this.recomputeLayout();
+    }
+    replaceRange(start, end, replacement) {
+        const safeStart = clamp(start, 0, this.chars.length);
+        const safeEnd = clamp(end, safeStart, this.chars.length);
+        const replacementChars = toChars(replacement);
+        this.detachFromHistory();
+        this.markAutocompleteDirty();
+        this.preferredColumn = null;
+        this.chars.splice(safeStart, safeEnd - safeStart, ...replacementChars);
+        this.cursor = safeStart + replacementChars.length;
+        this.recomputeLayout();
+    }
+    backspace() {
+        if (this.cursor <= 0)
+            return;
+        this.markAutocompleteDirty();
+        this.chars.splice(this.cursor - 1, 1);
+        this.cursor -= 1;
+        this.recomputeLayout();
+    }
+    deleteForward() {
+        if (this.cursor >= this.chars.length)
+            return;
+        this.markAutocompleteDirty();
+        this.chars.splice(this.cursor, 1);
+        this.recomputeLayout();
+    }
+    moveCursor(delta) {
+        this.markAutocompleteDirty();
+        this.cursor = clamp(this.cursor + delta, 0, this.chars.length);
+        this.recomputeLayout();
+    }
+    moveToLineBoundary(target) {
+        this.markAutocompleteDirty();
+        const row = this.layout.cursorRow;
+        if (target === "start") {
+            this.cursor = this.layout.rowStarts[row] ?? this.cursor;
+        }
+        else {
+            this.cursor = this.layout.rowEnds[row] ?? this.cursor;
+        }
+        this.recomputeLayout();
+    }
+    moveVertical(direction) {
+        const targetRow = this.layout.cursorRow + direction;
+        if (targetRow < 0 || targetRow >= this.layout.rowCount) {
+            return false;
+        }
+        this.markAutocompleteDirty();
+        const preferred = this.preferredColumn ?? this.layout.cursorCol;
+        const targetRowLen = charLength(this.layout.rows[targetRow] ?? "");
+        const targetCol = Math.min(preferred, targetRowLen);
+        const targetStart = this.layout.rowStarts[targetRow] ?? 0;
+        this.cursor = targetStart + targetCol;
+        this.preferredColumn = preferred;
+        this.recomputeLayout();
+        return true;
+    }
+    historyPrevious() {
+        if (this.history.length === 0 || this.historyIndex <= 0)
+            return;
+        if (this.historyIndex === this.history.length) {
+            this.historyDraft = this.getText();
+        }
+        this.historyIndex -= 1;
+        this.loadHistoryValue(this.history[this.historyIndex] ?? "");
+    }
+    historyNext() {
+        if (this.history.length === 0 || this.historyIndex >= this.history.length)
+            return;
+        this.historyIndex += 1;
+        if (this.historyIndex === this.history.length) {
+            this.loadHistoryValue(this.historyDraft);
+            return;
+        }
+        this.loadHistoryValue(this.history[this.historyIndex] ?? "");
+    }
+    loadHistoryValue(value) {
+        this.markAutocompleteDirty();
+        this.chars = toChars(value);
+        this.cursor = this.chars.length;
+        this.preferredColumn = null;
+        this.recomputeLayout();
+    }
+    markAutocompleteDirty() {
+        this.autocompleteSelection = null;
+        this.suppressAutocompleteMenu = false;
+    }
+    tokenBounds() {
+        let start = this.cursor;
+        while (start > 0 && !whitespace(this.chars[start - 1])) {
+            start -= 1;
+        }
+        let end = this.cursor;
+        while (end < this.chars.length && !whitespace(this.chars[end])) {
+            end += 1;
+        }
+        const token = this.chars.slice(start, end).join("");
+        return { start, end, token };
+    }
+    tokenSpans() {
+        const spans = [];
+        let index = 0;
+        while (index < this.chars.length) {
+            while (index < this.chars.length && whitespace(this.chars[index])) {
+                index += 1;
+            }
+            if (index >= this.chars.length) {
+                break;
+            }
+            const start = index;
+            while (index < this.chars.length && !whitespace(this.chars[index])) {
+                index += 1;
+            }
+            const end = index;
+            spans.push({
+                start,
+                end,
+                token: this.chars.slice(start, end).join("")
+            });
+        }
+        return spans;
+    }
+    currentTokenIndex(bounds) {
+        const spans = this.tokenSpans();
+        if (bounds.token.length > 0) {
+            const index = spans.findIndex((span) => this.cursor >= span.start && this.cursor <= span.end);
+            if (index >= 0) {
+                return index;
+            }
+        }
+        return spans.filter((span) => span.end <= bounds.start).length;
+    }
+    firstToken() {
+        const spans = this.tokenSpans();
+        return spans[0]?.token ?? "";
+    }
+    modelOptionsForToken(token) {
+        const needle = token.trim().toLowerCase();
+        const options = [];
+        const seen = new Set();
+        for (const candidate of this.modelAutoComplete) {
+            const value = candidate.value.trim();
+            if (value.length === 0 || seen.has(value)) {
+                continue;
+            }
+            const aliases = [value, ...candidate.aliases].map((entry) => entry.trim().toLowerCase());
+            const matches = needle.length === 0 || aliases.some((alias) => alias.length > 0 && alias.startsWith(needle));
+            if (!matches) {
+                continue;
+            }
+            seen.add(value);
+            options.push(value);
+        }
+        return options;
+    }
+    computeAutocompleteSuggestions() {
+        const bounds = this.tokenBounds();
+        const firstToken = this.firstToken().toLowerCase();
+        const tokenIndex = this.currentTokenIndex(bounds);
+        if (bounds.token.startsWith("/")) {
+            const options = this.commandAutoComplete.filter((candidate) => candidate.startsWith(bounds.token));
+            if (options.length === 0) {
+                return null;
+            }
+            return {
+                token: bounds.token,
+                tokenStart: bounds.start,
+                tokenEnd: bounds.end,
+                options: [...options]
+            };
+        }
+        const isModelArg = firstToken === "/model" && tokenIndex === 1;
+        const isNickTargetArg = firstToken === "/nick" && tokenIndex === 1;
+        if (!isModelArg && !isNickTargetArg) {
+            return null;
+        }
+        const options = this.modelOptionsForToken(bounds.token);
+        if (options.length === 0) {
+            return null;
+        }
+        return {
+            token: bounds.token,
+            tokenStart: bounds.start,
+            tokenEnd: bounds.end,
+            options
+        };
+    }
+    handleAutoComplete() {
+        return noneEvent();
+    }
+}
+exports.PromptComposer = PromptComposer;

package/dist/ui/spinner.js

@@ -0,0 +1,76 @@
+"use strict";
+/** Pulsing braille spinner with color oscillation. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PulsingSpinner = void 0;
+const colors_1 = require("#ui/colors");
+const SPINNER_FRAMES = ["⠹", "⢸", "⣰", "⣤", "⣆", "⡇", "⠏", "⠛"];
+const FRAME_COUNT = SPINNER_FRAMES.length;
+const OSCILLATION_RATE = 2.0;
+const FRAME_INTERVAL_MS = 80;
+class PulsingSpinner {
+    label;
+    frameIndex;
+    startTime;
+    lastFrameTime;
+    active;
+    constructor(label = "Thinking...") {
+        this.label = label;
+        this.frameIndex = 0;
+        this.startTime = Date.now();
+        this.lastFrameTime = this.startTime;
+        this.active = false;
+    }
+    start(label) {
+        if (label !== undefined) {
+            this.label = label;
+        }
+        this.frameIndex = 0;
+        this.startTime = Date.now();
+        this.lastFrameTime = this.startTime;
+        this.active = true;
+    }
+    stop() {
+        this.active = false;
+    }
+    update(label) {
+        this.label = label;
+    }
+    isActive() {
+        return this.active;
+    }
+    getElapsed() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+    formatElapsed(seconds) {
+        const minutes = Math.floor(seconds / 60);
+        const remainder = seconds % 60;
+        if (minutes === 0) {
+            return `${remainder}s`;
+        }
+        return `${minutes}m ${remainder}s`;
+    }
+    render() {
+        const now = Date.now();
+        const elapsedSinceFrame = now - this.lastFrameTime;
+        if (elapsedSinceFrame >= FRAME_INTERVAL_MS) {
+            const frameSteps = Math.floor(elapsedSinceFrame / FRAME_INTERVAL_MS);
+            this.frameIndex = (this.frameIndex + frameSteps) % FRAME_COUNT;
+            this.lastFrameTime += frameSteps * FRAME_INTERVAL_MS;
+        }
+        const frame = SPINNER_FRAMES[this.frameIndex % FRAME_COUNT];
+        const elapsedSeconds = Math.max(0, (now - this.startTime) / 1000);
+        const elapsed = Math.floor(elapsedSeconds);
+        const t = (Math.sin(elapsedSeconds * OSCILLATION_RATE) + 1) / 2;
+        const color = (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, t);
+        const timeText = this.formatElapsed(elapsed);
+        const spinnerChar = (0, colors_1.colorText)(frame, color);
+        const labelText = (0, colors_1.colorText)(this.label, color);
+        const suffix = (0, colors_1.colorText)(`(${timeText})`, color);
+        return `${spinnerChar} ${labelText} ${suffix}`;
+    }
+    static computeOscillationColor(elapsedSeconds) {
+        const t = (Math.sin(elapsedSeconds * OSCILLATION_RATE) + 1) / 2;
+        return (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, t);
+    }
+}
+exports.PulsingSpinner = PulsingSpinner;