@sheepbun/yips 0.1.1

package/dist/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/repl.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHelpText = renderHelpText;
+exports.handleInput = handleInput;
+exports.applyAction = applyAction;
+exports.startRepl = startRepl;
+const node_process_1 = require("node:process");
+const promises_1 = require("node:readline/promises");
+function renderHelpText() {
+    return [
+        "Available commands:",
+        "  /help  - Show this help",
+        "  /exit  - Exit the REPL",
+        "  /restart  - Restart Yips",
+        "  /quit  - Exit the REPL"
+    ].join("\n");
+}
+function handleInput(input, state) {
+    if (!state.running) {
+        return { type: "exit" };
+    }
+    const trimmed = input.trim();
+    if (trimmed.startsWith("/")) {
+        const [commandToken = ""] = trimmed.split(/\s+/, 1);
+        const normalizedCommand = commandToken.toLowerCase();
+        if (normalizedCommand === "/help") {
+            return { type: "help" };
+        }
+        if (normalizedCommand === "/exit" || normalizedCommand === "/quit") {
+            return { type: "exit" };
+        }
+        if (normalizedCommand === "/restart") {
+            return { type: "restart" };
+        }
+        return { type: "unknown", command: normalizedCommand.slice(1) };
+    }
+    return { type: "echo", text: input };
+}
+function streamIsTTY(stream) {
+    if (typeof stream !== "object" || stream === null || !("isTTY" in stream)) {
+        return false;
+    }
+    return stream.isTTY === true;
+}
+function writeLine(output, message) {
+    output.write(`${message}\n`);
+}
+function assertNever(value) {
+    throw new Error(`Unexpected action: ${JSON.stringify(value)}`);
+}
+function applyAction(action, state, output) {
+    switch (action.type) {
+        case "help":
+            writeLine(output, renderHelpText());
+            return;
+        case "exit":
+            state.running = false;
+            writeLine(output, "Goodbye.");
+            return;
+        case "restart":
+            state.running = false;
+            writeLine(output, "Restarting Yips.");
+            return;
+        case "echo":
+            if (action.text.trim().length > 0) {
+                state.messageCount += 1;
+                writeLine(output, `Yips: ${action.text}`);
+            }
+            return;
+        case "unknown":
+            writeLine(output, `Unknown command: /${action.command}. Type /help for help.`);
+            return;
+        default:
+            assertNever(action);
+    }
+}
+async function startRepl(options) {
+    const input = options.input ?? node_process_1.stdin;
+    const output = options.output ?? node_process_1.stdout;
+    const prompt = options.prompt ?? "> ";
+    const terminal = streamIsTTY(input) && streamIsTTY(output);
+    const state = {
+        messageCount: 0,
+        running: true,
+        config: options.config
+    };
+    writeLine(output, "Yips Milestone 0 REPL");
+    writeLine(output, "Type /help for commands.");
+    const readline = (0, promises_1.createInterface)({ input, output, terminal });
+    let restartRequested = false;
+    try {
+        while (state.running) {
+            const inputLine = await readline.question(prompt);
+            const action = handleInput(inputLine, state);
+            if (action.type === "restart") {
+                restartRequested = true;
+            }
+            applyAction(action, state, output);
+        }
+    }
+    finally {
+        readline.close();
+    }
+    return restartRequested ? "restart" : "exit";
+}