flowseeker 0.1.7 → 0.1.9

package/dist/gateway/embeddingProviders.js

@@ -0,0 +1,852 @@
+"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.localProviderNextAction = localProviderNextAction;
+exports.getLocalProviderReadiness = getLocalProviderReadiness;
+exports.checkLocalProviderReadiness = checkLocalProviderReadiness;
+exports.detectLocalRuntime = detectLocalRuntime;
+exports.detectBundledLocalPackage = detectBundledLocalPackage;
+exports.normalizeEmbeddings = normalizeEmbeddings;
+exports.createOpenAICompatibleEmbeddingProvider = createOpenAICompatibleEmbeddingProvider;
+exports.createConfiguredEmbeddingProvider = createConfiguredEmbeddingProvider;
+const fs = __importStar(require("fs"));
+const module_1 = require("module");
+const path = __importStar(require("path"));
+const env_1 = require("../config/env");
+function localProviderNextAction(status) {
+    if (status === "local_unavailable_runtime_missing")
+        return "Run flowseeker semantic local setup to install the local embedding runtime in this project. Or, for the ready local path: npm i -g flowseeker flowseeker-local.";
+    if (status === "local_unavailable_model_missing")
+        return "Run flowseeker semantic local download to download the local embedding model.";
+    if (status === "local_unavailable_model_invalid")
+        return "Re-download the local embedding model or check semanticLocalModelPath in .flowseeker/config.json.";
+    if (status === "bundled_package_missing")
+        return "Install the optional local model package: npm i -g flowseeker flowseeker-local. Deterministic retrieval remains available by default.";
+    if (status === "bundled_package_invalid")
+        return "The flowseeker-local package is installed but its manifest is invalid. Reinstall or check the package version.";
+    if (status === "bundled_package_ready")
+        return "Built-in local model package is ready. Run flowseeker semantic check --test to verify local embeddings.";
+    return "Local embedding provider is ready. Run flowseeker semantic check --test to verify local embeddings.";
+}
+function getLocalProviderReadiness(workspacePath, config) {
+    // Check bundled local package first (GitNexus-style)
+    const bundled = detectBundledLocalPackage(workspacePath);
+    if (bundled.available) {
+        if (bundled.valid) {
+            return {
+                runtimeAvailable: true,
+                localStatus: "bundled_package_ready",
+                runtimeStatus: "available (bundled package)",
+                modelStatus: bundled.modelId || "ready",
+                nextAction: localProviderNextAction("bundled_package_ready"),
+                reasonWhenSkipped: ""
+            };
+        }
+        return {
+            runtimeAvailable: true,
+            localStatus: bundled.status,
+            runtimeStatus: "available (bundled package)",
+            modelStatus: bundled.reason || "invalid",
+            nextAction: localProviderNextAction(bundled.status),
+            reasonWhenSkipped: bundled.reason || ""
+        };
+    }
+    // Fall through to project-level detection (Phase 11 path)
+    const runtimeAvailable = detectLocalRuntime(workspacePath);
+    if (!runtimeAvailable)
+        return makeReadiness(false, "local_unavailable_runtime_missing", "unavailable (not installed)");
+    if (!config.semanticLocalModelPath)
+        return makeReadiness(true, "local_unavailable_model_missing", "not downloaded");
+    if (config.semanticDimensions !== undefined && config.semanticDimensions <= 0)
+        return makeReadiness(true, "local_unavailable_model_invalid", "invalid dimensions");
+    const mr = validateLocalModelManifest(config.semanticLocalModelPath);
+    return makeReadiness(true, mr.status, mr.detail);
+}
+function makeReadiness(runtimeAvailable, status, modelStatus) {
+    return {
+        runtimeAvailable, localStatus: status,
+        runtimeStatus: runtimeAvailable ? "available" : "unavailable (not installed)",
+        modelStatus,
+        nextAction: localProviderNextAction(status),
+        reasonWhenSkipped: status !== "local_ready" ? "Local runtime/model not available." : ""
+    };
+}
+function validateLocalModelManifest(modelDir) {
+    const manifestPath = path.join(modelDir, "manifest.json");
+    if (!fs.existsSync(manifestPath))
+        return { status: "local_unavailable_model_missing", detail: "manifest not found" };
+    let raw;
+    try {
+        raw = fs.readFileSync(manifestPath, "utf8");
+    }
+    catch {
+        return { status: "local_unavailable_model_missing", detail: "cannot read manifest" };
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(raw);
+    }
+    catch {
+        return { status: "local_unavailable_model_invalid", detail: "manifest is not valid JSON" };
+    }
+    const manifestStatus = String(manifest.status || "");
+    if (manifestStatus === "declared" || manifestStatus === "pending" || !manifestStatus)
+        return { status: "local_unavailable_model_missing", detail: "manifest status: " + (manifestStatus || "empty") };
+    if (manifestStatus !== "ready" && manifestStatus !== "downloaded")
+        return { status: "local_unavailable_model_invalid", detail: "unknown manifest status: " + manifestStatus };
+    const dims = Number(manifest.dimensions);
+    if (isNaN(dims) || dims <= 0)
+        return { status: "local_unavailable_model_invalid", detail: "invalid dimensions in manifest" };
+    const artifacts = manifest.artifacts;
+    if (!artifacts || typeof artifacts !== "object" || Object.keys(artifacts).length === 0)
+        return { status: "local_unavailable_model_missing", detail: "no artifacts in manifest" };
+    const resolvedBase = path.resolve(modelDir);
+    for (const [key, artifactPath] of Object.entries(artifacts)) {
+        if (typeof artifactPath !== "string" || !artifactPath)
+            return { status: "local_unavailable_model_invalid", detail: "artifact '" + key + "' has empty or non-string path" };
+        if (artifactPath.includes("..") || path.isAbsolute(artifactPath))
+            return { status: "local_unavailable_model_invalid", detail: "artifact '" + key + "' path traversal detected" };
+        const resolved = path.resolve(path.join(resolvedBase, artifactPath));
+        if (!resolved.startsWith(resolvedBase + path.sep) && resolved !== resolvedBase)
+            return { status: "local_unavailable_model_invalid", detail: "artifact '" + key + "' escapes model directory" };
+        try {
+            fs.accessSync(resolved);
+        }
+        catch {
+            return { status: "local_unavailable_model_missing", detail: "artifact '" + key + "' file missing: " + artifactPath };
+        }
+    }
+    return { status: "local_ready", detail: "ready" };
+}
+function checkLocalProviderReadiness(config, options) {
+    // Check runtime
+    if (!options?.runtimeAvailable)
+        return "local_unavailable_runtime_missing";
+    // Check model path
+    if (!config.semanticLocalModelPath)
+        return "local_unavailable_model_missing";
+    // Check model validity (dimensions)
+    if (config.semanticDimensions !== undefined && config.semanticDimensions <= 0)
+        return "local_unavailable_model_invalid";
+    return "local_ready";
+}
+/**
+ * Detect @huggingface/transformers in the target workspace.
+ * Prefers Node package resolution from the workspace package.json.
+ * Does not import the runtime — only checks presence.
+ */
+function detectLocalRuntime(workspacePath) {
+    try {
+        const workspaceRequire = (0, module_1.createRequire)(path.join(workspacePath, "package.json"));
+        workspaceRequire.resolve("@huggingface/transformers");
+        return true;
+    }
+    catch {
+        try {
+            fs.accessSync(path.join(workspacePath, "node_modules", "@huggingface", "transformers", "package.json"));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function getFlowseekerPackageDir() {
+    try {
+        // __dirname at runtime is dist/gateway/, walk up to find package root
+        let dir = path.resolve(__dirname);
+        for (let i = 0; i < 10; i++) {
+            const candidate = path.join(dir, "package.json");
+            if (fs.existsSync(candidate)) {
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
+                    if (pkg.name === "flowseeker")
+                        return dir;
+                }
+                catch { /* keep walking */ }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* best effort */ }
+}
+function getGlobalModulesDir() {
+    try {
+        // npm root -g equivalent detection
+        const { execSync } = require("child_process");
+        const out = execSync("npm root -g", { encoding: "utf8", timeout: 5000, windowsHide: true }).trim();
+        if (out && fs.existsSync(out))
+            return out;
+    }
+    catch { /* npm not available or failed */ }
+    // Fallback: common global paths
+    const candidates = [
+        process.env.APPDATA ? path.join(process.env.APPDATA, "npm", "node_modules") : undefined,
+        "/usr/local/lib/node_modules",
+        "/usr/lib/node_modules",
+    ];
+    for (const c of candidates) {
+        if (c && fs.existsSync(c))
+            return c;
+    }
+}
+function isReadyStatus(status) {
+    return status === "local_ready" || status === "bundled_package_ready";
+}
+function detectBundledLocalPackage(workspacePath) {
+    // Explicit override for unusual package managers or custom installs
+    const overridePath = process.env.FLOWSEEKER_LOCAL_PACKAGE_PATH;
+    if (overridePath && fs.existsSync(path.join(overridePath, "package.json"))) {
+        const pkgDir = overridePath;
+        return resolveBundledPackage(pkgDir);
+    }
+    const searchPaths = [
+        workspacePath || process.cwd(),
+        process.cwd(),
+    ];
+    // Also search workspace node_modules (works even without workspace package.json)
+    if (workspacePath) {
+        searchPaths.push(path.join(workspacePath, "node_modules"));
+    }
+    searchPaths.push(path.join(process.cwd(), "node_modules"));
+    // Also search from flowseeker's own install location (sibling/global-like path)
+    const flowseekerDir = getFlowseekerPackageDir();
+    if (flowseekerDir) {
+        // flowseekerDir is e.g. /usr/lib/node_modules/flowseeker
+        // The sibling would be /usr/lib/node_modules/flowseeker-local
+        const parentNodeModules = path.dirname(flowseekerDir);
+        searchPaths.push(parentNodeModules);
+    }
+    // Also try global npm prefix
+    const globalDir = getGlobalModulesDir();
+    if (globalDir)
+        searchPaths.push(globalDir);
+    // Extra search paths for unusual setups / smoke testing (semicolon-separated)
+    const extraPaths = process.env.FLOWSEEKER_LOCAL_SEARCH_PATHS;
+    if (extraPaths) {
+        searchPaths.push(...extraPaths.split(";").map(s => s.trim()).filter(Boolean));
+    }
+    let resolvedPath;
+    for (const base of searchPaths) {
+        try {
+            const pkgJsonPath = path.join(base, "package.json");
+            // For pure directory paths (like global node_modules), check filesystem first
+            if (fs.existsSync(path.join(base, "flowseeker-local", "package.json"))) {
+                resolvedPath = path.join(base, "flowseeker-local", "package.json");
+                break;
+            }
+            // Then try require.resolve if package.json exists at base
+            let reqPath = pkgJsonPath;
+            if (!fs.existsSync(pkgJsonPath)) {
+                // Try to resolve from a dummy package.json in the base
+                reqPath = path.join(base, "flowseeker-local", "package.json");
+                if (!fs.existsSync(reqPath))
+                    continue;
+            }
+            const req = (0, module_1.createRequire)(reqPath);
+            resolvedPath = req.resolve("flowseeker-local");
+            break;
+        }
+        catch { /* not found in this path */ }
+    }
+    if (!resolvedPath)
+        return { available: false, valid: false, status: "bundled_package_missing", reason: "flowseeker-local package not installed. Run: npm i -g flowseeker flowseeker-local" };
+    // Resolve to package root directory
+    let pkgDir = resolvedPath;
+    // Walk up from resolved module to find package.json of flowseeker-local
+    for (let i = 0; i < 10; i++) {
+        const candidate = path.join(pkgDir, "package.json");
+        if (fs.existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
+                if (pkg.name === "flowseeker-local") {
+                    pkgDir = path.dirname(candidate);
+                    break;
+                }
+            }
+            catch { /* keep walking */ }
+        }
+        const parent = path.dirname(pkgDir);
+        if (parent === pkgDir)
+            break;
+        pkgDir = parent;
+    }
+    return resolveBundledPackage(pkgDir);
+}
+function resolveBundledPackage(pkgDir) {
+    // Look for a manifest file
+    const manifestCandidates = ["model-manifest.json", "manifest.json", ".flowseeker/manifest.json"];
+    let manifestPath;
+    for (const mc of manifestCandidates) {
+        const mp = path.join(pkgDir, mc);
+        if (fs.existsSync(mp)) {
+            manifestPath = mp;
+            break;
+        }
+    }
+    if (!manifestPath)
+        return { available: true, valid: false, status: "bundled_package_invalid", packagePath: pkgDir, reason: "flowseeker-local package found but no model manifest found." };
+    return validatePackageManifest(manifestPath, pkgDir);
+}
+function validatePackageManifest(manifestPath, packageDir) {
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    }
+    catch {
+        return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Manifest is not valid JSON." };
+    }
+    const status = String(manifest.status || "");
+    if (status !== "ready" && status !== "downloaded") {
+        return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Manifest status is not ready/downloaded: " + (status || "empty") };
+    }
+    const dims = Number(manifest.dimensions);
+    if (isNaN(dims) || dims <= 0) {
+        return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Invalid dimensions in manifest." };
+    }
+    const artifacts = manifest.artifacts;
+    if (!artifacts || typeof artifacts !== "object" || Object.keys(artifacts).length === 0) {
+        return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "No artifacts in manifest." };
+    }
+    const modelBase = path.dirname(manifestPath);
+    for (const [key, artifactPath] of Object.entries(artifacts)) {
+        if (typeof artifactPath !== "string" || !artifactPath) {
+            return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Artifact '" + key + "' has empty or non-string path." };
+        }
+        if (artifactPath.includes("..") || path.isAbsolute(artifactPath)) {
+            return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Artifact '" + key + "' path traversal detected." };
+        }
+        const resolved = path.resolve(path.join(modelBase, artifactPath));
+        if (!resolved.startsWith(path.resolve(modelBase) + path.sep) && resolved !== path.resolve(modelBase)) {
+            return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Artifact '" + key + "' escapes model directory." };
+        }
+        try {
+            fs.accessSync(resolved);
+        }
+        catch {
+            return { available: true, valid: false, status: "bundled_package_invalid", manifestPath, packagePath: packageDir, reason: "Artifact '" + key + "' file missing: " + artifactPath };
+        }
+    }
+    const modelId = String(manifest.modelId || manifest.modelSlug || "");
+    return {
+        available: true,
+        valid: true,
+        status: "bundled_package_ready",
+        modelId,
+        dimensions: dims,
+        packagePath: packageDir,
+        manifestPath
+    };
+}
+function deployBundledModel(packageModelDir, packageRoot) {
+    const srcDir = path.join(packageModelDir, "models");
+    if (!fs.existsSync(srcDir))
+        return;
+    // Find @huggingface/transformers package directory
+    let tfDir = "";
+    try {
+        const req = (0, module_1.createRequire)(path.join(packageRoot, "package.json"));
+        const tfMain = req.resolve("@huggingface/transformers");
+        let d = path.dirname(tfMain);
+        for (let i = 0; i < 10; i++) {
+            if (fs.existsSync(path.join(d, "package.json"))) {
+                const pkg = JSON.parse(fs.readFileSync(path.join(d, "package.json"), "utf8"));
+                if (pkg.name === "@huggingface/transformers") {
+                    tfDir = d;
+                    break;
+                }
+            }
+            const parent = path.dirname(d);
+            if (parent === d)
+                break;
+            d = parent;
+        }
+    }
+    catch {
+        return;
+    }
+    if (!tfDir)
+        return;
+    const dstDir = path.join(tfDir, "models");
+    // Only copy if not already present
+    if (!fs.existsSync(path.join(dstDir, "sentence-transformers"))) {
+        copyDirSync(srcDir, dstDir);
+    }
+}
+function copyDirSync(src, dst) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dst, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const dstPath = path.join(dst, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, dstPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, dstPath);
+        }
+    }
+}
+function createLocalEmbeddingProvider(workspacePath, config) {
+    const runtimeRoot = config.packageRoot || workspacePath;
+    return {
+        name: "local",
+        model: config.modelId,
+        dimensions: config.dimensions,
+        async embedTexts(texts) {
+            const workspaceRequire = (0, module_1.createRequire)(path.join(runtimeRoot, "package.json"));
+            let transformers;
+            try {
+                transformers = workspaceRequire("@huggingface/transformers");
+            }
+            catch (e) {
+                // Fallback: try scaffold-runtime.js in the package root (self-contained fake runtime)
+                if (config.packageRoot) {
+                    const scaffoldPath = path.join(config.packageRoot, "scaffold-runtime.js");
+                    if (fs.existsSync(scaffoldPath)) {
+                        transformers = require(scaffoldPath);
+                    }
+                }
+                if (!transformers) {
+                    throw new Error("Local embedding runtime (@huggingface/transformers) is not installed in this project. Run flowseeker semantic local setup.");
+                }
+            }
+            const pipeline = transformers.pipeline || transformers.default?.pipeline;
+            if (typeof pipeline !== "function") {
+                throw new Error("Local runtime does not export pipeline. Check @huggingface/transformers installation in your project.");
+            }
+            // For bundled packages, deploy model files to Transformers.js expected location at runtime
+            if (config.packageRoot) {
+                deployBundledModel(config.modelPath, runtimeRoot);
+            }
+            const extractor = await pipeline("feature-extraction", config.modelId, {
+                local_files_only: true,
+                cache_dir: config.modelPath,
+            });
+            let raw;
+            try {
+                // Transformers.js v2 returns {__call__: fn}, v3 returns callable object, v4: callable with kwargs
+                const callFn = typeof extractor === "function" ? extractor : extractor?.__call__;
+                if (typeof callFn !== "function")
+                    throw new Error("extractor is not callable");
+                raw = await callFn(texts.length === 1 ? texts[0] : texts, { pooling: "mean", normalize: true });
+            }
+            catch (e) {
+                throw new Error("Local embedding extraction failed: " + (e instanceof Error ? e.message : String(e)));
+            }
+            return normalizeEmbeddings(raw, texts.length, config.dimensions);
+        }
+    };
+}
+function normalizeEmbeddings(raw, expectedCount, expectedDims) {
+    // Extract a flat array from raw tensor-like output
+    let flatVec = null;
+    if (raw?.data) {
+        flatVec = Array.from(raw.data);
+    }
+    else if (typeof raw?.tolist === "function") {
+        flatVec = raw.tolist();
+    }
+    else if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "number") {
+        flatVec = raw;
+    }
+    // If we got a single flat vector that matches expected dimensions,
+    // return it directly (or reshape if batch)
+    if (flatVec && flatVec.length >= expectedDims) {
+        if (flatVec.length === expectedDims) {
+            if (expectedCount > 1)
+                throw new Error(`Local embedding output count mismatch: expected ${expectedCount}, got 1`);
+            if (!flatVec.every((x) => typeof x === "number" && isFinite(x))) {
+                throw new Error("Local embedding returned non-numeric or infinite values");
+            }
+            return [flatVec];
+        }
+        if (flatVec.length === expectedCount * expectedDims && expectedCount > 1) {
+            const vectors = [];
+            for (let i = 0; i < expectedCount; i++) {
+                const vec = flatVec.slice(i * expectedDims, (i + 1) * expectedDims);
+                if (!vec.every((x) => typeof x === "number" && isFinite(x))) {
+                    throw new Error("Local embedding returned non-numeric or infinite values");
+                }
+                vectors.push(vec);
+            }
+            return vectors;
+        }
+    }
+    // Unwrap top-level arrays
+    const items = Array.isArray(raw) ? raw : [raw];
+    const vectors = [];
+    for (const item of items) {
+        let vec;
+        if (Array.isArray(item)) {
+            vec = item;
+        }
+        else if (item?.data) {
+            // Tensor-like: { data: Float32Array | number[] }
+            vec = Array.from(item.data);
+        }
+        else if (typeof item?.tolist === "function") {
+            vec = item.tolist();
+        }
+        else if (typeof item === "object" && item !== null) {
+            // Try numeric object keys
+            const keys = Object.keys(item).map(Number).filter(k => !isNaN(k)).sort((a, b) => a - b);
+            if (keys.length > 0 && keys[0] === 0 && keys[keys.length - 1] === keys.length - 1) {
+                vec = keys.map(k => Number(item[k]));
+            }
+            else {
+                throw new Error("Local embedding output has unrecognized format: " + JSON.stringify(item).slice(0, 200));
+            }
+        }
+        else {
+            throw new Error("Local embedding output has unrecognized format: " + typeof item);
+        }
+        if (vec.length === 0)
+            throw new Error("Local embedding returned empty vector");
+        if (!vec.every((x) => typeof x === "number" && isFinite(x))) {
+            throw new Error("Local embedding returned non-numeric or infinite values");
+        }
+        if (expectedDims > 0 && vec.length !== expectedDims) {
+            throw new Error(`Local embedding dimension mismatch: expected ${expectedDims}, got ${vec.length}`);
+        }
+        vectors.push(vec);
+    }
+    if (vectors.length !== expectedCount) {
+        throw new Error(`Local embedding output count mismatch: expected ${expectedCount}, got ${vectors.length}`);
+    }
+    return vectors;
+}
+function createOpenAICompatibleEmbeddingProvider(options) {
+    const baseUrl = options.baseUrl.replace(/\/+$/, "") || "https://api.openai.com/v1";
+    let authFailed = false; // Fail-fast: skip all subsequent calls after first 401
+    return {
+        name: "openaiCompatible",
+        model: options.model,
+        async embedTexts(texts, requestOptions) {
+            if (authFailed)
+                throw new Error("Embedding provider auth previously failed — skipping all requests");
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+            requestOptions?.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+            try {
+                const isGemini = baseUrl.includes("generativelanguage.googleapis.com");
+                const url = isGemini
+                    ? `${baseUrl}/embeddings?key=${encodeURIComponent(options.apiKey)}`
+                    : `${baseUrl}/embeddings`;
+                const headers = { "content-type": "application/json" };
+                if (!isGemini) {
+                    headers.authorization = `Bearer ${options.apiKey}`;
+                }
+                // Rate limit: process in small batches (~8 texts/batch, ~400 tokens/batch)
+                // to stay under typical 100K tokens/minute rate limits
+                const batchSize = 8;
+                const results = new Array(texts.length);
+                for (let i = 0; i < texts.length; i += batchSize) {
+                    const batch = texts.slice(i, i + batchSize);
+                    let lastError = "";
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        try {
+                            const response = await fetch(url, {
+                                method: "POST",
+                                headers,
+                                body: JSON.stringify({ model: options.model, input: batch }),
+                                signal: controller.signal
+                            });
+                            if (response.status === 429 && attempt < 2) {
+                                lastError = await response.text().catch(() => "rate limited");
+                                await new Promise(r => setTimeout(r, 5000 * (attempt + 1)));
+                                continue;
+                            }
+                            // Fail-fast on auth errors: mark provider dead, don't retry
+                            if (response.status === 401 || response.status === 403) {
+                                authFailed = true;
+                                const body = await response.text().catch(() => "");
+                                throw new Error(`Embedding auth failed: HTTP ${response.status} — ${body.slice(0, 300)}`);
+                            }
+                            if (!response.ok) {
+                                const body = await response.text().catch(() => "");
+                                throw new Error(`Embedding request failed: HTTP ${response.status}${body ? ` — ${body.slice(0, 200)}` : ""}`);
+                            }
+                            const payload = await response.json();
+                            const embeddings = payload.data?.map((item) => item.embedding).filter((item) => Array.isArray(item));
+                            if (!embeddings || embeddings.length !== batch.length) {
+                                // Fallback: try Gemini response format
+                                const geminiEmbeddings = payload?.embeddings?.map((e) => e.values)?.filter((e) => Array.isArray(e));
+                                if (geminiEmbeddings && geminiEmbeddings.length === batch.length) {
+                                    geminiEmbeddings.forEach((vec, idx) => { results[i + idx] = vec; });
+                                    break;
+                                }
+                                throw new Error("Embedding response did not match requested input count.");
+                            }
+                            embeddings.forEach((vec, idx) => { results[i + idx] = vec; });
+                            break;
+                        }
+                        catch (e) {
+                            const msg = e instanceof Error ? e.message : String(e);
+                            if (attempt === 2 || (!msg.includes("429") && !msg.includes("rate")))
+                                throw e;
+                            lastError = msg;
+                            await new Promise(r => setTimeout(r, 5000 * (attempt + 1)));
+                        }
+                    }
+                    // Delay between batches: ~3s for 8 texts ≈ 400 tokens = well under 100K/min
+                    if (i + batchSize < texts.length) {
+                        await new Promise(r => setTimeout(r, 3000));
+                    }
+                }
+                return results.filter((r) => Array.isArray(r));
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+    };
+}
+function createGeminiEmbeddingProvider(options) {
+    const modelId = options.model || "gemini-embedding-001";
+    let authFailed = false;
+    return {
+        name: "gemini",
+        model: options.model,
+        async embedTexts(texts, requestOptions) {
+            if (authFailed)
+                throw new Error("Embedding provider auth previously failed — skipping all requests");
+            const controller = new AbortController();
+            const timeoutTimer = setTimeout(() => controller.abort(), options.timeoutMs);
+            requestOptions?.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+            try {
+                // Gemini embedContent has low free-tier rate limits (~5 RPM)
+                // Process sequentially with 1.5s delay between requests
+                const results = new Array(texts.length);
+                for (let i = 0; i < texts.length; i++) {
+                    const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:embedContent?key=${encodeURIComponent(options.apiKey)}`;
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        try {
+                            const response = await fetch(url, {
+                                method: "POST",
+                                headers: { "content-type": "application/json" },
+                                body: JSON.stringify({
+                                    model: `models/${modelId}`,
+                                    content: { parts: [{ text: texts[i] }] }
+                                }),
+                                signal: controller.signal
+                            });
+                            if (response.status === 429 && attempt < 2) {
+                                await new Promise(r => setTimeout(r, 3000 * (attempt + 1)));
+                                continue;
+                            }
+                            if (response.status === 401 || response.status === 403) {
+                                authFailed = true;
+                                const body = await response.text().catch(() => "");
+                                throw new Error(`Gemini embedding auth failed: HTTP ${response.status} — ${body.slice(0, 300)}`);
+                            }
+                            if (!response.ok) {
+                                const body = await response.text().catch(() => "");
+                                throw new Error(`Gemini embedding failed: HTTP ${response.status} — ${body.slice(0, 300)}`);
+                            }
+                            const payload = await response.json();
+                            const embedding = payload.embedding?.values;
+                            if (!embedding || !Array.isArray(embedding)) {
+                                throw new Error("Gemini response missing embedding values");
+                            }
+                            results[i] = embedding;
+                            break;
+                        }
+                        catch (e) {
+                            if (attempt === 2 || (e instanceof Error && !e.message.includes("429")))
+                                throw e;
+                            await new Promise(r => setTimeout(r, 3000 * (attempt + 1)));
+                        }
+                    }
+                    // Rate limit: 1 request per 1.5s
+                    if (i < texts.length - 1) {
+                        await new Promise(r => setTimeout(r, 1500));
+                    }
+                }
+                return results.filter((r) => Array.isArray(r));
+            }
+            finally {
+                clearTimeout(timeoutTimer);
+            }
+        }
+    };
+}
+// Deterministic test embedding provider — zero network, pure term-hash vectors.
+// Produces 128-dim vectors from token hashing so cosine similarity ≈ term overlap.
+// Only for pipeline smoke/proof; never use in production.
+const DET_DIM = 128;
+const DET_BITS_PER_TERM = 7;
+function createDeterministicEmbeddingProvider(model) {
+    return {
+        name: "deterministicTest",
+        model,
+        dimensions: DET_DIM,
+        async embedTexts(texts, _requestOptions) {
+            return texts.map((text) => deterministicEmbed(text));
+        }
+    };
+}
+function deterministicEmbed(text) {
+    const vec = new Array(DET_DIM).fill(0);
+    const tokens = tokenizeForEmbedding(text);
+    for (const token of tokens) {
+        const h = hashStr(token);
+        for (let b = 0; b < DET_BITS_PER_TERM; b++) {
+            const dim = ((h >> (b * 5)) & 0x7f) % DET_DIM; // 0..127
+            const sign = ((h >> (b * 5 + 4)) & 1) ? 1 : -1;
+            vec[dim] += sign;
+        }
+    }
+    // L2 normalize
+    let norm = 0;
+    for (let i = 0; i < DET_DIM; i++)
+        norm += vec[i] * vec[i];
+    norm = Math.sqrt(norm) || 1;
+    for (let i = 0; i < DET_DIM; i++)
+        vec[i] /= norm;
+    return vec;
+}
+function tokenizeForEmbedding(text) {
+    const lower = text.toLowerCase();
+    const tokens = [];
+    // Extract identifiers, paths, words
+    const wordRe = /[a-z0-9_]{2,}/g;
+    let m;
+    while ((m = wordRe.exec(lower)) !== null) {
+        tokens.push(m[0]);
+        // Also add bigrams for path-like strings
+        if (m[0].length >= 5) {
+            for (let i = 0; i < m[0].length - 1; i++) {
+                tokens.push(m[0].slice(i, i + 2));
+            }
+        }
+    }
+    // Path segments
+    for (const seg of lower.split(/[/\\]/)) {
+        if (seg.length >= 2)
+            tokens.push(seg);
+    }
+    return [...new Set(tokens)];
+}
+function hashStr(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+        h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+    }
+    return h >>> 0; // unsigned 32-bit
+}
+function createConfiguredEmbeddingProvider(config, options) {
+    (0, env_1.loadEnvFiles)();
+    // Deterministic test provider — no network, no API key needed
+    if (config.semanticProvider === "deterministicTest") {
+        return createDeterministicEmbeddingProvider(config.semanticModel || "deterministic-term-v1");
+    }
+    // Local provider — no API key, gated by runtime/model readiness
+    if (config.semanticProvider === "local") {
+        const workspacePath = config.workspacePath;
+        if (!workspacePath)
+            return undefined;
+        const readiness = getLocalProviderReadiness(workspacePath, {
+            semanticModel: config.semanticModel,
+            semanticLocalModelPath: config.semanticLocalModelPath,
+            semanticDimensions: config.semanticDimensions
+        });
+        // Bundled package path
+        if (readiness.localStatus === "bundled_package_ready") {
+            const bundled = detectBundledLocalPackage(workspacePath);
+            if (bundled.valid && bundled.packagePath && bundled.modelId) {
+                return createLocalEmbeddingProvider(workspacePath, {
+                    modelId: bundled.modelId,
+                    modelPath: bundled.packagePath,
+                    dimensions: bundled.dimensions || 0,
+                    packageRoot: bundled.packagePath
+                });
+            }
+            return undefined;
+        }
+        if (readiness.localStatus !== "local_ready")
+            return undefined;
+        // Read manifest for trusted model id and dimensions
+        let modelId = config.semanticModel || "sentence-transformers/all-MiniLM-L6-v2";
+        let dims = config.semanticDimensions || 0;
+        const modelPath = config.semanticLocalModelPath || "";
+        if (modelPath) {
+            try {
+                const manifestRaw = fs.readFileSync(path.join(modelPath, "manifest.json"), "utf8");
+                const manifest = JSON.parse(manifestRaw);
+                if (manifest.modelId && typeof manifest.modelId === "string")
+                    modelId = manifest.modelId;
+                if (manifest.dimensions !== undefined && typeof manifest.dimensions === "number" && manifest.dimensions > 0)
+                    dims = manifest.dimensions;
+            }
+            catch { /* use config values as fallback */ }
+        }
+        // Prefer explicit semanticLocalModelId over manifest modelId
+        if (config.semanticLocalModelId)
+            modelId = config.semanticLocalModelId;
+        return createLocalEmbeddingProvider(workspacePath, {
+            modelId,
+            modelPath,
+            dimensions: dims
+        });
+    }
+    const apiKey = process.env[config.semanticApiKeyEnv];
+    if (!apiKey) {
+        return undefined;
+    }
+    // Detect Gemini provider by base URL or model name
+    if (config.semanticBaseUrl.includes("generativelanguage.googleapis.com") ||
+        config.semanticModel.includes("embedding-") ||
+        config.semanticModel.includes("gemini")) {
+        return createGeminiEmbeddingProvider({
+            apiKey,
+            baseUrl: config.semanticBaseUrl,
+            model: config.semanticModel,
+            timeoutMs: config.semanticTimeoutMs
+        });
+    }
+    return createOpenAICompatibleEmbeddingProvider({
+        apiKey,
+        baseUrl: config.semanticBaseUrl,
+        model: config.semanticModel,
+        timeoutMs: config.semanticTimeoutMs
+    });
+}
+//# sourceMappingURL=embeddingProviders.js.map