@sheepbun/yips 0.1.1 → 0.1.46

package/dist/input-engine.js

@@ -1,250 +0,0 @@
-"use strict";
-/** Raw-stdin input parser for deterministic prompt editing actions. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputEngine = void 0;
-exports.parseCsiSequence = parseCsiSequence;
-const node_string_decoder_1 = require("node:string_decoder");
-function parseInteger(value) {
-    const parsed = Number(value);
-    return Number.isInteger(parsed) ? parsed : null;
-}
-function isEnterKeyCode(code) {
-    return code === 1 || code === 10 || code === 13 || code === 57414;
-}
-function toEnterAction(modifier) {
-    return modifier > 1 ? { type: "newline" } : { type: "submit" };
-}
-function parseEnterActionFromCsiBody(body, final) {
-    if (final === "u" || final === "~" || final === "M") {
-        const keyOnly = body.match(/^(\d+)$/);
-        if (keyOnly) {
-            const keyCode = parseInteger(keyOnly[1] ?? "");
-            if (keyCode !== null && isEnterKeyCode(keyCode)) {
-                return { type: "submit" };
-            }
-        }
-        const keyAndModifier = body.match(/^(\d+);(\d+)$/);
-        if (keyAndModifier) {
-            const keyCode = parseInteger(keyAndModifier[1] ?? "");
-            const modifier = parseInteger(keyAndModifier[2] ?? "");
-            if (keyCode !== null && modifier !== null && isEnterKeyCode(keyCode) && modifier >= 1) {
-                return toEnterAction(modifier);
-            }
-        }
-    }
-    if (final === "~") {
-        const legacyModifyOtherKeys = body.match(/^27;(\d+);(\d+)$/);
-        if (legacyModifyOtherKeys) {
-            const first = parseInteger(legacyModifyOtherKeys[1] ?? "");
-            const second = parseInteger(legacyModifyOtherKeys[2] ?? "");
-            if (first === null || second === null) {
-                return null;
-            }
-            if (isEnterKeyCode(first) && second >= 1) {
-                return toEnterAction(second);
-            }
-            if (isEnterKeyCode(second) && first >= 1) {
-                return toEnterAction(first);
-            }
-        }
-    }
-    return null;
-}
-function parseMouseActionFromCsiBody(body, final) {
-    if (final !== "M" && final !== "m") {
-        return null;
-    }
-    if (!body.startsWith("<")) {
-        return null;
-    }
-    const params = body.slice(1).split(";");
-    const buttonCode = parseInteger(params[0] ?? "");
-    if (buttonCode === null) {
-        return null;
-    }
-    // SGR mouse wheel encodes bit 6 for wheel + bit 0 for direction.
-    // Modifier bits may be present (shift/alt/ctrl), so match by bitmask.
-    if ((buttonCode & 0x40) !== 0) {
-        return (buttonCode & 0x01) === 0
-            ? { type: "scroll-line-up" }
-            : { type: "scroll-line-down" };
-    }
-    return null;
-}
-function parseCsiSequence(sequence) {
-    if (!sequence.startsWith("\x1b[")) {
-        return null;
-    }
-    if (sequence.length < 3) {
-        return null;
-    }
-    const final = sequence[sequence.length - 1] ?? "";
-    const body = sequence.slice(2, -1);
-    const enterAction = parseEnterActionFromCsiBody(body, final);
-    if (enterAction) {
-        return enterAction;
-    }
-    const mouseAction = parseMouseActionFromCsiBody(body, final);
-    if (mouseAction) {
-        return mouseAction;
-    }
-    if (final === "A")
-        return { type: "move-up" };
-    if (final === "B")
-        return { type: "move-down" };
-    if (final === "C")
-        return { type: "move-right" };
-    if (final === "D")
-        return { type: "move-left" };
-    if (final === "H")
-        return { type: "home" };
-    if (final === "F")
-        return { type: "end" };
-    if (final === "Z")
-        return { type: "tab" };
-    if (final === "~") {
-        const firstParam = body.split(";")[0] ?? "";
-        if (firstParam === "1" || firstParam === "7")
-            return { type: "home" };
-        if (firstParam === "4" || firstParam === "8")
-            return { type: "end" };
-        if (firstParam === "3")
-            return { type: "delete" };
-        if (firstParam === "5")
-            return { type: "scroll-page-up" };
-        if (firstParam === "6")
-            return { type: "scroll-page-down" };
-    }
-    return null;
-}
-function isCsiFinalByte(byte) {
-    return byte >= 0x40 && byte <= 0x7e;
-}
-function parseEscapeSequence(buffer, startIndex) {
-    if (startIndex + 1 >= buffer.length) {
-        return null;
-    }
-    const second = buffer[startIndex + 1] ?? 0;
-    if (second === 0x5b) {
-        let index = startIndex + 2;
-        while (index < buffer.length) {
-            const byte = buffer[index] ?? 0;
-            if (isCsiFinalByte(byte)) {
-                const sequence = buffer.subarray(startIndex, index + 1).toString("latin1");
-                return { action: parseCsiSequence(sequence), nextIndex: index + 1 };
-            }
-            index += 1;
-        }
-        return null;
-    }
-    if (second === 0x4f) {
-        if (startIndex + 2 >= buffer.length) {
-            return null;
-        }
-        const third = buffer[startIndex + 2] ?? 0;
-        if (third === 0x4d) {
-            return { action: { type: "submit" }, nextIndex: startIndex + 3 };
-        }
-        return { action: null, nextIndex: startIndex + 3 };
-    }
-    if (second === 0x0d || second === 0x0a) {
-        return { action: { type: "newline" }, nextIndex: startIndex + 2 };
-    }
-    return { action: null, nextIndex: startIndex + 2 };
-}
-class InputEngine {
-    pending = Buffer.alloc(0);
-    decoder = new node_string_decoder_1.StringDecoder("utf8");
-    reset() {
-        this.pending = Buffer.alloc(0);
-        this.decoder.end();
-    }
-    pushChunk(chunk) {
-        const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "latin1");
-        if (incoming.length === 0) {
-            return [];
-        }
-        this.pending =
-            this.pending.length > 0 ? Buffer.concat([this.pending, incoming]) : Buffer.from(incoming);
-        const actions = [];
-        let index = 0;
-        let textStart = null;
-        const flushText = (endIndex) => {
-            if (textStart === null || endIndex <= textStart) {
-                textStart = null;
-                return;
-            }
-            const text = this.decoder.write(this.pending.subarray(textStart, endIndex));
-            if (text.length > 0) {
-                actions.push({ type: "insert", text });
-            }
-            textStart = null;
-        };
-        while (index < this.pending.length) {
-            const byte = this.pending[index] ?? 0;
-            if (byte === 0x1b) {
-                flushText(index);
-                const parsed = parseEscapeSequence(this.pending, index);
-                if (!parsed) {
-                    break;
-                }
-                if (parsed.action) {
-                    actions.push(parsed.action);
-                }
-                index = parsed.nextIndex;
-                continue;
-            }
-            if (byte === 0x03) {
-                flushText(index);
-                actions.push({ type: "cancel" });
-                index += 1;
-                continue;
-            }
-            if (byte === 0x7f || byte === 0x08) {
-                flushText(index);
-                actions.push({ type: "backspace" });
-                index += 1;
-                continue;
-            }
-            if (byte === 0x0d) {
-                flushText(index);
-                actions.push({ type: "submit" });
-                index += 1;
-                if (this.pending[index] === 0x0a) {
-                    index += 1;
-                }
-                continue;
-            }
-            if (byte === 0x0a) {
-                flushText(index);
-                actions.push({ type: "newline" });
-                index += 1;
-                continue;
-            }
-            if (byte === 0x09) {
-                flushText(index);
-                actions.push({ type: "tab" });
-                index += 1;
-                continue;
-            }
-            if (byte < 0x20) {
-                flushText(index);
-                index += 1;
-                continue;
-            }
-            if (textStart === null) {
-                textStart = index;
-            }
-            index += 1;
-        }
-        // Treat lone ESC as cancel (close modal/back) when it is not part of a CSI sequence.
-        if (index < this.pending.length && this.pending[index] === 0x1b && this.pending.length - index === 1) {
-            actions.push({ type: "cancel" });
-            index += 1;
-        }
-        flushText(index);
-        this.pending = this.pending.subarray(index);
-        return actions;
-    }
-}
-exports.InputEngine = InputEngine;

package/dist/llama-client.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LlamaClient = void 0;
-const CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
-const DEFAULT_TIMEOUT_MS = 30_000;
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/+$/, "");
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function extractFirstChoice(payload) {
-    if (!isRecord(payload)) {
-        return null;
-    }
-    const choices = payload["choices"];
-    if (!Array.isArray(choices) || choices.length === 0) {
-        return null;
-    }
-    const first = choices[0];
-    return isRecord(first) ? first : null;
-}
-function extractMessageContent(choice) {
-    const message = choice["message"];
-    if (isRecord(message) && typeof message["content"] === "string") {
-        return message["content"];
-    }
-    return "";
-}
-function extractDeltaContent(choice) {
-    const delta = choice["delta"];
-    if (isRecord(delta) && typeof delta["content"] === "string") {
-        return delta["content"];
-    }
-    return "";
-}
-function parseStreamLine(line) {
-    if (!line.startsWith("data:")) {
-        return { done: false, token: "" };
-    }
-    const payload = line.slice("data:".length).trim();
-    if (payload.length === 0) {
-        return { done: false, token: "" };
-    }
-    if (payload === "[DONE]") {
-        return { done: true, token: "" };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(payload);
-    }
-    catch {
-        throw new Error(`Failed to parse streaming payload: ${payload.slice(0, 200)}`);
-    }
-    const choice = extractFirstChoice(parsed);
-    const usage = extractUsageTotals(parsed);
-    if (!choice) {
-        return { done: false, token: "", usage };
-    }
-    const token = extractDeltaContent(choice) || extractMessageContent(choice);
-    return { done: false, token, usage };
-}
-function extractUsageTotals(payload) {
-    if (!isRecord(payload)) {
-        return undefined;
-    }
-    const usage = payload["usage"];
-    if (!isRecord(usage)) {
-        return undefined;
-    }
-    const promptTokens = usage["prompt_tokens"];
-    const completionTokens = usage["completion_tokens"];
-    const totalTokens = usage["total_tokens"];
-    if (typeof promptTokens !== "number" ||
-        typeof completionTokens !== "number" ||
-        typeof totalTokens !== "number") {
-        return undefined;
-    }
-    if (promptTokens < 0 || completionTokens < 0 || totalTokens < 0) {
-        return undefined;
-    }
-    return { promptTokens, completionTokens, totalTokens };
-}
-async function readErrorBody(response) {
-    try {
-        return (await response.text()).trim();
-    }
-    catch {
-        return "";
-    }
-}
-class LlamaClient {
-    baseUrl;
-    model;
-    timeoutMs;
-    fetchImpl;
-    constructor(options) {
-        this.baseUrl = normalizeBaseUrl(options.baseUrl);
-        this.model = options.model.trim();
-        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        this.fetchImpl = options.fetchImpl ?? fetch;
-    }
-    setModel(model) {
-        const next = model.trim();
-        if (next.length > 0) {
-            this.model = next;
-        }
-    }
-    getModel() {
-        return this.model;
-    }
-    async chat(messages, model = this.model) {
-        const payload = this.buildPayload(messages, model, false);
-        const response = await this.requestCompletion(payload);
-        const parsed = await response.json();
-        const choice = extractFirstChoice(parsed);
-        if (!choice) {
-            throw new Error("Chat completion response did not include choices.");
-        }
-        const content = extractMessageContent(choice);
-        if (content.length === 0) {
-            throw new Error("Chat completion response did not include assistant content.");
-        }
-        return {
-            text: content,
-            usage: extractUsageTotals(parsed)
-        };
-    }
-    async streamChat(messages, handlers, model = this.model) {
-        const payload = this.buildPayload(messages, model, true);
-        const response = await this.requestCompletion(payload);
-        if (!response.body) {
-            throw new Error("Streaming response body is unavailable.");
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let content = "";
-        let streamDone = false;
-        let usage;
-        try {
-            while (!streamDone) {
-                const { value, done } = await reader.read();
-                if (done) {
-                    break;
-                }
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split(/\r?\n/);
-                buffer = lines.pop() ?? "";
-                for (const line of lines) {
-                    const result = parseStreamLine(line.trim());
-                    if (result.usage) {
-                        usage = result.usage;
-                    }
-                    if (result.token.length > 0) {
-                        content += result.token;
-                        handlers.onToken(result.token);
-                    }
-                    if (result.done) {
-                        streamDone = true;
-                        break;
-                    }
-                }
-            }
-            const finalChunk = decoder.decode();
-            if (finalChunk.length > 0) {
-                buffer += finalChunk;
-            }
-            if (!streamDone && buffer.trim().length > 0) {
-                const result = parseStreamLine(buffer.trim());
-                if (result.usage) {
-                    usage = result.usage;
-                }
-                if (result.token.length > 0) {
-                    content += result.token;
-                    handlers.onToken(result.token);
-                }
-            }
-            return { text: content, usage };
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    buildPayload(messages, model, stream) {
-        return {
-            model: model.trim() || this.model,
-            messages,
-            stream
-        };
-    }
-    async requestCompletion(payload) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-        const endpoint = `${this.baseUrl}${CHAT_COMPLETIONS_PATH}`;
-        let response;
-        try {
-            response = await this.fetchImpl(endpoint, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json"
-                },
-                body: JSON.stringify(payload),
-                signal: controller.signal
-            });
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new Error(`llama.cpp request timed out after ${this.timeoutMs}ms.`);
-            }
-            throw new Error(`Failed to connect to llama.cpp at ${this.baseUrl}: ${toErrorMessage(error)}`);
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        if (!response.ok) {
-            const details = await readErrorBody(response);
-            const suffix = details.length > 0 ? `: ${details}` : "";
-            throw new Error(`llama.cpp request failed (${response.status} ${response.statusText})${suffix}`);
-        }
-        return response;
-    }
-}
-exports.LlamaClient = LlamaClient;