@sheepbun/yips 0.1.1

package/dist/model-manager-state.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelManagerState = createModelManagerState;
+exports.setModelManagerLoading = setModelManagerLoading;
+exports.setModelManagerError = setModelManagerError;
+exports.setModelManagerModels = setModelManagerModels;
+exports.setModelManagerSearchQuery = setModelManagerSearchQuery;
+exports.moveModelManagerSelection = moveModelManagerSelection;
+exports.removeModelById = removeModelById;
+exports.getSelectedModel = getSelectedModel;
+const model_manager_1 = require("./model-manager");
+function createModelManagerState(memory) {
+    return {
+        isOpen: true,
+        searchQuery: "",
+        allModels: [],
+        models: [],
+        selectedModelIndex: 0,
+        scrollOffset: 0,
+        phase: "idle",
+        loading: false,
+        loadingMessage: "Loading models...",
+        errorMessage: "",
+        ramGb: memory.ramGb,
+        vramGb: memory.vramGb,
+        totalMemoryGb: memory.totalMemoryGb
+    };
+}
+function clampSelection(state) {
+    const max = Math.max(0, state.models.length - 1);
+    const selectedModelIndex = Math.min(Math.max(0, state.selectedModelIndex), max);
+    const scrollOffset = Math.min(Math.max(0, state.scrollOffset), Math.max(0, max));
+    return {
+        ...state,
+        selectedModelIndex,
+        scrollOffset
+    };
+}
+function setModelManagerLoading(state, message) {
+    return {
+        ...state,
+        phase: "loading",
+        loading: true,
+        loadingMessage: message,
+        errorMessage: ""
+    };
+}
+function setModelManagerError(state, message) {
+    return {
+        ...state,
+        phase: "error",
+        loading: false,
+        errorMessage: message
+    };
+}
+function setModelManagerModels(state, models) {
+    const filtered = (0, model_manager_1.filterModels)(models, state.searchQuery);
+    return clampSelection({
+        ...state,
+        allModels: models,
+        models: filtered,
+        phase: "idle",
+        loading: false,
+        errorMessage: "",
+        selectedModelIndex: filtered.length > 0 ? Math.min(state.selectedModelIndex, filtered.length - 1) : 0,
+        scrollOffset: 0
+    });
+}
+function setModelManagerSearchQuery(state, searchQuery) {
+    const models = (0, model_manager_1.filterModels)(state.allModels, searchQuery);
+    return clampSelection({
+        ...state,
+        searchQuery,
+        models,
+        selectedModelIndex: models.length > 0 ? Math.min(state.selectedModelIndex, models.length - 1) : 0,
+        scrollOffset: 0,
+        phase: state.phase === "error" ? "idle" : state.phase,
+        errorMessage: state.phase === "error" ? "" : state.errorMessage
+    });
+}
+function moveModelManagerSelection(state, delta, viewportSize) {
+    if (state.models.length === 0) {
+        return state;
+    }
+    const max = state.models.length - 1;
+    const nextIndex = Math.min(max, Math.max(0, state.selectedModelIndex + delta));
+    let nextScroll = state.scrollOffset;
+    if (nextIndex < nextScroll) {
+        nextScroll = nextIndex;
+    }
+    else if (nextIndex >= nextScroll + viewportSize) {
+        nextScroll = nextIndex - (viewportSize - 1);
+    }
+    return {
+        ...state,
+        selectedModelIndex: nextIndex,
+        scrollOffset: Math.max(0, nextScroll)
+    };
+}
+function removeModelById(state, id) {
+    const allModels = state.allModels.filter((model) => model.id !== id);
+    const models = (0, model_manager_1.filterModels)(allModels, state.searchQuery);
+    return clampSelection({
+        ...state,
+        allModels,
+        models,
+        selectedModelIndex: models.length > 0 ? Math.min(state.selectedModelIndex, models.length - 1) : 0,
+        phase: "idle",
+        loading: false,
+        errorMessage: ""
+    });
+}
+function getSelectedModel(state) {
+    if (state.models.length === 0) {
+        return null;
+    }
+    return state.models[state.selectedModelIndex] ?? null;
+}

package/dist/model-manager-ui.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderModelManagerLines = renderModelManagerLines;
+const colors_1 = require("./colors");
+const TAB_INACTIVE = { r: 0x88, g: 0x88, b: 0x88 };
+const BLACK = { r: 0x00, g: 0x00, b: 0x00 };
+const CURRENT_MODEL_BLUE = { r: 0x89, g: 0xcf, b: 0xf0 };
+const FOCUS_ACCENT_BG = { r: 0xff, g: 0xcc, b: 0xff };
+const MODEL_MANAGER_BODY_ROWS = 12;
+const ANSI_BOLD_ON = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+function charLength(text) {
+    return Array.from((0, colors_1.stripAnsi)(text)).length;
+}
+function fitLeft(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    if (width <= 3) {
+        return chars.slice(0, width).join("");
+    }
+    return `${chars.slice(0, width - 3).join("")}...`;
+}
+function fitRight(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    return chars.slice(chars.length - width).join("");
+}
+function makeBorderTop(width) {
+    if (width <= 1)
+        return "╭";
+    const prefix = "╭─── ";
+    const titleBrand = "Yips";
+    const titleDetail = " Model Manager";
+    const titleTail = " ";
+    const prefixLen = charLength(prefix);
+    const titleBrandLen = charLength(titleBrand);
+    const titleDetailLen = charLength(titleDetail);
+    const titleTailLen = charLength(titleTail);
+    const plainTitleLen = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const fill = "─".repeat(Math.max(0, width - plainTitleLen - 1));
+    const fillOffset = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const cornerOffset = width - 1;
+    return `${(0, colors_1.horizontalGradientAtOffset)(prefix, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, 0, width)}${ANSI_BOLD_ON}${(0, colors_1.horizontalGradient)(titleBrand, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)(titleDetail, colors_1.GRADIENT_BLUE)}${ANSI_BOLD_OFF}${(0, colors_1.horizontalGradientAtOffset)(titleTail, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, prefixLen + titleBrandLen + titleDetailLen, width)}${(0, colors_1.horizontalGradientAtOffset)(fill, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, fillOffset, width)}${(0, colors_1.horizontalGradientAtOffset)("╮", colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, cornerOffset, width)}`;
+}
+function makeBorderBottom(width) {
+    if (width <= 1)
+        return "╰";
+    const mid = "─".repeat(Math.max(0, width - 2));
+    return `${(0, colors_1.colorText)("╰", colors_1.GRADIENT_PINK)}${(0, colors_1.horizontalGradient)(mid, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)("╯", colors_1.GRADIENT_YELLOW)}`;
+}
+function lineWithBorders(inner, innerWidth) {
+    let fitted = inner;
+    if (charLength(fitted) > innerWidth) {
+        fitted = fitLeft((0, colors_1.stripAnsi)(inner), innerWidth);
+    }
+    const padding = " ".repeat(Math.max(0, innerWidth - charLength(fitted)));
+    return `${(0, colors_1.colorText)("│", colors_1.GRADIENT_PINK)}${fitted}${padding}${(0, colors_1.colorText)("│", colors_1.GRADIENT_YELLOW)}`;
+}
+function highlightedRow(row) {
+    const chars = Array.from(row);
+    if (chars.length === 0)
+        return row;
+    const first = (0, colors_1.bgColorText)(chars[0] ?? "", FOCUS_ACCENT_BG, BLACK);
+    const rest = chars.slice(1).join("");
+    if (rest.length === 0) {
+        return first;
+    }
+    return `${first}${(0, colors_1.horizontalGradientBackground)(rest, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, BLACK)}`;
+}
+function toSizeCell(sizeGb) {
+    return `${sizeGb.toFixed(1)}G`;
+}
+function getFileName(modelId) {
+    const parts = modelId.split("/");
+    return parts[parts.length - 1] ?? modelId;
+}
+function buildModelRows(state, contentWidth, rowCount, currentModel) {
+    if (state.models.length === 0) {
+        return [(0, colors_1.colorText)("No models found in local models directory.", colors_1.WARNING_YELLOW)];
+    }
+    const markerWidth = 3;
+    const separators = 4 * 3;
+    const minBackendWidth = 9;
+    const minProviderWidth = 14;
+    const minNameWidth = 16;
+    const minFileWidth = 18;
+    const minSizeWidth = 7;
+    let backendWidth = minBackendWidth;
+    let providerWidth = minProviderWidth;
+    let nameWidth = minNameWidth;
+    let fileWidth = minFileWidth;
+    let sizeWidth = minSizeWidth;
+    const minimumTotalColumnWidth = minBackendWidth + minProviderWidth + minNameWidth + minFileWidth + minSizeWidth;
+    const availableTotalColumnWidth = Math.max(5, contentWidth - markerWidth - separators);
+    if (availableTotalColumnWidth >= minimumTotalColumnWidth) {
+        const extra = availableTotalColumnWidth - minimumTotalColumnWidth;
+        const growBy = Math.floor(extra / 5);
+        const remainder = extra % 5;
+        backendWidth += growBy + (remainder > 0 ? 1 : 0);
+        providerWidth += growBy + (remainder > 1 ? 1 : 0);
+        nameWidth += growBy + (remainder > 2 ? 1 : 0);
+        fileWidth += growBy + (remainder > 3 ? 1 : 0);
+        sizeWidth += growBy;
+    }
+    else {
+        const minAllowed = [4, 6, 8, 8, 4];
+        const widths = [
+            backendWidth,
+            providerWidth,
+            nameWidth,
+            fileWidth,
+            sizeWidth
+        ];
+        const reduceOrder = [3, 2, 1, 0, 4];
+        let deficit = minimumTotalColumnWidth - availableTotalColumnWidth;
+        while (deficit > 0) {
+            let reducedThisPass = false;
+            for (const index of reduceOrder) {
+                if (deficit <= 0) {
+                    break;
+                }
+                if (widths[index] > minAllowed[index]) {
+                    widths[index] -= 1;
+                    deficit -= 1;
+                    reducedThisPass = true;
+                }
+            }
+            if (!reducedThisPass) {
+                break;
+            }
+        }
+        [backendWidth, providerWidth, nameWidth, fileWidth, sizeWidth] = widths;
+    }
+    const rows = [];
+    const header = `   ${"Backend".padEnd(backendWidth, " ")} | ${"Provider".padEnd(providerWidth, " ")} | ${"Name".padEnd(nameWidth, " ")} | ${"File".padEnd(fileWidth, " ")} | ${"Size".padStart(sizeWidth, " ")}`;
+    rows.push((0, colors_1.horizontalGradient)(header, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW));
+    const visibleRowCount = Math.max(0, rowCount - 1);
+    const start = state.scrollOffset;
+    const end = Math.min(state.models.length, start + visibleRowCount);
+    for (let index = start; index < end; index++) {
+        const model = state.models[index];
+        if (!model)
+            continue;
+        const selected = index === state.selectedModelIndex;
+        const current = model.id === currentModel;
+        const prefix = `${selected ? ">" : " "}${current ? "*" : " "} `;
+        const backend = fitLeft(model.friendlyBackend, backendWidth).padEnd(backendWidth, " ");
+        const provider = fitLeft(model.host, providerWidth).padEnd(providerWidth, " ");
+        const name = fitLeft(model.friendlyName, nameWidth).padEnd(nameWidth, " ");
+        const file = fitLeft(getFileName(model.id), fileWidth).padEnd(fileWidth, " ");
+        const sizeCell = toSizeCell(model.sizeGb).padStart(sizeWidth, " ");
+        const row = `${prefix}${backend} | ${provider} | ${name} | ${file} | ${sizeCell}`;
+        if (selected) {
+            rows.push(highlightedRow(row));
+            continue;
+        }
+        rows.push(current ? (0, colors_1.colorText)(row, CURRENT_MODEL_BLUE) : row);
+    }
+    return rows;
+}
+function fillRows(rows, rowCount) {
+    if (rows.length >= rowCount) {
+        return rows.slice(0, rowCount);
+    }
+    return [...rows, ...new Array(rowCount - rows.length).fill("")];
+}
+function renderModelManagerLines(options) {
+    const width = Math.max(20, options.width);
+    const innerWidth = Math.max(1, width - 2);
+    const rows = [];
+    rows.push(makeBorderTop(width));
+    const leftLabel = (0, colors_1.colorText)(" Local ", TAB_INACTIVE);
+    const specText = `RAM: ${options.state.ramGb.toFixed(1)}GB | VRAM: ${options.state.vramGb.toFixed(1)}GB`;
+    const gap = Math.max(1, innerWidth - charLength(leftLabel) - charLength(specText));
+    rows.push(lineWithBorders(`${leftLabel}${" ".repeat(gap)}${fitRight(specText, Math.max(1, innerWidth - charLength(leftLabel) - 1))}`, innerWidth));
+    let bodyRows;
+    if (options.state.phase === "loading") {
+        bodyRows = fillRows([`Loading: ${options.state.loadingMessage}`], MODEL_MANAGER_BODY_ROWS);
+    }
+    else if (options.state.phase === "error" && options.state.errorMessage.length > 0) {
+        bodyRows = fillRows([`Error: ${options.state.errorMessage}`], MODEL_MANAGER_BODY_ROWS);
+    }
+    else {
+        bodyRows = fillRows(buildModelRows(options.state, innerWidth, MODEL_MANAGER_BODY_ROWS, options.currentModel), MODEL_MANAGER_BODY_ROWS);
+    }
+    rows.push(...bodyRows.map((row) => lineWithBorders(row, innerWidth)));
+    rows.push(lineWithBorders((0, colors_1.horizontalGradient)("[Enter] Select  [↑/↓] Move  [Del] Delete Local  [T] Downloader  [Esc] Close", colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW), innerWidth));
+    rows.push(makeBorderBottom(width));
+    return rows;
+}

package/dist/model-manager.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelDisplayName = getModelDisplayName;
+exports.getFriendlyModelName = getFriendlyModelName;
+exports.listLocalModels = listLocalModels;
+exports.filterModels = filterModels;
+exports.findMatchingModel = findMatchingModel;
+exports.selectBestModelForHardware = selectBestModelForHardware;
+exports.deleteLocalModel = deleteLocalModel;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const model_downloader_1 = require("./model-downloader");
+const MEMORY_LIMIT_MULTIPLIER = 1.2;
+function evaluateSuitability(sizeBytes, totalMemoryGb) {
+    if (typeof totalMemoryGb !== "number" || !Number.isFinite(totalMemoryGb) || totalMemoryGb <= 0) {
+        return { canRun: true, reason: "No memory limit" };
+    }
+    const sizeGb = sizeBytes / 1024 ** 3;
+    const effectiveLimit = totalMemoryGb * MEMORY_LIMIT_MULTIPLIER;
+    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 getModelDisplayName(modelId) {
+    const normalizedId = modelId.replace(/\\/gu, "/");
+    const segments = normalizedId.split("/").filter((segment) => segment.length > 0);
+    const filename = (0, node_path_1.basename)(modelId);
+    if (filename.toLowerCase().endsWith(".gguf")) {
+        const parent = segments.length > 1 ? (segments[segments.length - 2] ?? "") : "";
+        if (parent.length > 0) {
+            return parent;
+        }
+        return filename.slice(0, -5);
+    }
+    return filename;
+}
+function getFriendlyModelName(modelId, nicknames) {
+    const exact = nicknames[modelId];
+    if (typeof exact === "string" && exact.trim().length > 0) {
+        return exact.trim();
+    }
+    const fallback = getModelDisplayName(modelId);
+    const byFilename = nicknames[fallback];
+    if (typeof byFilename === "string" && byFilename.trim().length > 0) {
+        return byFilename.trim();
+    }
+    const filename = (0, node_path_1.basename)(modelId);
+    if (filename.toLowerCase().endsWith(".gguf")) {
+        const filenameStem = filename.slice(0, -5);
+        const byStem = nicknames[filenameStem];
+        if (typeof byStem === "string" && byStem.trim().length > 0) {
+            return byStem.trim();
+        }
+    }
+    return fallback;
+}
+async function collectGgufPaths(root, base = root) {
+    const entries = await (0, promises_1.readdir)(root, { withFileTypes: true });
+    const paths = [];
+    for (const entry of entries) {
+        const absolutePath = (0, node_path_1.join)(root, entry.name);
+        if (entry.isDirectory()) {
+            paths.push(...(await collectGgufPaths(absolutePath, base)));
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if ((0, node_path_1.extname)(entry.name).toLowerCase() !== ".gguf") {
+            continue;
+        }
+        const rel = (0, node_path_1.relative)(base, absolutePath).replace(/\\/gu, "/");
+        paths.push(rel);
+    }
+    return paths;
+}
+async function listLocalModels(options) {
+    const modelsDir = (0, node_path_1.resolve)(options?.modelsDir?.trim() || (0, model_downloader_1.resolveDefaultModelsDir)());
+    const nicknames = options?.nicknames ?? {};
+    let modelIds = [];
+    try {
+        modelIds = await collectGgufPaths(modelsDir);
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    for (const modelId of modelIds.sort((left, right) => left.localeCompare(right))) {
+        const path = (0, node_path_1.join)(modelsDir, modelId);
+        let sizeBytes = 0;
+        try {
+            const stats = await (0, promises_1.stat)(path);
+            sizeBytes = stats.isFile() ? stats.size : 0;
+        }
+        catch {
+            continue;
+        }
+        const parts = modelId.split("/");
+        const host = parts.length > 1 ? (parts[0] ?? "Local") : "Local";
+        const suitability = evaluateSuitability(sizeBytes, options?.totalMemoryGb);
+        rows.push({
+            id: modelId,
+            name: getModelDisplayName(modelId),
+            friendlyName: getFriendlyModelName(modelId, nicknames),
+            host,
+            backend: "llamacpp",
+            friendlyBackend: "llama.cpp",
+            sizeBytes,
+            sizeGb: sizeBytes / 1024 ** 3,
+            canRun: suitability.canRun,
+            reason: suitability.reason,
+            path
+        });
+    }
+    return rows;
+}
+function filterModels(models, query) {
+    const trimmed = query.trim().toLowerCase();
+    if (trimmed.length === 0) {
+        return [...models];
+    }
+    return models.filter((model) => [model.id, model.name, model.friendlyName, model.host].some((value) => value.toLowerCase().includes(trimmed)));
+}
+function findMatchingModel(models, input) {
+    const needle = input.trim().toLowerCase();
+    if (needle.length === 0) {
+        return null;
+    }
+    const exact = models.find((model) => model.id.toLowerCase() === needle ||
+        model.name.toLowerCase() === needle ||
+        (0, node_path_1.basename)(model.id).toLowerCase() === needle);
+    if (exact) {
+        return exact;
+    }
+    const partial = models.find((model) => model.id.toLowerCase().includes(needle) ||
+        model.name.toLowerCase().includes(needle) ||
+        (0, node_path_1.basename)(model.id).toLowerCase().includes(needle));
+    return partial ?? null;
+}
+function byLargestSize(left, right) {
+    if (left.sizeBytes !== right.sizeBytes) {
+        return right.sizeBytes - left.sizeBytes;
+    }
+    return left.id.localeCompare(right.id);
+}
+function selectBestModelForHardware(models, specs) {
+    const runnable = models.filter((model) => model.canRun);
+    if (runnable.length === 0) {
+        return null;
+    }
+    const vramBytes = Number.isFinite(specs.vramGb) && specs.vramGb > 0 ? specs.vramGb * 1024 ** 3 : 0;
+    if (vramBytes > 0) {
+        const gpuFit = runnable.filter((model) => model.sizeBytes <= vramBytes);
+        if (gpuFit.length > 0) {
+            return [...gpuFit].sort(byLargestSize)[0] ?? null;
+        }
+    }
+    return [...runnable].sort(byLargestSize)[0] ?? null;
+}
+async function pruneEmptyParents(path, root) {
+    let current = (0, node_path_1.dirname)(path);
+    const normalizedRoot = (0, node_path_1.resolve)(root);
+    while (current.startsWith(normalizedRoot) && current !== normalizedRoot) {
+        try {
+            const entries = await (0, promises_1.readdir)(current);
+            if (entries.length > 0) {
+                return;
+            }
+            await (0, promises_1.rmdir)(current);
+            current = (0, node_path_1.dirname)(current);
+        }
+        catch {
+            return;
+        }
+    }
+}
+async function deleteLocalModel(model, options) {
+    const modelsDir = (0, node_path_1.resolve)(options?.modelsDir?.trim() || (0, model_downloader_1.resolveDefaultModelsDir)());
+    const modelPath = (0, node_path_1.resolve)(model.path);
+    const expectedPrefix = `${modelsDir}${node_path_1.sep}`;
+    if (modelPath !== modelsDir && !modelPath.startsWith(expectedPrefix)) {
+        throw new Error("Refusing to delete model outside models directory.");
+    }
+    await (0, promises_1.unlink)(modelPath);
+    await pruneEmptyParents(modelPath, modelsDir);
+}

package/dist/models/hardware.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSystemSpecs = getSystemSpecs;
+exports.clearSystemSpecsCache = clearSystemSpecsCache;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_fs_2 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_fs_3 = require("node:fs");
+function roundOne(value) {
+    return Math.round(value * 10) / 10;
+}
+function getRamGb() {
+    return roundOne((0, node_os_1.totalmem)() / (1024 ** 3));
+}
+function getNvidiaVramGb() {
+    try {
+        const result = (0, node_child_process_1.execFileSync)("nvidia-smi", ["--query-gpu=memory.total", "--format=csv,noheader,nounits"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const totalMb = result
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => Number(line))
+            .filter((value) => Number.isFinite(value) && value > 0)
+            .reduce((sum, value) => sum + value, 0);
+        return totalMb > 0 ? roundOne(totalMb / 1024) : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function getAmdVramGb() {
+    try {
+        const paths = (0, node_fs_2.globSync)("/sys/class/drm/card*/device/mem_info_vram_total");
+        if (paths.length === 0) {
+            return 0;
+        }
+        const totalBytes = paths
+            .map((path) => (0, node_fs_1.readFileSync)(path, "utf8").trim())
+            .map((value) => Number(value))
+            .filter((value) => Number.isFinite(value) && value > 0)
+            .reduce((sum, value) => sum + value, 0);
+        return totalBytes > 0 ? roundOne(totalBytes / (1024 ** 3)) : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function getModelsDir() {
+    const override = process.env["YIPS_MODELS_DIR"]?.trim();
+    if (override && override.length > 0) {
+        return override;
+    }
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".yips", "models");
+}
+function getDiskFreeGb(path) {
+    try {
+        const fsStats = (0, node_fs_3.statfsSync)(path);
+        const blockSize = Number(fsStats.bsize);
+        const available = Number(fsStats.bavail);
+        if (!Number.isFinite(blockSize) || !Number.isFinite(available) || blockSize <= 0 || available < 0) {
+            return 0;
+        }
+        return roundOne((blockSize * available) / (1024 ** 3));
+    }
+    catch {
+        return 0;
+    }
+}
+let cachedSpecs = null;
+function getSystemSpecs() {
+    if (cachedSpecs) {
+        return cachedSpecs;
+    }
+    const ramGb = getRamGb();
+    const nvidiaVramGb = getNvidiaVramGb();
+    const amdVramGb = nvidiaVramGb > 0 ? 0 : getAmdVramGb();
+    const vramGb = nvidiaVramGb > 0 ? nvidiaVramGb : amdVramGb;
+    const gpuType = nvidiaVramGb > 0 ? "nvidia" : amdVramGb > 0 ? "amd" : "unknown";
+    cachedSpecs = {
+        ramGb,
+        vramGb,
+        totalMemoryGb: roundOne(ramGb + vramGb),
+        diskFreeGb: getDiskFreeGb(getModelsDir()),
+        gpuType
+    };
+    return cachedSpecs;
+}
+function clearSystemSpecsCache() {
+    cachedSpecs = null;
+}