grepmax 0.1.0

package/dist/lib/utils/project-root.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+exports.ensureProjectPaths = ensureProjectPaths;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+function findProjectRoot(startDir = process.cwd()) {
+    const start = path.resolve(startDir);
+    // Only consider the current directory; do not climb above the user's cwd.
+    const osgrepDir = path.join(start, ".osgrep");
+    const gitDir = path.join(start, ".git");
+    if ((fs.existsSync(osgrepDir) || fs.existsSync(gitDir)) &&
+        path.resolve(start) !== path.resolve(config_1.PATHS.globalRoot)) {
+        return start;
+    }
+    // Otherwise, treat the current dir as the root (per-subdirectory isolation).
+    return start;
+}
+function ensureProjectPaths(startDir = process.cwd(), options) {
+    var _a;
+    const root = (_a = findProjectRoot(startDir)) !== null && _a !== void 0 ? _a : path.resolve(startDir);
+    const osgrepDir = path.join(root, ".osgrep");
+    const lancedbDir = path.join(osgrepDir, "lancedb");
+    const cacheDir = path.join(osgrepDir, "cache");
+    const lmdbPath = path.join(cacheDir, "meta.lmdb");
+    const configPath = path.join(osgrepDir, "config.json");
+    if (!(options === null || options === void 0 ? void 0 : options.dryRun)) {
+        [osgrepDir, lancedbDir, cacheDir].forEach((dir) => {
+            fs.mkdirSync(dir, { recursive: true });
+        });
+        ensureGitignoreEntry(root);
+    }
+    return { root, osgrepDir, lancedbDir, cacheDir, lmdbPath, configPath };
+}
+function fileContainsEntry(filePath, entry) {
+    try {
+        const contents = fs.readFileSync(filePath, "utf-8");
+        return contents
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .includes(entry);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function ensureGitignoreEntry(root) {
+    // Only add when inside a git repo.
+    if (!fs.existsSync(path.join(root, ".git")))
+        return;
+    const entry = ".osgrep";
+    // Check .git/info/exclude first
+    const excludePath = path.join(root, ".git", "info", "exclude");
+    if (fileContainsEntry(excludePath, entry))
+        return;
+    // Check .gitignore
+    const gitignorePath = path.join(root, ".gitignore");
+    if (fileContainsEntry(gitignorePath, entry))
+        return;
+    // Add to .gitignore
+    let contents = "";
+    try {
+        contents = fs.readFileSync(gitignorePath, "utf-8");
+    }
+    catch (_a) {
+        // ignore missing file; will create below
+    }
+    const needsNewline = contents.length > 0 && !contents.endsWith("\n");
+    const prefix = needsNewline ? "\n" : "";
+    fs.writeFileSync(gitignorePath, `${contents}${prefix}${entry}\n`, {
+        encoding: "utf-8",
+    });
+}

package/dist/lib/utils/server-registry.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProcessRunning = isProcessRunning;
+exports.registerServer = registerServer;
+exports.unregisterServer = unregisterServer;
+exports.listServers = listServers;
+exports.getServerForProject = getServerForProject;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+const REGISTRY_PATH = path.join(config_1.PATHS.globalRoot, "servers.json");
+function loadRegistry() {
+    try {
+        if (!fs.existsSync(REGISTRY_PATH))
+            return [];
+        const data = fs.readFileSync(REGISTRY_PATH, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (_a) {
+        return [];
+    }
+}
+function saveRegistry(servers) {
+    try {
+        fs.mkdirSync(path.dirname(REGISTRY_PATH), { recursive: true });
+        fs.writeFileSync(REGISTRY_PATH, JSON.stringify(servers, null, 2));
+    }
+    catch (err) {
+        console.error("Failed to save server registry:", err);
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function registerServer(info) {
+    const servers = loadRegistry().filter((s) => isProcessRunning(s.pid));
+    // Remove any existing entry for this projectRoot to avoid duplicates
+    const filtered = servers.filter((s) => s.projectRoot !== info.projectRoot);
+    filtered.push(info);
+    saveRegistry(filtered);
+}
+function unregisterServer(pid) {
+    const servers = loadRegistry();
+    const filtered = servers.filter((s) => s.pid !== pid);
+    saveRegistry(filtered);
+}
+function listServers() {
+    const servers = loadRegistry();
+    // Clean up stale entries on read
+    const active = servers.filter((s) => isProcessRunning(s.pid));
+    if (active.length !== servers.length) {
+        saveRegistry(active);
+    }
+    return active;
+}
+function getServerForProject(projectRoot) {
+    return listServers().find((s) => s.projectRoot === projectRoot);
+}

package/dist/lib/workers/colbert-math.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSim = maxSim;
+exports.cosineSim = cosineSim;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const simsimd_1 = require("simsimd");
+const config_1 = require("../../config");
+let SKIP_IDS = null;
+function loadSkipIds() {
+    if (SKIP_IDS)
+        return SKIP_IDS;
+    // Check local models first (same logic as orchestrator)
+    const PROJECT_ROOT = process.env.OSGREP_PROJECT_ROOT
+        ? path.resolve(process.env.OSGREP_PROJECT_ROOT)
+        : process.cwd();
+    const localModels = path.join(PROJECT_ROOT, "models");
+    const localColbert = path.join(localModels, ...config_1.MODEL_IDS.colbert.split("/"));
+    const localSkipPath = path.join(localColbert, "skiplist.json");
+    // Try local first, then global
+    const globalBasePath = path.join(config_1.PATHS.models, ...config_1.MODEL_IDS.colbert.split("/"));
+    const globalSkipPath = path.join(globalBasePath, "skiplist.json");
+    const skipPath = fs.existsSync(localSkipPath)
+        ? localSkipPath
+        : globalSkipPath;
+    if (fs.existsSync(skipPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(skipPath, "utf8"));
+            SKIP_IDS = new Set(parsed.map((n) => Number(n)));
+            return SKIP_IDS;
+        }
+        catch (_e) {
+            // fall through to empty set
+        }
+    }
+    SKIP_IDS = new Set();
+    return SKIP_IDS;
+}
+function maxSim(queryEmbeddings, docEmbeddings, docTokenIds) {
+    if (queryEmbeddings.length === 0 || docEmbeddings.length === 0) {
+        return 0;
+    }
+    const qVecs = queryEmbeddings.map((v) => v instanceof Float32Array ? v : new Float32Array(v));
+    const dVecs = docEmbeddings.map((v) => v instanceof Float32Array ? v : new Float32Array(v));
+    const dTokenIds = docTokenIds && docTokenIds.length === dVecs.length ? docTokenIds : null;
+    const skipIds = loadSkipIds();
+    let totalScore = 0;
+    for (const qVec of qVecs) {
+        let maxDotProduct = -Infinity;
+        for (let idx = 0; idx < dVecs.length; idx++) {
+            const tokenId = dTokenIds ? dTokenIds[idx] : null;
+            if (tokenId !== null && skipIds.has(Number(tokenId)))
+                continue;
+            const dVec = dVecs[idx];
+            const dim = Math.min(qVec.length, dVec.length);
+            const dot = (0, simsimd_1.inner)(qVec.subarray(0, dim), dVec.subarray(0, dim));
+            if (dot > maxDotProduct)
+                maxDotProduct = dot;
+        }
+        if (maxDotProduct === -Infinity)
+            maxDotProduct = 0;
+        totalScore += maxDotProduct;
+    }
+    return totalScore;
+}
+function cosineSim(a, b) {
+    const aVec = a instanceof Float32Array ? a : new Float32Array(a);
+    const bVec = b instanceof Float32Array ? b : new Float32Array(b);
+    const dim = Math.min(aVec.length, bVec.length);
+    if (aVec.length !== bVec.length) {
+        return (0, simsimd_1.inner)(aVec.subarray(0, dim), bVec.subarray(0, dim));
+    }
+    return (0, simsimd_1.inner)(aVec, bVec);
+}

package/dist/lib/workers/colbert-tokenizer.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColBERTTokenizer = void 0;
+const transformers_1 = require("@huggingface/transformers");
+const QUERY_MARKER_TOKEN = "[Q] ";
+const DOC_MARKER_TOKEN = "[D] ";
+const MASK_TOKEN = "[MASK]";
+const QUERY_MAXLEN = 32; // Standard ColBERT query length
+const DOC_MAXLEN = 512; // Standard ColBERT document length
+class ColBERTTokenizer {
+    constructor() {
+        this.tokenizer = null;
+        this.specialTokenIds = null;
+    }
+    init(modelPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            this.tokenizer = yield transformers_1.AutoTokenizer.from_pretrained(modelPath);
+            // Get special token IDs with fallbacks
+            // We use the IDs we discovered in validation: [Q]=50368, [D]=50369
+            // But we still try to look them up dynamically first.
+            const tokenizer = this.tokenizer;
+            const get = (token) => tokenizer === null || tokenizer === void 0 ? void 0 : tokenizer.model.tokens_to_ids.get(token);
+            const specialTokens = tokenizer;
+            const clsId = (_b = get((_a = specialTokens.cls_token) !== null && _a !== void 0 ? _a : "[CLS]")) !== null && _b !== void 0 ? _b : 50281;
+            const sepId = (_d = get((_c = specialTokens.sep_token) !== null && _c !== void 0 ? _c : "[SEP]")) !== null && _d !== void 0 ? _d : 50282;
+            const padId = (_f = get((_e = specialTokens.pad_token) !== null && _e !== void 0 ? _e : "[PAD]")) !== null && _f !== void 0 ? _f : 50283;
+            const maskId = (_g = get(MASK_TOKEN)) !== null && _g !== void 0 ? _g : 50284;
+            const queryMarkerId = (_h = get(QUERY_MARKER_TOKEN)) !== null && _h !== void 0 ? _h : 50368;
+            const docMarkerId = (_j = get(DOC_MARKER_TOKEN)) !== null && _j !== void 0 ? _j : 50369;
+            this.specialTokenIds = {
+                cls: clsId,
+                sep: sepId,
+                pad: padId,
+                mask: maskId,
+                queryMarker: queryMarkerId,
+                docMarker: docMarkerId,
+            };
+        });
+    }
+    encodeQuery(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenizer || !this.specialTokenIds) {
+                throw new Error("Tokenizer not initialized. Call init() first.");
+            }
+            // Tokenize without special tokens
+            const encoded = yield this.tokenizer(text, {
+                add_special_tokens: false,
+                truncation: true,
+                max_length: QUERY_MAXLEN - 2, // Reserve space for [CLS] and [Q]
+            });
+            const { input_ids } = encoded;
+            // Build sequence: [CLS] [Q] token1 token2 ... [SEP] [MASK] [MASK] ...
+            const finalIds = [
+                this.specialTokenIds.cls,
+                this.specialTokenIds.queryMarker,
+                ...Array.from(input_ids.data).map(Number),
+                this.specialTokenIds.sep,
+            ];
+            // Query Expansion: pad with [MASK] tokens up to QUERY_MAXLEN
+            while (finalIds.length < QUERY_MAXLEN) {
+                finalIds.push(this.specialTokenIds.mask);
+            }
+            // Truncate if somehow longer (safety check)
+            if (finalIds.length > QUERY_MAXLEN) {
+                finalIds.length = QUERY_MAXLEN;
+            }
+            // Create attention mask (1 for all tokens, since MASK is also attended to)
+            const attentionMask = new Array(finalIds.length).fill(1);
+            return {
+                input_ids: finalIds.map((id) => BigInt(id)),
+                attention_mask: attentionMask.map((v) => BigInt(v)),
+            };
+        });
+    }
+    encodeDoc(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenizer || !this.specialTokenIds) {
+                throw new Error("Tokenizer not initialized. Call init() first.");
+            }
+            // Tokenize without special tokens
+            const encoded = yield this.tokenizer(text, {
+                add_special_tokens: false,
+                truncation: true,
+                max_length: DOC_MAXLEN - 3, // Reserve space for [CLS], [D], and [SEP]
+            });
+            const { input_ids } = encoded;
+            // Build sequence: [CLS] [D] token1 token2 ... [SEP]
+            const finalIds = [
+                this.specialTokenIds.cls,
+                this.specialTokenIds.docMarker,
+                ...Array.from(input_ids.data).map(Number),
+                this.specialTokenIds.sep,
+            ];
+            // Create attention mask
+            const attentionMask = new Array(finalIds.length).fill(1);
+            return {
+                input_ids: finalIds.map((id) => BigInt(id)),
+                attention_mask: attentionMask.map((v) => BigInt(v)),
+            };
+        });
+    }
+}
+exports.ColBERTTokenizer = ColBERTTokenizer;

package/dist/lib/workers/download-worker.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_worker_threads_1 = require("node:worker_threads");
+const transformers_1 = require("@huggingface/transformers");
+const config_1 = require("../../config");
+// Configuration
+const HOMEDIR = os.homedir();
+const CACHE_DIR = path.join(HOMEDIR, ".osgrep", "models");
+transformers_1.env.cacheDir = CACHE_DIR;
+transformers_1.env.allowLocalModels = true;
+transformers_1.env.allowRemoteModels = true;
+// Suppress noisy warnings from transformers.js/onnxruntime
+const originalWarn = console.warn;
+console.warn = (...args) => {
+    if (args[0] &&
+        typeof args[0] === "string" &&
+        args[0].includes("Unable to determine content-length")) {
+        return;
+    }
+    originalWarn(...args);
+};
+// Helper to download with timeout
+function downloadModelWithTimeout(modelId, dtype) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+        try {
+            const downloadPromise = (0, transformers_1.pipeline)("feature-extraction", modelId, {
+                dtype,
+                progress_callback: (progress) => {
+                    if (node_worker_threads_1.parentPort)
+                        node_worker_threads_1.parentPort.postMessage({ type: "progress", progress });
+                },
+            });
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Download timed out after ${TIMEOUT_MS} ms`)), TIMEOUT_MS);
+            });
+            return Promise.race([downloadPromise, timeoutPromise]);
+        }
+        catch (err) {
+            console.error(`Worker: pipeline creation failed for ${modelId}: `, err);
+            throw err;
+        }
+    });
+}
+// Helper to manually download extra files like skiplist.json
+function downloadExtraFile(modelId, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = `https://huggingface.co/${modelId}/resolve/main/${filename}`;
+        // Construct path: ~/.osgrep/models/ryandono/osgrep-colbert-q8/skiplist.json
+        const destDir = path.join(CACHE_DIR, ...modelId.split("/"));
+        const destPath = path.join(destDir, filename);
+        if (!fs.existsSync(destDir)) {
+            fs.mkdirSync(destDir, { recursive: true });
+        }
+        // If file exists and is non-zero, skip (or implement hash check if you want SOTA robustness)
+        if (fs.existsSync(destPath) && fs.statSync(destPath).size > 0) {
+            return;
+        }
+        if (node_worker_threads_1.parentPort) {
+            node_worker_threads_1.parentPort.postMessage({
+                type: "progress",
+                progress: { status: "downloading", file: filename },
+            });
+        }
+        try {
+            const res = yield fetch(url);
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            }
+            const buffer = yield res.arrayBuffer();
+            fs.writeFileSync(destPath, Buffer.from(buffer));
+            if (node_worker_threads_1.parentPort) {
+                node_worker_threads_1.parentPort.postMessage({
+                    type: "progress",
+                    progress: { status: "downloaded", file: filename },
+                });
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            console.warn(`⚠️ Failed to download ${filename} from ${url}:`, errorMsg);
+            // Don't crash, just warn. The math worker has a fallback (empty set).
+            // But report the failure so setup can retry
+            if (node_worker_threads_1.parentPort) {
+                node_worker_threads_1.parentPort.postMessage({
+                    type: "warning",
+                    file: filename,
+                    error: errorMsg,
+                });
+            }
+        }
+    });
+}
+function download() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 1. Download Dense Model
+            const embedPipeline = yield downloadModelWithTimeout(config_1.MODEL_IDS.embed, "q4");
+            yield embedPipeline.dispose();
+            // 2. Download ColBERT Model
+            const colbertPipeline = yield downloadModelWithTimeout(config_1.MODEL_IDS.colbert, "int8");
+            yield colbertPipeline.dispose();
+            // 3. Download the custom Skiplist
+            yield downloadExtraFile(config_1.MODEL_IDS.colbert, "skiplist.json");
+            if (node_worker_threads_1.parentPort) {
+                node_worker_threads_1.parentPort.postMessage({ status: "success" });
+            }
+            else {
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            console.error("Worker failed to download models:", error);
+            if (node_worker_threads_1.parentPort) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                node_worker_threads_1.parentPort.postMessage({ status: "error", error: errorMsg });
+            }
+            else {
+                process.exit(1);
+            }
+        }
+    });
+}
+download();