@sheepbun/yips 0.1.1

package/dist/memory-store.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMemory = saveMemory;
+exports.listMemories = listMemories;
+exports.readMemory = readMemory;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const DEFAULT_MEMORY_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".yips", "memories");
+const MEMORY_DIR_ENV = "YIPS_MEMORIES_DIR";
+function resolveMemoryDir() {
+    const override = process.env[MEMORY_DIR_ENV]?.trim();
+    if (override && override.length > 0) {
+        return override;
+    }
+    return DEFAULT_MEMORY_DIR;
+}
+function pad2(value) {
+    return value.toString().padStart(2, "0");
+}
+function toMemoryTimestamp(now) {
+    return [
+        now.getFullYear(),
+        "-",
+        pad2(now.getMonth() + 1),
+        "-",
+        pad2(now.getDate()),
+        "_",
+        pad2(now.getHours()),
+        "-",
+        pad2(now.getMinutes()),
+        "-",
+        pad2(now.getSeconds())
+    ].join("");
+}
+function slugifyTitle(input) {
+    const base = input
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/gu, " ")
+        .trim()
+        .replace(/\s+/gu, "-")
+        .slice(0, 48)
+        .replace(/-+$/gu, "");
+    return base.length > 0 ? base : "memory";
+}
+function normalizeContent(content) {
+    return content.trim().replace(/\r\n/gu, "\n");
+}
+function parseFileStem(path) {
+    const stem = (0, node_path_1.basename)(path, ".md");
+    const splitIndex = stem.indexOf("_");
+    if (splitIndex <= 0) {
+        return { createdAt: new Date(0), slug: stem };
+    }
+    const datePart = stem.slice(0, splitIndex);
+    const remainder = stem.slice(splitIndex + 1);
+    const secondSplit = remainder.indexOf("_");
+    if (secondSplit <= 0) {
+        return { createdAt: new Date(0), slug: stem };
+    }
+    const timePart = remainder.slice(0, secondSplit);
+    const slug = remainder.slice(secondSplit + 1);
+    const timestamp = new Date(`${datePart}T${timePart.replace(/-/gu, ":")}`);
+    if (Number.isNaN(timestamp.valueOf())) {
+        return { createdAt: new Date(0), slug };
+    }
+    return { createdAt: timestamp, slug };
+}
+function extractBody(content) {
+    const marker = "## Memory";
+    const markerIndex = content.indexOf(marker);
+    if (markerIndex < 0) {
+        return content.trim();
+    }
+    return content.slice(markerIndex + marker.length).trim();
+}
+function previewOf(content) {
+    const firstLine = extractBody(content)
+        .split(/\n/gu)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine) {
+        return "(empty memory)";
+    }
+    return firstLine.length > 96 ? `${firstLine.slice(0, 93)}...` : firstLine;
+}
+async function saveMemory(content, now = new Date()) {
+    const normalized = normalizeContent(content);
+    if (normalized.length === 0) {
+        throw new Error("Cannot save empty memory.");
+    }
+    const memoryDir = resolveMemoryDir();
+    await (0, promises_1.mkdir)(memoryDir, { recursive: true });
+    const titleSource = normalized.split(/\n/gu)[0] ?? "memory";
+    const slug = slugifyTitle(titleSource);
+    const id = `${toMemoryTimestamp(now)}_${slug}`;
+    const path = (0, node_path_1.join)(memoryDir, `${id}.md`);
+    const body = [
+        "# Memory",
+        "",
+        `**Created**: ${now.toISOString()}`,
+        "",
+        "## Memory",
+        "",
+        normalized,
+        ""
+    ].join("\n");
+    await (0, promises_1.writeFile)(path, body, "utf8");
+    return {
+        id,
+        path,
+        title: titleSource.trim().slice(0, 96),
+        createdAt: now,
+        preview: previewOf(body)
+    };
+}
+async function listMemories(limit) {
+    const memoryDir = resolveMemoryDir();
+    try {
+        const entries = await (0, promises_1.readdir)(memoryDir, { withFileTypes: true });
+        const files = entries
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+            .map((entry) => (0, node_path_1.join)(memoryDir, entry.name));
+        const loaded = await Promise.all(files.map(async (path) => {
+            const text = await (0, promises_1.readFile)(path, "utf8");
+            const parsed = parseFileStem(path);
+            return {
+                id: (0, node_path_1.basename)(path, ".md"),
+                path,
+                title: parsed.slug.replace(/-/gu, " ").trim() || "memory",
+                createdAt: parsed.createdAt,
+                preview: previewOf(text)
+            };
+        }));
+        const sorted = loaded.sort((left, right) => right.createdAt.valueOf() - left.createdAt.valueOf());
+        return typeof limit === "number" && limit > 0 ? sorted.slice(0, limit) : sorted;
+    }
+    catch {
+        return [];
+    }
+}
+async function readMemory(id) {
+    const normalizedId = id.trim().replace(/\.md$/iu, "");
+    if (normalizedId.length === 0) {
+        throw new Error("Memory id is required.");
+    }
+    const path = (0, node_path_1.join)(resolveMemoryDir(), `${normalizedId}.md`);
+    const text = await (0, promises_1.readFile)(path, "utf8");
+    const parsed = parseFileStem(path);
+    const content = extractBody(text);
+    return {
+        id: normalizedId,
+        path,
+        title: parsed.slug.replace(/-/gu, " ").trim() || "memory",
+        createdAt: parsed.createdAt,
+        preview: previewOf(text),
+        content
+    };
+}

package/dist/messages.js

@@ -0,0 +1,59 @@
+"use strict";
+/** Conversation message formatting with ANSI truecolor styling. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUserMessage = formatUserMessage;
+exports.formatAssistantMessage = formatAssistantMessage;
+exports.formatErrorMessage = formatErrorMessage;
+exports.formatWarningMessage = formatWarningMessage;
+exports.formatSuccessMessage = formatSuccessMessage;
+exports.formatDimMessage = formatDimMessage;
+const colors_1 = require("./colors");
+function formatTimestamp(date) {
+    const hours = date.getHours();
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    const period = hours >= 12 ? "PM" : "AM";
+    const displayHours = hours % 12 || 12;
+    return `${displayHours}:${minutes} ${period}`;
+}
+function formatUserMessage(text) {
+    const lines = text.split("\n");
+    const first = (0, colors_1.colorText)(`>>> ${lines[0] ?? ""}`, colors_1.INPUT_PINK);
+    if (lines.length <= 1) {
+        return first;
+    }
+    const rest = lines.slice(1).map((line) => (0, colors_1.colorText)(line, colors_1.INPUT_PINK));
+    return [first, ...rest].join("\n");
+}
+function formatAssistantMessage(text, timestamp) {
+    const time = timestamp ?? new Date();
+    const timestampPlain = `[${formatTimestamp(time)}]`;
+    const namePlain = "Yips";
+    const prefixPlain = `${timestampPlain} ${namePlain}: `;
+    const timeStr = (0, colors_1.colorText)(timestampPlain, colors_1.GRADIENT_BLUE);
+    const name = (0, colors_1.horizontalGradient)(namePlain, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    const colon = (0, colors_1.colorText)(":", colors_1.GRADIENT_BLUE);
+    const lines = text.split("\n");
+    const firstLine = lines[0] ?? "";
+    const firstBody = (0, colors_1.horizontalGradient)(firstLine, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    const first = `${timeStr} ${name}${colon} ${firstBody}`;
+    if (lines.length <= 1) {
+        return first;
+    }
+    const indent = " ".repeat(prefixPlain.length);
+    const rest = lines
+        .slice(1)
+        .map((line) => `${indent}${(0, colors_1.horizontalGradient)(line, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}`);
+    return [first, ...rest].join("\n");
+}
+function formatErrorMessage(text) {
+    return (0, colors_1.colorText)(text, colors_1.ERROR_RED);
+}
+function formatWarningMessage(text) {
+    return (0, colors_1.colorText)(text, colors_1.WARNING_YELLOW);
+}
+function formatSuccessMessage(text) {
+    return (0, colors_1.colorText)(text, colors_1.SUCCESS_GREEN);
+}
+function formatDimMessage(text) {
+    return (0, colors_1.colorText)(text, colors_1.DIM_GRAY);
+}

package/dist/model-downloader.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDefaultModelsDir = resolveDefaultModelsDir;
+exports.isHfDownloadUrl = isHfDownloadUrl;
+exports.parseHfDownloadUrl = parseHfDownloadUrl;
+exports.listGgufModels = listGgufModels;
+exports.listModelFiles = listModelFiles;
+exports.downloadModelFile = downloadModelFile;
+exports.renderModelList = renderModelList;
+exports.renderFileList = renderFileList;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function encodePath(path) {
+    return path
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+function toPositiveInt(value, fallback = 0) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function toDateText(value) {
+    if (typeof value !== "string") {
+        return "unknown";
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : "unknown";
+}
+function safeRelativePath(path) {
+    const normalized = (0, node_path_1.normalize)(path).replace(/^[\\/]+/u, "");
+    const segments = normalized.split(/[\\/]/u).filter((segment) => segment.length > 0);
+    if (segments.some((segment) => segment === "..")) {
+        throw new Error(`Unsafe filename: ${path}`);
+    }
+    if (segments.length === 0) {
+        throw new Error("Filename cannot be empty.");
+    }
+    return segments.join("/");
+}
+function extractSizeBytes(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const source = value;
+    const direct = source.total;
+    if (typeof direct === "number" && Number.isFinite(direct) && direct > 0) {
+        return direct;
+    }
+    const lfs = source.lfs;
+    if (typeof lfs === "object" && lfs !== null) {
+        const lfsSize = lfs.size;
+        if (typeof lfsSize === "number" && Number.isFinite(lfsSize) && lfsSize > 0) {
+            return lfsSize;
+        }
+    }
+    return null;
+}
+function evaluateSuitability(sizeBytes, totalMemoryGb) {
+    if (sizeBytes === null) {
+        return { canRun: true, reason: "Unknown size" };
+    }
+    if (typeof totalMemoryGb !== "number" || !Number.isFinite(totalMemoryGb) || totalMemoryGb <= 0) {
+        return { canRun: true, reason: "No memory limit" };
+    }
+    const memoryLimitMultiplier = 1.2;
+    const sizeGb = sizeBytes / (1024 * 1024 * 1024);
+    const effectiveLimit = totalMemoryGb * memoryLimitMultiplier;
+    if (sizeGb <= effectiveLimit) {
+        return { canRun: true, reason: "Fits RAM+VRAM" };
+    }
+    return {
+        canRun: false,
+        reason: `Model too large (${sizeGb.toFixed(1)}GB > ${effectiveLimit.toFixed(1)}GB)`
+    };
+}
+function extractQuant(path) {
+    const upper = path.toUpperCase();
+    if (upper.includes("Q4_K_M"))
+        return "Q4_K_M (Balanced)";
+    if (upper.includes("Q5_K_M"))
+        return "Q5_K_M (High Quality)";
+    if (upper.includes("Q8_0"))
+        return "Q8_0 (Max Quality)";
+    if (upper.includes("Q2_K"))
+        return "Q2_K (Max Speed)";
+    const match = upper.match(/(Q\d+_[A-Z0-9_]+)/u);
+    return match?.[1] ?? "Unknown";
+}
+async function readJson(response) {
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+function getFetch(fetchImpl) {
+    return fetchImpl ?? fetch;
+}
+function resolveDefaultModelsDir() {
+    const env = process.env["YIPS_MODELS_DIR"]?.trim();
+    if (env && env.length > 0) {
+        return env;
+    }
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".yips", "models");
+}
+function isHfDownloadUrl(input) {
+    try {
+        parseHfDownloadUrl(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseHfDownloadUrl(input) {
+    const raw = input.trim();
+    if (raw.length === 0) {
+        throw new Error("URL is required.");
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error("Invalid URL.");
+    }
+    const host = url.hostname.toLowerCase();
+    if (host !== "hf.co" && host !== "huggingface.co" && host !== "www.huggingface.co") {
+        throw new Error("URL must be from hf.co or huggingface.co.");
+    }
+    const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
+    if (segments.length < 5) {
+        throw new Error("URL must include /<owner>/<repo>/resolve/<revision>/<file>.gguf");
+    }
+    const resolveIndex = segments.findIndex((segment) => segment === "resolve");
+    if (resolveIndex !== 2 || segments.length < 5) {
+        throw new Error("URL must include /<owner>/<repo>/resolve/<revision>/<file>.gguf");
+    }
+    const owner = segments[0] ?? "";
+    const repo = segments[1] ?? "";
+    const revision = segments[3] ?? "main";
+    const filenameSegments = segments.slice(4);
+    const filename = filenameSegments.join("/");
+    if (!filename.toLowerCase().endsWith(".gguf")) {
+        throw new Error("URL must point to a .gguf file.");
+    }
+    return {
+        repoId: `${owner}/${repo}`,
+        revision,
+        filename
+    };
+}
+async function listGgufModels(options) {
+    const query = options?.query?.trim() ?? "";
+    const sort = options?.sort ?? "downloads";
+    const limit = Math.max(1, Math.min(100, options?.limit ?? 10));
+    const requestModels = async (expanded) => {
+        const url = new URL("https://huggingface.co/api/models");
+        url.searchParams.set("filter", "gguf");
+        url.searchParams.set("sort", sort);
+        url.searchParams.set("limit", String(limit));
+        if (expanded) {
+            url.searchParams.append("expand", "downloads");
+            url.searchParams.append("expand", "likes");
+            url.searchParams.append("expand", "lastModified");
+            url.searchParams.append("expand", "gguf");
+        }
+        if (query.length > 0) {
+            url.searchParams.set("search", query);
+        }
+        const response = await getFetch(options?.fetchImpl)(url);
+        return readJson(response);
+    };
+    let data;
+    try {
+        data = await requestModels(true);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("HTTP 400") && !message.includes("HTTP 422")) {
+            throw error;
+        }
+        data = await requestModels(false);
+    }
+    return data
+        .map((item) => {
+        if (typeof item !== "object" || item === null) {
+            return null;
+        }
+        const model = item;
+        const id = typeof model.id === "string" ? model.id : "";
+        if (id.trim().length === 0) {
+            return null;
+        }
+        const sizeBytes = extractSizeBytes(model.gguf);
+        const suitability = evaluateSuitability(sizeBytes, options?.totalMemoryGb);
+        return {
+            id,
+            downloads: toPositiveInt(model.downloads),
+            likes: toPositiveInt(model.likes),
+            lastModified: toDateText(model.lastModified),
+            sizeBytes,
+            canRun: suitability.canRun,
+            reason: suitability.reason
+        };
+    })
+        .filter((entry) => entry !== null)
+        .filter((entry) => entry.canRun || entry.sizeBytes === null);
+}
+async function listModelFiles(repoId, options) {
+    const trimmedRepo = repoId.trim();
+    if (trimmedRepo.length === 0) {
+        throw new Error("Repository id is required.");
+    }
+    const encodedRepo = encodePath(trimmedRepo);
+    const url = new URL(`https://huggingface.co/api/models/${encodedRepo}`);
+    url.searchParams.set("blobs", "true");
+    const response = await getFetch(options?.fetchImpl)(url);
+    const data = await readJson(response);
+    const siblingsValue = data.siblings;
+    const siblings = Array.isArray(siblingsValue) ? siblingsValue : [];
+    const files = siblings
+        .map((item) => {
+        if (typeof item !== "object" || item === null) {
+            return null;
+        }
+        const file = item;
+        const path = typeof file.rfilename === "string" ? file.rfilename : "";
+        if (!path.toLowerCase().endsWith(".gguf")) {
+            return null;
+        }
+        const sizeBytes = extractSizeBytes(file.size ?? file.lfs ?? null);
+        const suitability = evaluateSuitability(sizeBytes, options?.totalMemoryGb);
+        return {
+            path,
+            sizeBytes,
+            quant: extractQuant(path),
+            canRun: suitability.canRun,
+            reason: suitability.reason
+        };
+    })
+        .filter((entry) => entry !== null);
+    files.sort((left, right) => {
+        const leftSize = left.sizeBytes ?? Number.MAX_SAFE_INTEGER;
+        const rightSize = right.sizeBytes ?? Number.MAX_SAFE_INTEGER;
+        if (leftSize !== rightSize) {
+            return leftSize - rightSize;
+        }
+        return left.path.localeCompare(right.path);
+    });
+    return files;
+}
+async function downloadModelFile(options) {
+    const repoId = options.repoId.trim();
+    if (repoId.length === 0) {
+        throw new Error("Repository id is required.");
+    }
+    const safeFilename = safeRelativePath(options.filename.trim());
+    const modelsDir = options.modelsDir?.trim() || resolveDefaultModelsDir();
+    const repoPath = safeRelativePath(repoId);
+    const outputPath = (0, node_path_1.resolve)(modelsDir, repoPath, safeFilename);
+    const revision = options.revision?.trim() || "main";
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(outputPath), { recursive: true });
+    let byteCount = 0;
+    let completed = false;
+    try {
+        const fileUrl = `https://huggingface.co/${encodePath(repoId)}/resolve/${encodeURIComponent(revision)}/` +
+            `${encodePath(safeFilename)}?download=true`;
+        const response = await getFetch(options.fetchImpl)(fileUrl, { signal: options.signal });
+        if (!response.ok) {
+            throw new Error(`Download failed with HTTP ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error("Download failed: response body is empty.");
+        }
+        const contentLengthHeader = response.headers.get("content-length");
+        const parsedLength = contentLengthHeader
+            ? Number.parseInt(contentLengthHeader, 10)
+            : Number.NaN;
+        const totalBytes = Number.isFinite(parsedLength) && parsedLength > 0 ? parsedLength : null;
+        const emitProgress = (bytesDownloaded) => {
+            if (!options.onProgress) {
+                return;
+            }
+            options.onProgress({
+                bytesDownloaded,
+                totalBytes
+            });
+        };
+        emitProgress(byteCount);
+        await new Promise((resolvePromise, rejectPromise) => {
+            const writer = (0, node_fs_1.createWriteStream)(outputPath);
+            writer.on("error", rejectPromise);
+            writer.on("finish", resolvePromise);
+            const reader = response.body?.getReader();
+            if (!reader) {
+                writer.destroy(new Error("Download failed: could not create stream reader."));
+                return;
+            }
+            const pump = async () => {
+                try {
+                    let reading = true;
+                    while (reading) {
+                        const chunk = await reader.read();
+                        if (chunk.done) {
+                            writer.end();
+                            reading = false;
+                            continue;
+                        }
+                        const value = chunk.value;
+                        byteCount += value.byteLength;
+                        emitProgress(byteCount);
+                        if (!writer.write(Buffer.from(value))) {
+                            await new Promise((drainResolve) => {
+                                writer.once("drain", drainResolve);
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    writer.destroy(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            void pump();
+        });
+        emitProgress(byteCount);
+        completed = true;
+        return { localPath: outputPath, byteCount };
+    }
+    catch (error) {
+        if (!completed) {
+            try {
+                await (0, promises_1.rm)(outputPath, { force: true });
+            }
+            catch {
+                // Preserve the original download error when cleanup fails.
+            }
+        }
+        throw error;
+    }
+}
+function formatCount(value) {
+    if (value >= 1_000_000) {
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    }
+    if (value >= 1_000) {
+        return `${(value / 1_000).toFixed(1)}k`;
+    }
+    return String(value);
+}
+function formatSize(bytes) {
+    if (bytes === null || bytes <= 0) {
+        return "unknown";
+    }
+    const gib = bytes / (1024 * 1024 * 1024);
+    return `${gib.toFixed(2)} GB`;
+}
+function renderModelList(models) {
+    if (models.length === 0) {
+        return "No GGUF models found.";
+    }
+    const rows = models.map((model, index) => {
+        const date = model.lastModified === "unknown" ? "unknown" : model.lastModified.slice(0, 10);
+        return `${index + 1}. ${model.id}  (downloads ${formatCount(model.downloads)}, likes ${formatCount(model.likes)}, size ${formatSize(model.sizeBytes)}, updated ${date})`;
+    });
+    return rows.join("\n");
+}
+function renderFileList(files) {
+    if (files.length === 0) {
+        return "No GGUF files found for this repository.";
+    }
+    return files
+        .map((file, index) => `${index + 1}. ${file.path}  (${formatSize(file.sizeBytes)}, ${file.quant}, ${file.reason})`)
+        .join("\n");
+}