@sheepbun/yips 0.1.1

package/dist/config.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_PATH_ENV_VAR = exports.DEFAULT_CONFIG_PATH = void 0;
+exports.getDefaultConfig = getDefaultConfig;
+exports.resolveConfigPath = resolveConfigPath;
+exports.mergeConfig = mergeConfig;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.updateConfig = updateConfig;
+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");
+const SUPPORTED_BACKENDS = new Set(["llamacpp", "claude"]);
+const PORT_CONFLICT_POLICIES = new Set([
+    "fail",
+    "kill-llama",
+    "kill-user"
+]);
+const SUPPORTED_HOOKS = [
+    "on-session-start",
+    "on-session-end",
+    "on-file-write",
+    "on-file-read",
+    "pre-commit"
+];
+const DEFAULT_HOOK_TIMEOUT_MS = 10_000;
+const MAX_HOOK_TIMEOUT_MS = 120_000;
+exports.DEFAULT_CONFIG_PATH = ".yips_config.json";
+exports.CONFIG_PATH_ENV_VAR = "YIPS_CONFIG_PATH";
+function getDefaultConfig() {
+    const llamaHost = "127.0.0.1";
+    const llamaPort = 8080;
+    return {
+        streaming: true,
+        verbose: false,
+        backend: "llamacpp",
+        llamaBaseUrl: buildBaseUrl(llamaHost, llamaPort),
+        llamaServerPath: "",
+        llamaModelsDir: (0, node_path_1.resolve)((0, node_os_1.homedir)(), ".yips", "models"),
+        llamaHost,
+        llamaPort,
+        llamaContextSize: 8192,
+        llamaGpuLayers: 999,
+        llamaAutoStart: true,
+        llamaPortConflictPolicy: "kill-user",
+        model: "default",
+        tokensMode: "auto",
+        tokensManualMax: 8192,
+        nicknames: {},
+        hooks: {}
+    };
+}
+function resolveConfigPath(configPath = exports.DEFAULT_CONFIG_PATH) {
+    if (configPath === exports.DEFAULT_CONFIG_PATH) {
+        const envPath = process.env[exports.CONFIG_PATH_ENV_VAR]?.trim();
+        if (envPath && envPath.length > 0) {
+            return (0, node_path_1.resolve)(envPath);
+        }
+    }
+    return (0, node_path_1.resolve)(process.cwd(), configPath);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function normalizeBackend(value, fallback) {
+    if (typeof value === "string" && SUPPORTED_BACKENDS.has(value)) {
+        return value;
+    }
+    return fallback;
+}
+function normalizeModel(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeBaseUrl(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return fallback;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return fallback;
+        }
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        return fallback;
+    }
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+        return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+        return false;
+    }
+    return fallback;
+}
+function normalizeString(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeHost(value, fallback) {
+    return normalizeString(value, fallback);
+}
+function normalizePort(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function normalizePositiveInt(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function normalizePositiveIntWithMax(value, fallback, max) {
+    const normalized = normalizePositiveInt(value, fallback);
+    return Math.min(normalized, max);
+}
+function normalizePortConflictPolicy(value, fallback) {
+    if (typeof value === "string" && PORT_CONFLICT_POLICIES.has(value)) {
+        return value;
+    }
+    return fallback;
+}
+function normalizeTokensMode(value, fallback) {
+    if (value === "auto" || value === "manual") {
+        return value;
+    }
+    return fallback;
+}
+function buildBaseUrl(host, port) {
+    return `http://${host}:${port}`;
+}
+function parseBaseUrlHostPort(baseUrl) {
+    try {
+        const parsed = new URL(baseUrl);
+        if (!parsed.hostname || !parsed.port) {
+            return null;
+        }
+        const port = Number(parsed.port);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+            return null;
+        }
+        return {
+            host: parsed.hostname,
+            port
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNicknames(value, fallback) {
+    if (!isRecord(value)) {
+        return { ...fallback };
+    }
+    const next = {};
+    for (const [key, nickname] of Object.entries(value)) {
+        if (typeof key !== "string" || typeof nickname !== "string") {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        const trimmedNickname = nickname.trim();
+        if (trimmedKey.length === 0 || trimmedNickname.length === 0) {
+            continue;
+        }
+        next[trimmedKey] = trimmedNickname;
+    }
+    return next;
+}
+function normalizeHookConfig(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const command = normalizeString(value.command, "");
+    if (command.length === 0) {
+        return null;
+    }
+    const timeoutMs = normalizePositiveIntWithMax(value.timeoutMs, DEFAULT_HOOK_TIMEOUT_MS, MAX_HOOK_TIMEOUT_MS);
+    return { command, timeoutMs };
+}
+function normalizeHooks(value, fallback) {
+    const next = {};
+    for (const hookName of SUPPORTED_HOOKS) {
+        const existing = fallback[hookName];
+        if (existing) {
+            next[hookName] = { ...existing };
+        }
+    }
+    if (!isRecord(value)) {
+        return next;
+    }
+    for (const hookName of SUPPORTED_HOOKS) {
+        const normalized = normalizeHookConfig(value[hookName]);
+        if (normalized) {
+            next[hookName] = normalized;
+        }
+    }
+    return next;
+}
+function applyEnvOverrides(config) {
+    const envHost = normalizeHost(process.env["YIPS_LLAMA_HOST"], config.llamaHost);
+    const envPort = normalizePort(process.env["YIPS_LLAMA_PORT"], config.llamaPort);
+    const envBaseUrl = normalizeBaseUrl(process.env["YIPS_LLAMA_BASE_URL"], buildBaseUrl(envHost, envPort));
+    const envBaseUrlHostPort = parseBaseUrlHostPort(envBaseUrl);
+    return {
+        ...config,
+        llamaHost: envBaseUrlHostPort?.host ?? envHost,
+        llamaPort: envBaseUrlHostPort?.port ?? envPort,
+        llamaBaseUrl: envBaseUrl,
+        llamaServerPath: normalizeString(process.env["YIPS_LLAMA_SERVER_PATH"], config.llamaServerPath),
+        llamaModelsDir: normalizeString(process.env["YIPS_LLAMA_MODELS_DIR"], config.llamaModelsDir),
+        llamaContextSize: normalizePositiveInt(process.env["YIPS_LLAMA_CONTEXT_SIZE"], config.llamaContextSize),
+        llamaGpuLayers: normalizePositiveInt(process.env["YIPS_LLAMA_GPU_LAYERS"], config.llamaGpuLayers),
+        llamaAutoStart: parseBoolean(process.env["YIPS_LLAMA_AUTO_START"], config.llamaAutoStart),
+        llamaPortConflictPolicy: normalizePortConflictPolicy(process.env["YIPS_LLAMA_PORT_CONFLICT_POLICY"], config.llamaPortConflictPolicy),
+        model: normalizeModel(process.env["YIPS_MODEL"], config.model),
+        tokensMode: normalizeTokensMode(process.env["YIPS_TOKENS_MODE"], config.tokensMode),
+        tokensManualMax: normalizePositiveInt(process.env["YIPS_TOKENS_MANUAL_MAX"], config.tokensManualMax),
+        hooks: normalizeHooks(config.hooks, config.hooks)
+    };
+}
+function mergeConfig(defaults, candidate) {
+    if (!isRecord(candidate)) {
+        return defaults;
+    }
+    const llamaHost = normalizeHost(candidate.llamaHost, defaults.llamaHost);
+    const llamaPort = normalizePort(candidate.llamaPort, defaults.llamaPort);
+    const llamaBaseUrl = normalizeBaseUrl(candidate.llamaBaseUrl, buildBaseUrl(llamaHost, llamaPort));
+    const baseUrlHostPort = parseBaseUrlHostPort(llamaBaseUrl);
+    return {
+        streaming: normalizeBoolean(candidate.streaming, defaults.streaming),
+        verbose: normalizeBoolean(candidate.verbose, defaults.verbose),
+        backend: normalizeBackend(candidate.backend, defaults.backend),
+        llamaBaseUrl,
+        llamaServerPath: normalizeString(candidate.llamaServerPath, defaults.llamaServerPath),
+        llamaModelsDir: normalizeString(candidate.llamaModelsDir, defaults.llamaModelsDir),
+        llamaHost: baseUrlHostPort?.host ?? llamaHost,
+        llamaPort: baseUrlHostPort?.port ?? llamaPort,
+        llamaContextSize: normalizePositiveInt(candidate.llamaContextSize, defaults.llamaContextSize),
+        llamaGpuLayers: normalizePositiveInt(candidate.llamaGpuLayers, defaults.llamaGpuLayers),
+        llamaAutoStart: normalizeBoolean(candidate.llamaAutoStart, defaults.llamaAutoStart),
+        llamaPortConflictPolicy: normalizePortConflictPolicy(candidate.llamaPortConflictPolicy, defaults.llamaPortConflictPolicy),
+        model: normalizeModel(candidate.model, defaults.model),
+        tokensMode: normalizeTokensMode(candidate.tokensMode, defaults.tokensMode),
+        tokensManualMax: normalizePositiveInt(candidate.tokensManualMax, defaults.tokensManualMax),
+        nicknames: normalizeNicknames(candidate.nicknames, defaults.nicknames),
+        hooks: normalizeHooks(candidate.hooks, defaults.hooks)
+    };
+}
+async function loadConfig(configPath = exports.DEFAULT_CONFIG_PATH) {
+    const defaults = getDefaultConfig();
+    const path = resolveConfigPath(configPath);
+    const legacyDefaultPath = (0, node_path_1.resolve)(process.cwd(), exports.DEFAULT_CONFIG_PATH);
+    const candidatePaths = [path];
+    if (configPath === exports.DEFAULT_CONFIG_PATH && path !== legacyDefaultPath) {
+        candidatePaths.push(legacyDefaultPath);
+    }
+    let readablePath = null;
+    for (const candidatePath of candidatePaths) {
+        try {
+            await (0, promises_1.access)(candidatePath, node_fs_1.constants.R_OK);
+            readablePath = candidatePath;
+            break;
+        }
+        catch {
+            // keep trying
+        }
+    }
+    if (!readablePath) {
+        return { config: applyEnvOverrides(defaults), path, source: "default" };
+    }
+    try {
+        const rawConfig = await (0, promises_1.readFile)(readablePath, "utf8");
+        const parsedConfig = JSON.parse(rawConfig);
+        return {
+            config: applyEnvOverrides(mergeConfig(defaults, parsedConfig)),
+            path: readablePath,
+            source: "file"
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            config: applyEnvOverrides(defaults),
+            path: readablePath,
+            source: "default",
+            warning: `Failed to load config at ${readablePath}: ${message}`
+        };
+    }
+}
+async function saveConfig(config, configPath = exports.DEFAULT_CONFIG_PATH) {
+    const path = resolveConfigPath(configPath);
+    const normalized = mergeConfig(getDefaultConfig(), config);
+    await (0, promises_1.writeFile)(path, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+}
+async function updateConfig(patch, configPath = exports.DEFAULT_CONFIG_PATH) {
+    const loaded = await loadConfig(configPath);
+    const merged = mergeConfig(getDefaultConfig(), { ...loaded.config, ...patch });
+    await saveConfig(merged, configPath);
+    return merged;
+}

package/dist/downloader-state.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOWNLOADER_TABS = void 0;
+exports.tabToSort = tabToSort;
+exports.createDownloaderState = createDownloaderState;
+exports.cycleTab = cycleTab;
+exports.setModels = setModels;
+exports.setFiles = setFiles;
+exports.setLoading = setLoading;
+exports.setLoadingModels = setLoadingModels;
+exports.setLoadingFiles = setLoadingFiles;
+exports.startDownload = startDownload;
+exports.updateDownloadProgress = updateDownloadProgress;
+exports.finishDownload = finishDownload;
+exports.setPreloadingTabs = setPreloadingTabs;
+exports.setCachedModels = setCachedModels;
+exports.getCachedModels = getCachedModels;
+exports.resetModelCache = resetModelCache;
+exports.setError = setError;
+exports.setDownloaderError = setDownloaderError;
+exports.closeFileView = closeFileView;
+exports.openCancelConfirm = openCancelConfirm;
+exports.closeCancelConfirm = closeCancelConfirm;
+exports.moveModelSelection = moveModelSelection;
+exports.moveFileSelection = moveFileSelection;
+exports.DOWNLOADER_TABS = ["Most Downloaded", "Top Rated", "Newest"];
+function tabToSort(tab) {
+    if (tab === "Top Rated") {
+        return "trendingScore";
+    }
+    if (tab === "Newest") {
+        return "lastModified";
+    }
+    return "downloads";
+}
+function createDownloaderState(memory) {
+    return {
+        isOpen: true,
+        view: "models",
+        tab: "Most Downloaded",
+        searchQuery: "",
+        models: [],
+        files: [],
+        selectedModelIndex: 0,
+        selectedFileIndex: 0,
+        modelScrollOffset: 0,
+        fileScrollOffset: 0,
+        phase: "idle",
+        loading: false,
+        loadingMessage: "Loading models...",
+        errorMessage: "",
+        download: null,
+        selectedRepoId: "",
+        ramGb: memory.ramGb,
+        vramGb: memory.vramGb,
+        totalMemoryGb: memory.totalMemoryGb,
+        diskFreeGb: memory.diskFreeGb ?? 0,
+        cacheQuery: "",
+        modelCacheByTab: {},
+        preloadingTabs: false,
+        cancelConfirmOpen: false
+    };
+}
+function cycleTab(state, direction) {
+    const currentIndex = exports.DOWNLOADER_TABS.indexOf(state.tab);
+    const nextIndex = (currentIndex + direction + exports.DOWNLOADER_TABS.length) % exports.DOWNLOADER_TABS.length;
+    return {
+        ...state,
+        tab: exports.DOWNLOADER_TABS[nextIndex] ?? "Most Downloaded",
+        selectedModelIndex: 0,
+        modelScrollOffset: 0
+    };
+}
+function setModels(state, models) {
+    return {
+        ...state,
+        models,
+        selectedModelIndex: models.length > 0 ? Math.min(state.selectedModelIndex, models.length - 1) : 0,
+        modelScrollOffset: 0,
+        phase: "idle",
+        loading: false,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setFiles(state, repoId, files) {
+    return {
+        ...state,
+        selectedRepoId: repoId,
+        view: "files",
+        files,
+        selectedFileIndex: 0,
+        fileScrollOffset: 0,
+        phase: "idle",
+        loading: false,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setLoading(state, message) {
+    return {
+        ...state,
+        phase: "loading-models",
+        loading: true,
+        loadingMessage: message,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setLoadingModels(state, message) {
+    return {
+        ...state,
+        phase: "loading-models",
+        loading: true,
+        loadingMessage: message,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setLoadingFiles(state, message) {
+    return {
+        ...state,
+        phase: "loading-files",
+        loading: true,
+        loadingMessage: message,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function startDownload(state, repoId, filename, statusText) {
+    const now = Date.now();
+    return {
+        ...state,
+        phase: "downloading",
+        loading: true,
+        loadingMessage: statusText,
+        errorMessage: "",
+        download: {
+            repoId,
+            filename,
+            bytesDownloaded: 0,
+            totalBytes: null,
+            startedAtMs: now,
+            lastUpdateAtMs: now,
+            statusText
+        },
+        cancelConfirmOpen: false
+    };
+}
+function updateDownloadProgress(state, update) {
+    if (state.phase !== "downloading" || !state.download) {
+        return state;
+    }
+    return {
+        ...state,
+        loadingMessage: update.statusText,
+        download: {
+            ...state.download,
+            bytesDownloaded: Math.max(0, update.bytesDownloaded),
+            totalBytes: update.totalBytes,
+            lastUpdateAtMs: Date.now(),
+            statusText: update.statusText
+        }
+    };
+}
+function finishDownload(state) {
+    return {
+        ...state,
+        phase: "idle",
+        loading: false,
+        loadingMessage: "",
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setPreloadingTabs(state, preloadingTabs) {
+    return {
+        ...state,
+        preloadingTabs
+    };
+}
+function setCachedModels(state, tab, query, models) {
+    const normalizedQuery = query.trim();
+    const cache = state.cacheQuery === normalizedQuery ? state.modelCacheByTab : {};
+    return {
+        ...state,
+        cacheQuery: normalizedQuery,
+        modelCacheByTab: {
+            ...cache,
+            [tab]: models
+        }
+    };
+}
+function getCachedModels(state, tab, query) {
+    if (state.cacheQuery !== query.trim()) {
+        return null;
+    }
+    return state.modelCacheByTab[tab] ?? null;
+}
+function resetModelCache(state, query) {
+    return {
+        ...state,
+        cacheQuery: query.trim(),
+        modelCacheByTab: {}
+    };
+}
+function setError(state, message) {
+    return {
+        ...state,
+        phase: "error",
+        loading: false,
+        errorMessage: message,
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function setDownloaderError(state, message) {
+    return {
+        ...state,
+        phase: "error",
+        loading: false,
+        errorMessage: message,
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function closeFileView(state) {
+    return {
+        ...state,
+        view: "models",
+        files: [],
+        selectedFileIndex: 0,
+        fileScrollOffset: 0,
+        phase: "idle",
+        loading: false,
+        errorMessage: "",
+        download: null,
+        cancelConfirmOpen: false
+    };
+}
+function openCancelConfirm(state) {
+    if (state.phase !== "downloading" || !state.download) {
+        return state;
+    }
+    return {
+        ...state,
+        cancelConfirmOpen: true
+    };
+}
+function closeCancelConfirm(state) {
+    if (!state.cancelConfirmOpen) {
+        return state;
+    }
+    return {
+        ...state,
+        cancelConfirmOpen: false
+    };
+}
+function moveModelSelection(state, delta, windowSize) {
+    if (state.models.length === 0) {
+        return state;
+    }
+    const max = state.models.length - 1;
+    const nextIndex = Math.max(0, Math.min(max, state.selectedModelIndex + delta));
+    let nextOffset = state.modelScrollOffset;
+    if (nextIndex < nextOffset) {
+        nextOffset = nextIndex;
+    }
+    if (nextIndex >= nextOffset + windowSize) {
+        nextOffset = nextIndex - windowSize + 1;
+    }
+    return {
+        ...state,
+        selectedModelIndex: nextIndex,
+        modelScrollOffset: Math.max(0, nextOffset)
+    };
+}
+function moveFileSelection(state, delta, windowSize) {
+    if (state.files.length === 0) {
+        return state;
+    }
+    const max = state.files.length - 1;
+    const nextIndex = Math.max(0, Math.min(max, state.selectedFileIndex + delta));
+    let nextOffset = state.fileScrollOffset;
+    if (nextIndex < nextOffset) {
+        nextOffset = nextIndex;
+    }
+    if (nextIndex >= nextOffset + windowSize) {
+        nextOffset = nextIndex - windowSize + 1;
+    }
+    return {
+        ...state,
+        selectedFileIndex: nextIndex,
+        fileScrollOffset: Math.max(0, nextOffset)
+    };
+}