opencode-rag-plugin 1.15.1 → 1.17.2

package/dist/core/version-check.js

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Version check and self-update functionality. Checks GitHub
+ * releases for new versions and installs the newest version via npm, then
+ * re-syncs the OpenCode runtime junctions.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { setupRuntime } from "./setup-runtime.js";
+/** npm package name (must match the `name` field in package.json). */
+const PACKAGE_NAME = "opencode-rag-plugin";
+/** GitHub repo used for release checks (owner/repo). */
+const GITHUB_REPO = "MrDoe/OpenCodeRAG";
+const GITHUB_API_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+/**
+ * Read the current version from the package.json sitting next to this module.
+ *
+ * Resolves the package root via `import.meta.url` so it works both from the
+ * source tree and from the compiled `dist/` output. Returns `"0.0.0"` if the
+ * file cannot be read or parsed (best-effort — never throws).
+ *
+ * @returns The current package version string.
+ */
+export function getCurrentVersion() {
+    try {
+        const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** Strip a leading 'v' or 'V' prefix from a version tag. */
+function normalizeVersion(tag) {
+    return tag.replace(/^v/i, "");
+}
+/**
+ * Compare two semver-ish strings.
+ * @returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+export function compareVersions(a, b) {
+    const pa = a.split(".").map((s) => parseInt(s, 10));
+    const pb = b.split(".").map((s) => parseInt(s, 10));
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Check the GitHub releases API for a newer version of OpenCodeRAG.
+ *
+ * Uses a 5-second timeout; failures (network errors, non-OK responses, missing
+ * `tag_name`) are silently caught and reported as "no update available" so the
+ * caller never has to handle a rejection.
+ *
+ * @param currentVersion - The version string to compare against.
+ * @returns UpdateInfo indicating whether an update is available.
+ */
+export async function checkForUpdate(currentVersion) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await fetch(GITHUB_API_URL, {
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "opencode-rag-updater",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+        }
+        const data = (await response.json());
+        const tagName = data.tag_name;
+        if (!tagName) {
+            return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+        }
+        const latestVersion = normalizeVersion(tagName);
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
+            releaseUrl: data.html_url ?? "",
+            publishedAt: data.published_at ?? "",
+        };
+    }
+    catch {
+        return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Install the newest published version of OpenCodeRAG.
+ *
+ * Runs `npm install -g <package>@latest` to refresh the global install, then
+ * calls {@link setupRuntime} with `force: true` to re-create the
+ * `~/.opencode/node_modules/` junctions so OpenCode picks up the new build on
+ * the next restart.
+ *
+ * @param options - Optional verbosity flag. When `verbose` is true, npm output
+ *   is streamed to the console; otherwise it is captured silently. The
+ *   `_execSync` and `_setupRuntime` seams are for testing only.
+ * @returns An {@link InstallUpdateResult} with success status, message, and the
+ *   from/to versions.
+ */
+export async function installLatestUpdate(options) {
+    const verbose = options?.verbose ?? false;
+    const stdio = verbose ? "inherit" : "pipe";
+    const run = options?._execSync ?? execSync;
+    const syncRuntime = options?._setupRuntime ?? setupRuntime;
+    const readVersion = options?._getCurrentVersion ?? getCurrentVersion;
+    const fromVersion = readVersion();
+    try {
+        run(`npm install -g ${PACKAGE_NAME}@latest --no-fund --no-audit`, {
+            stdio,
+            timeout: 120_000,
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `npm install failed: ${err.message}`,
+            fromVersion,
+        };
+    }
+    const toVersion = readVersion();
+    const result = await syncRuntime({ force: true, silent: !verbose, version: toVersion });
+    if (!result.success) {
+        return {
+            success: false,
+            message: `installed v${toVersion} but runtime sync failed: ${result.errors.join("; ")}. Run \`opencode-rag setup\` to retry.`,
+            fromVersion,
+            toVersion,
+        };
+    }
+    if (compareVersions(toVersion, fromVersion) <= 0) {
+        return {
+            success: true,
+            message: `Already up-to-date (v${toVersion}). Runtime re-synced.`,
+            fromVersion,
+            toVersion,
+        };
+    }
+    return {
+        success: true,
+        message: `Updated v${fromVersion} → v${toVersion}. Restart OpenCode to load the new version.`,
+        fromVersion,
+        toVersion,
+    };
+}
+//# sourceMappingURL=version-check.js.map

package/dist/describer/anthropic.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Anthropic Messages API description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that uses Anthropic's Messages API to generate natural-language descriptions of code chunks.
@@ -18,7 +18,7 @@ export declare class AnthropicDescriptionProvider implements DescriptionProvider
     /** @inheritdoc */
     generateDescription(chunk: Chunk): Promise<string>;
     /** @inheritdoc */
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     /**
      * Sends a request to the Anthropic Messages API with retry and exponential backoff.
      * The system prompt is combined with all user messages into a single message payload, and

package/dist/describer/anthropic.js

@@ -25,11 +25,11 @@ export class AnthropicDescriptionProvider {
         return this.chatRequest(messages, this.config.timeoutMs ?? 60000);
     }
     /** @inheritdoc */
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => console.log(msg), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -45,11 +45,9 @@ export class AnthropicDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`[describer] Progress: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`[describer] Descriptions generated: ${result.size}/${total}`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     /**

package/dist/describer/describer.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview OpenAI-compatible LLM description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that works with any OpenAI-compatible chat API (including Ollama).
@@ -18,7 +18,7 @@ export declare class LlmDescriptionProvider implements DescriptionProvider {
     /** @inheritdoc */
     generateDescription(chunk: Chunk): Promise<string>;
     /** @inheritdoc */
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     /**
      * Sends a chat completion request to the LLM API with retry and exponential backoff.
      * For Ollama, uses the `/api/chat` endpoint with streaming disabled; otherwise uses the standard `/v1/chat/completions` endpoint.

package/dist/describer/describer.js

@@ -2,7 +2,7 @@ import { postJson } from "../embedder/http.js";
 import { buildUserMessage, sleep } from "./shared.js";
 import pLimit from "p-limit";
 /** HTTP status codes that are safe to retry on. */
-const RETRYABLE_STATUSES = new Set([404, 408, 429, 500, 502, 503, 504]);
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
 /**
  * Description provider that works with any OpenAI-compatible chat API (including Ollama).
  *
@@ -26,11 +26,11 @@ export class LlmDescriptionProvider {
         return this.chatRequest(messages, this.config.timeoutMs ?? 60000);
     }
     /** @inheritdoc */
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`Generating descriptions for ${total} chunks via ${this.config.provider}/${this.config.model} (concurrency: ${concurrency})...`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks via ${this.config.provider}/${this.config.model} (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -46,11 +46,9 @@ export class LlmDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`Descriptions: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`Descriptions: ${result.size}/${total} done.`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     /**

package/dist/describer/gemini.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Google Gemini description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that uses Google Gemini's generateContent API to describe code chunks.
@@ -12,6 +12,6 @@ export declare class GeminiDescriptionProvider implements DescriptionProvider {
     private readonly config;
     constructor(config: DescriptionConfig);
     generateDescription(chunk: Chunk): Promise<string>;
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     private chatRequest;
 }

package/dist/describer/gemini.js

@@ -21,11 +21,11 @@ export class GeminiDescriptionProvider {
         ];
         return this.chatRequest(contents, this.config.timeoutMs ?? 60000);
     }
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => console.log(msg), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -41,11 +41,9 @@ export class GeminiDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`[describer] Progress: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`[describer] Descriptions generated: ${result.size}/${total}`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     async chatRequest(contents, timeoutMs) {

package/dist/embedder/cohere.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - Cohere API base URL
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export declare class CohereProvider implements EmbeddingProvider {

package/dist/embedder/cohere.js

@@ -5,7 +5,7 @@ import { postJson } from "./http.js";
  * @param baseUrl - Cohere API base URL
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export class CohereProvider {
@@ -15,7 +15,7 @@ export class CohereProvider {
     apiKey;
     timeoutMs;
     proxy;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/embedder/factory.d.ts

@@ -27,6 +27,8 @@ export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
  * @param batchSize - Number of texts per batch (default 10)
  * @param purpose - Optional hint for query vs. document embedding
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
+ * @param onProgress - Optional callback invoked after each batch with the running
+ *   completed count and total; per-text granularity when `concurrency <= 1`.
  * @returns A promise resolving to a flat array of embedding vectors (one per input text)
  */
-export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number): Promise<number[][]>;
+export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void): Promise<number[][]>;

package/dist/embedder/factory.js

@@ -16,7 +16,7 @@ import pLimit from "p-limit";
  */
 export function createEmbedder(config) {
     const { provider, baseUrl, model, apiKey, proxy, timeoutMs } = config.embedding;
-    const effectiveTimeoutMs = timeoutMs ?? 30000;
+    const effectiveTimeoutMs = timeoutMs ?? 120000;
     if (provider === "ollama") {
         return new OllamaProvider(baseUrl, model, apiKey, effectiveTimeoutMs, proxy, config.logging.level);
     }
@@ -46,9 +46,11 @@ export function createEmbedder(config) {
  * @param batchSize - Number of texts per batch (default 10)
  * @param purpose - Optional hint for query vs. document embedding
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
+ * @param onProgress - Optional callback invoked after each batch with the running
+ *   completed count and total; per-text granularity when `concurrency <= 1`.
  * @returns A promise resolving to a flat array of embedding vectors (one per input text)
  */
-export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1) {
+export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress) {
     if (texts.length === 0)
         return [];
     const batches = [];
@@ -60,12 +62,16 @@ export async function embedBatch(embedder, texts, batchSize = 10, purpose, concu
         for (const batch of batches) {
             const embeddings = await embedder.embed(batch.texts, purpose);
             results.push(...embeddings);
+            onProgress?.(results.length, texts.length);
         }
         return results;
     }
     const limit = pLimit(concurrency);
+    let completedCount = 0;
     const batchResults = await Promise.all(batches.map((batch) => limit(async () => {
         const embeddings = await embedder.embed(batch.texts, purpose);
+        completedCount += embeddings.length;
+        onProgress?.(completedCount, texts.length);
         return { index: batch.index, embeddings };
     })));
     batchResults.sort((a, b) => a.index - b.index);

package/dist/embedder/health.js

@@ -4,7 +4,7 @@ import { postJson } from "./http.js";
  * Returns one result per configured model (embedding + description + image_description if enabled).
  */
 export async function checkProviderHealth(config) {
-    const timeoutMs = config.embedding.timeoutMs ?? 30000;
+    const timeoutMs = config.embedding.timeoutMs ?? 120000;
     const checks = [
         checkEmbeddingModel(config, timeoutMs),
     ];
@@ -328,6 +328,10 @@ export async function pullOllamaModels(models, onProgress) {
                 }
             }
             finally {
+                try {
+                    await reader.cancel();
+                }
+                catch { }
                 reader.releaseLock();
             }
         }

package/dist/embedder/http.d.ts

@@ -58,4 +58,4 @@ export declare function directRequest(url: URL, body: unknown, headers: Record<s
  * @param proxy - Optional proxy configuration
  * @returns A promise resolving to an HttpResponseLike
  */
-export declare function postJson(urlString: string, body: unknown, headers: Record<string, string>, timeoutMs: number, proxy?: ProxyConfig): Promise<HttpResponseLike>;
+export declare function postJson(urlString: string, body: unknown, headers: Record<string, string>, timeoutMs: number, proxy?: ProxyConfig, signal?: AbortSignal): Promise<HttpResponseLike>;

package/dist/embedder/http.js

@@ -6,6 +6,10 @@ import tls from "node:tls";
 const MAX_POOL_SIZE = 4;
 const IDLE_TIMEOUT_MS = 30000;
 const connectionPool = new Map();
+// Serialize proxied fetch requests that mutate process.env,
+// preventing races when concurrent requests interleave
+// set/restore of HTTP_PROXY/HTTPS_PROXY.
+let proxyRequestQueue = Promise.resolve(undefined);
 function poolKey(host, port, isHttps) {
     return `${isHttps ? "tls" : "tcp"}:${host}:${port}`;
 }
@@ -43,7 +47,13 @@ function releaseConnection(socket, host, port, isHttps) {
             pool.splice(idx, 1);
         socket.destroy();
     }, IDLE_TIMEOUT_MS);
-    socket.removeAllListeners();
+    // Avoid removeAllListeners — that would strip the error handler
+    // and cause an unhandled crash on ECONNRESET/TLS alert.
+    socket.removeAllListeners("data");
+    socket.removeAllListeners("end");
+    socket.removeAllListeners("drain");
+    socket.removeAllListeners("error");
+    socket.on("error", () => socket.destroy());
     pool.push({ socket, idleTimer });
 }
 /** Destroy all pooled TCP/TLS sockets and clear the connection pool. */
@@ -307,9 +317,9 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
                 return;
             }
             if (isChunked) {
-                if (bodyBuffer.length >= 5) {
-                    const tail = bodyBuffer.slice(-7).toString("ascii");
-                    if (tail === "\r\n0\r\n\r\n" || bodyBuffer.toString("ascii") === "0\r\n\r\n") {
+                if (bodyBuffer.length >= 7) {
+                    const ascii = bodyBuffer.toString("ascii");
+                    if (/0(?:;[^\n]*)?\r\n(?:[^\n]+:[^\n]*\r\n)*\r\n$/.test(ascii)) {
                         settle(() => {
                             releaseOrDestroy();
                             resolve(assembled);
@@ -371,7 +381,15 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
                 },
             };
         }
-        return sendRawHttpRequest(new URL(location, url), body, headers, timeoutMs, redirectCount + 1);
+        const redirectUrl = new URL(location, url);
+        const sameOrigin = url.protocol === redirectUrl.protocol &&
+            url.hostname === redirectUrl.hostname &&
+            (url.port || (url.protocol === "https:" ? "443" : "80")) ===
+                (redirectUrl.port || (redirectUrl.protocol === "https:" ? "443" : "80"));
+        const safeHeaders = sameOrigin
+            ? headers
+            : Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== "authorization"));
+        return sendRawHttpRequest(redirectUrl, body, safeHeaders, timeoutMs, redirectCount + 1);
     }
     const text = response.body.toString("utf8");
     return {
@@ -399,52 +417,65 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
  * @param proxy - Optional proxy configuration
  * @returns A promise resolving to an HttpResponseLike
  */
-export async function postJson(urlString, body, headers, timeoutMs, proxy) {
+export async function postJson(urlString, body, headers, timeoutMs, proxy, signal) {
     const url = new URL(urlString);
     const bypassProxy = isLocalhost(url.hostname) || matchesNoProxy(url.hostname, proxy?.noProxy);
     if (bypassProxy || !proxy?.url) {
         return directRequest(url, body, headers, timeoutMs);
     }
-    return postJsonViaFetch(urlString, body, headers, timeoutMs, proxy);
+    return postJsonViaFetch(urlString, body, headers, timeoutMs, proxy, signal);
 }
 /** Send JSON via the global `fetch` API with proxy environment variable overrides. */
-async function postJsonViaFetch(urlString, body, headers, timeoutMs, proxy) {
+async function postJsonViaFetch(urlString, body, headers, timeoutMs, proxy, signal) {
     const authHeader = buildProxyAuthHeader(proxy);
     const envOverride = applyProxyEnv(proxy);
-    const savedHttpProxy = process.env.HTTP_PROXY;
-    const savedHttpsProxy = process.env.HTTPS_PROXY;
-    try {
-        if (envOverride) {
-            process.env.HTTP_PROXY = envOverride.httpProxy;
-            process.env.HTTPS_PROXY = envOverride.httpsProxy;
-        }
-        const requestHeaders = {
-            "Content-Type": "application/json",
-            ...headers,
-        };
-        if (authHeader) {
-            requestHeaders["Proxy-Authorization"] = authHeader;
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(urlString, {
-                method: "POST",
-                headers: requestHeaders,
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            return response;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    finally {
-        if (envOverride) {
-            process.env.HTTP_PROXY = savedHttpProxy;
-            process.env.HTTPS_PROXY = savedHttpsProxy;
-        }
-    }
+    // Serialize fetch requests that mutate process.env to prevent
+    // concurrent requests from interleaving set/restore of proxy vars.
+    const [savedHttpProxy, savedHttpsProxy] = [process.env.HTTP_PROXY, process.env.HTTPS_PROXY];
+    return new Promise((resolve, reject) => {
+        proxyRequestQueue = proxyRequestQueue.then(async () => {
+            try {
+                if (envOverride) {
+                    process.env.HTTP_PROXY = envOverride.httpProxy;
+                    process.env.HTTPS_PROXY = envOverride.httpsProxy;
+                }
+                const requestHeaders = {
+                    "Content-Type": "application/json",
+                    ...headers,
+                };
+                if (authHeader) {
+                    requestHeaders["Proxy-Authorization"] = authHeader;
+                }
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), timeoutMs);
+                const onAbort = () => { controller.abort(); clearTimeout(timeout); };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                try {
+                    const response = await fetch(urlString, {
+                        method: "POST",
+                        headers: requestHeaders,
+                        body: JSON.stringify(body),
+                        signal: controller.signal,
+                    });
+                    resolve(response);
+                }
+                finally {
+                    clearTimeout(timeout);
+                    signal?.removeEventListener("abort", onAbort);
+                    if (envOverride) {
+                        process.env.HTTP_PROXY = savedHttpProxy;
+                        process.env.HTTPS_PROXY = savedHttpsProxy;
+                    }
+                }
+            }
+            catch (err) {
+                if (envOverride) {
+                    process.env.HTTP_PROXY = savedHttpProxy;
+                    process.env.HTTPS_PROXY = savedHttpsProxy;
+                }
+                reject(err);
+            }
+        });
+    });
 }
 //# sourceMappingURL=http.js.map

package/dist/embedder/ollama.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - Ollama server base URL (e.g. http://localhost:11434)
  * @param model - Model name to use for embedding
  * @param apiKey - Optional API key for authenticated endpoints
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+   * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  * @param logLevel - Optional logging level for debug output
  */

package/dist/embedder/ollama.js

@@ -7,7 +7,7 @@ import { appendDebugLog } from "../core/fileLogger.js";
  * @param baseUrl - Ollama server base URL (e.g. http://localhost:11434)
  * @param model - Model name to use for embedding
  * @param apiKey - Optional API key for authenticated endpoints
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+   * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  * @param logLevel - Optional logging level for debug output
  */
@@ -19,7 +19,7 @@ export class OllamaProvider {
     timeoutMs;
     proxy;
     logLevel;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy, logLevel) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy, logLevel) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/embedder/openai.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - API base URL (e.g. https://api.openai.com/v1)
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export declare class OpenAIProvider implements EmbeddingProvider {

package/dist/embedder/openai.js

@@ -16,7 +16,7 @@ function inferProviderName(baseUrl) {
  * @param baseUrl - API base URL (e.g. https://api.openai.com/v1)
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export class OpenAIProvider {
@@ -27,7 +27,7 @@ export class OpenAIProvider {
     timeoutMs;
     proxy;
     provider;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/eval/compare-merge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Compare two branch benchmark JSON outputs and produce a side-by-side
+ * analysis report (console table + markdown file).
+ *
+ * Usage: node --import tsx src/eval/compare-merge.ts
+ *   --main .opencode/rag_db/eval-results/main.json
+ *   --branch .opencode/rag_db/eval-results/t1-cosine-l2.json
+ *   --output .opencode/rag_db/eval-results/branch-compare-report.md
+ */
+export {};