opencode-rag-plugin 1.19.4 → 1.19.8

package/dist/core/config.d.ts

@@ -54,7 +54,18 @@ export interface DescriptionConfig {
     proxy?: ProxyConfig;
     /** System prompt instructing the LLM how to describe code. */
     systemPrompt: string;
-    /** Maximum chunks per batch request. */
+    /**
+     * EXPERIMENTAL: enable multi-chunk batch description requests (Ollama
+     * provider only). Off by default — each chunk is described with its own
+     * request. When enabled, up to `batchMaxChunks` chunks share one request
+     * using ordinal labels ([CHUNK 1] ... reply "1: <desc>"); small models can
+     * mangle the structured output, so batches that fail to parse fall back to
+     * individual requests and batching auto-disables after 2 consecutive
+     * failures. Part of the description manifest fingerprint — toggling it
+     * re-describes files.
+     */
+    batchEnabled?: boolean;
+    /** Maximum chunks per batch request. Only applies when `batchEnabled` is true. */
     batchMaxChunks?: number;
     /** Timeout per batch request in milliseconds. */
     batchTimeoutMs?: number;
@@ -68,6 +79,8 @@ export interface DescriptionConfig {
     think?: boolean;
     /** Context window size for the LLM. */
     numCtx?: number;
+    /** Ollama keep_alive value (e.g. "-1" for keep-in-memory) sent with /api/chat requests. */
+    keepAlive?: string;
     /** Maximum content characters sent to the LLM. Chunks exceeding this use fallback descriptions. */
     maxContentChars?: number;
 }
@@ -91,6 +104,8 @@ export interface ImageDescriptionConfig {
     think?: boolean;
     /** Context window size. */
     numCtx?: number;
+    /** Ollama keep_alive value (e.g. "-1" for keep-in-memory) sent with /api/chat requests. */
+    keepAlive?: string;
     /** Proxy configuration. */
     proxy?: ProxyConfig;
     /** Maximum image dimension (pixels) — larger images are resized before sending. */
@@ -220,6 +235,8 @@ export interface RagConfig {
         queryPrefix?: string;
         /** Cached embedding vector dimension. Probed once on first startup, then persisted to config. */
         vectorDimension?: number;
+        /** Ollama keep_alive value (e.g. "-1" for keep-in-memory) sent with /api/embed requests. */
+        keepAlive?: string;
     };
     /** Indexing pipeline controls: what to index, concurrency, batch sizes. */
     indexing: {
@@ -268,6 +285,15 @@ export interface RagConfig {
          * @default 1_048_576 (1 MB)
          */
         maxSvgSizeBytes?: number;
+        /**
+         * Run vector-store compaction + version pruning every N windows during a
+         * long index pass. LanceDB keeps every committed version on disk, so
+         * without periodic maintenance the store phase slows down as the index
+         * grows (version-manifest accumulation). 0 disables mid-run optimization
+         * (the store is still optimized once at the end of a pass).
+         * @default 8
+         */
+        optimizeIntervalWindows?: number;
     };
     /** Vector storage backend configuration. */
     vectorStore: {

package/dist/core/config.js

@@ -115,9 +115,10 @@ export const DEFAULT_CONFIG = {
         concurrency: 8,
         embedBatchSize: 100,
         embedConcurrency: 3,
-        ollamaMaxBatchSize: 500,
+        ollamaMaxBatchSize: 100,
         descriptionConcurrency: 4,
         maxSvgSizeBytes: 1_048_576,
+        optimizeIntervalWindows: 8,
     },
     vectorStore: {
         path: "./.opencode/rag_db",
@@ -169,7 +170,10 @@ export const DEFAULT_CONFIG = {
         think: false,
         numCtx: 4096,
         timeoutMs: 60000,
-        systemPrompt: "Describe this code in 2-3 sentences: purpose, key concepts, inputs/outputs, and dependencies. No code repetition.",
+        systemPrompt: "Describe this code in ONE concise sentence (max 20 words): purpose, key inputs/outputs. No code repetition.",
+        batchEnabled: false,
+        batchMaxChunks: 25,
+        batchTimeoutMs: 120000,
         batchConcurrency: 1,
         retryMax: 3,
         retryBaseDelayMs: 1000,
@@ -378,6 +382,23 @@ export function validateConfig(config) {
     if (config.memory?.autoInjectTopK != null && config.memory.autoInjectTopK < 1) {
         warnings.push("memory.autoInjectTopK must be >= 1");
     }
+    if (config.memory?.minConfidence != null) {
+        const r = config.memory.minConfidence;
+        if (r < 0 || r > 1)
+            warnings.push("memory.minConfidence must be between 0 and 1");
+    }
+    if (config.memory?.autoCaptureDedupThreshold != null) {
+        const t = config.memory.autoCaptureDedupThreshold;
+        // > 1 would make dedup reject every candidate; < 0 disables it silently
+        if (t < 0 || t > 1)
+            warnings.push("memory.autoCaptureDedupThreshold must be between 0 and 1");
+    }
+    if (config.memory?.decay && config.memory.decay.halfLifeDays <= 0) {
+        warnings.push("memory.decay.halfLifeDays must be > 0");
+    }
+    if (config.openCode.maxReadOutputChars != null && config.openCode.maxReadOutputChars <= 0) {
+        warnings.push("openCode.maxReadOutputChars must be > 0");
+    }
     if (config.openCode.maxContextChunks <= 0) {
         warnings.push("openCode.maxContextChunks must be > 0");
     }
@@ -410,6 +431,10 @@ export function validateConfig(config) {
         if (config.description.timeoutMs != null && config.description.timeoutMs <= 0) {
             warnings.push("description.timeoutMs must be > 0");
         }
+        if (config.description.batchEnabled === true) {
+            warnings.push("description.batchEnabled is EXPERIMENTAL — batching several chunks into one LLM request (Ollama only) " +
+                "is unreliable on small models; disable it if descriptions look wrong");
+        }
     }
     if (config.imageDescription) {
         if (config.imageDescription.enabled) {
@@ -480,6 +505,14 @@ export function loadConfig(filePath, validate = true) {
                 ...DEFAULT_CONFIG.retrieval.hybridSearch,
                 ...(safeObj(parsed.retrieval?.hybridSearch) ?? {}),
             },
+            // contextOptimization MUST be nested-merged too — a shallow spread
+            // would replace the whole default object with a partial user object,
+            // silently leaving maxPerFile/mergeAdjacent/similarityThreshold etc.
+            // undefined (which disables the features via NaN comparisons).
+            contextOptimization: {
+                ...DEFAULT_CONFIG.retrieval.contextOptimization,
+                ...(safeObj(parsed.retrieval?.contextOptimization) ?? {}),
+            },
         },
         openCode: (() => {
             const base = DEFAULT_CONFIG.openCode;
@@ -528,6 +561,12 @@ export function loadConfig(filePath, validate = true) {
         memory: {
             ...DEFAULT_CONFIG.memory,
             ...(safeObj(parsed.memory) ?? {}),
+            // decay is a nested object — a user config with only
+            // `memory.decay.enabled` must not lose the halfLifeDays default.
+            decay: {
+                ...DEFAULT_CONFIG.memory.decay,
+                ...(safeObj((safeObj(parsed.memory) ?? {})?.decay) ?? {}),
+            },
         },
         ui: {
             ...DEFAULT_CONFIG.ui,

package/dist/core/desc-cache.d.ts

@@ -22,8 +22,14 @@ export declare class DescriptionCache {
     has(key: string): boolean;
     /** Persist the cache to disk if dirty. Safe to call multiple times. */
     save(): Promise<void>;
-    /** Build a cache key for a code chunk. */
-    static codeKey(content: string, descConfigHash: string): string;
+    /**
+     * Build a cache key for a code chunk.
+     *
+     * The optional `context` (relative path + line range) is included because
+     * the description prompt contains the file path — identical chunk content
+     * in two different files must not reuse a contextually wrong description.
+     */
+    static codeKey(content: string, descConfigHash: string, context?: string): string;
     /** Build a cache key for an image file. */
     static imageKey(imageBytesHash: string, imageDescConfigHash: string): string;
     /** Remove old entries to stay under the limit. */

package/dist/core/desc-cache.js

@@ -89,10 +89,17 @@ export class DescriptionCache {
         });
         return this.savePromise;
     }
-    /** Build a cache key for a code chunk. */
-    static codeKey(content, descConfigHash) {
+    /**
+     * Build a cache key for a code chunk.
+     *
+     * The optional `context` (relative path + line range) is included because
+     * the description prompt contains the file path — identical chunk content
+     * in two different files must not reuse a contextually wrong description.
+     */
+    static codeKey(content, descConfigHash, context) {
         const contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
-        return contentHash + "_" + descConfigHash.slice(0, 16);
+        const contextHash = context ? createHash("sha256").update(context).digest("hex").slice(0, 8) : "";
+        return contentHash + "_" + descConfigHash.slice(0, 16) + (contextHash ? "_" + contextHash : "");
     }
     /** Build a cache key for an image file. */
     static imageKey(imageBytesHash, imageDescConfigHash) {

package/dist/core/doc-progress.js

@@ -47,17 +47,20 @@ export function markFileDocumented(storePath, filePath) {
 export function markSubdirectoryDocumented(storePath, subdir, allFilePaths) {
     const normalized = subdir.replace(/\\/g, "/").replace(/\/$/, "");
     const progress = loadDocProgress(storePath);
+    // Set lookups avoid the O(n·m) `includes` scan for large workspaces
+    const documentedSet = new Set(progress.documented);
     let changed = false;
     for (const filePath of allFilePaths) {
         const normalizedFile = filePath.replace(/\\/g, "/");
         if (normalizedFile.startsWith(normalized + "/") || normalizedFile === normalized) {
-            if (!progress.documented.includes(filePath)) {
-                progress.documented.push(filePath);
+            if (!documentedSet.has(filePath)) {
+                documentedSet.add(filePath);
                 changed = true;
             }
         }
     }
     if (changed) {
+        progress.documented = [...documentedSet];
         progress.lastUpdated = Date.now();
         saveDocProgress(storePath, progress);
     }

package/dist/core/interfaces.d.ts

@@ -157,10 +157,31 @@ export interface FileSummary {
     language: string;
     chunkCount: number;
 }
+/**
+ * A single file's chunk payload for a bulk store write.
+ * `dedup: true` removes prior-revision rows for the same file path that are
+ * not part of this write; `dedup: false` appends only (safe when writing into
+ * a freshly-created store where no rows can collide).
+ */
+export interface BulkChunkWrite {
+    chunks: Chunk[];
+    dedup: boolean;
+}
 /** Persistent vector storage and retrieval backend (LanceDB or in-memory). */
 export interface VectorStore {
-    /** Store a batch of chunks with their embeddings. */
-    addChunks(chunks: Chunk[]): Promise<void>;
+    /**
+     * Store a batch of chunks with their embeddings.
+     * @param options - `dedup: false` skips prior-revision cleanup (append-only).
+     */
+    addChunks(chunks: Chunk[], options?: {
+        dedup?: boolean;
+    }): Promise<void>;
+    /**
+     * Store chunks for multiple files in a single write transaction.
+     * Optional — stores without it fall back to per-file `addChunks` calls.
+     * @param items - Per-file chunk payloads with dedup flags.
+     */
+    addChunksBulk?(items: BulkChunkWrite[]): Promise<void>;
     /** Search for the top-K nearest neighbor chunks by embedding similarity. */
     search(embedding: number[], topK: number): Promise<SearchResult[]>;
     /** Search with optional metadata filtering. */
@@ -183,8 +204,15 @@ export interface VectorStore {
     getChunksByFilePath(filePath: string): Promise<Chunk[]>;
     /** Re-open the store, optionally pointing at a new database path. */
     reopen?(newPath?: string): Promise<void>;
-    /** Compact fragments and prune old versions to prevent version-manifest accumulation. */
-    optimize?(): Promise<void>;
+    /**
+     * Compact fragments and prune old versions to prevent version-manifest
+     * accumulation.
+     * @param options - `aggressive: true` prunes all but the current version
+     *   (only safe when no other process reads the store, e.g. temp rebuilds).
+     */
+    optimize?(options?: {
+        aggressive?: boolean;
+    }): Promise<void>;
     /**
      * Verify that the store's data is actually readable.
      * Returns false if data integrity is compromised (e.g., data files missing from disk).

package/dist/core/manifest.js

@@ -44,7 +44,7 @@ export function computeDescriptionConfigHash(config) {
         return undefined;
     const parts = [];
     if (desc) {
-        parts.push(`desc:${desc.provider}|${desc.model}|${desc.baseUrl}|${desc.systemPrompt}`);
+        parts.push(`desc:${desc.provider}|${desc.model}|${desc.baseUrl}|${desc.systemPrompt}|batch:${desc.batchEnabled === true ? 1 : 0}`);
     }
     if (img) {
         parts.push(`img:${img.provider}|${img.model}|${img.baseUrl}|${img.prompt}`);

package/dist/core/provider-defaults.d.ts

@@ -19,3 +19,5 @@ export declare const PROVIDER_DEFAULTS: Record<string, ProviderDefaults>;
 export declare function getProviderDefault(provider: string): ProviderDefaults | undefined;
 /** Check whether a given provider uses an OpenAI-compatible API format. */
 export declare function isOpenAiCompatible(provider: string): boolean;
+/** Whether the given provider can produce embeddings. */
+export declare function supportsEmbedding(provider: string): boolean;

package/dist/core/provider-defaults.js

@@ -81,11 +81,26 @@ export const PROVIDER_DEFAULTS = {
 export function getProviderDefault(provider) {
     return PROVIDER_DEFAULTS[provider];
 }
+/** OpenAI-compatible providers (embedding + chat via /v1-style APIs). */
+const OPENAI_COMPATIBLE_PROVIDERS = new Set([
+    "openai",
+    "nvidia",
+    "azure",
+    "mistral",
+    "together",
+    "groq",
+    "deepseek",
+    "fireworks",
+]);
 /** Check whether a given provider uses an OpenAI-compatible API format. */
 export function isOpenAiCompatible(provider) {
-    if (provider === "ollama" || provider === "anthropic" || provider === "google" || provider === "cohere") {
-        return false;
-    }
-    return true;
+    // Only KNOWN OpenAI-compatible providers qualify — an unknown/typo'd
+    // provider name must fail fast instead of silently attempting
+    // OpenAI-style calls against a nonsense base URL.
+    return OPENAI_COMPATIBLE_PROVIDERS.has(provider);
+}
+/** Whether the given provider can produce embeddings. */
+export function supportsEmbedding(provider) {
+    return PROVIDER_DEFAULTS[provider]?.supportsEmbedding ?? false;
 }
 //# sourceMappingURL=provider-defaults.js.map

package/dist/core/runtime-overrides.d.ts

@@ -19,12 +19,6 @@ export interface RuntimeOverrides {
             debounceMs?: number;
             watcher?: string;
         };
-        autoInject?: {
-            enabled?: boolean;
-            minScore?: number;
-            maxChunks?: number;
-            contentType?: string;
-        };
     };
     embedding?: {
         provider?: string;

package/dist/core/version-check.d.ts

@@ -45,6 +45,11 @@ type NpmRunner = (command: string, options: {
 export declare function getCurrentVersion(): string;
 /**
  * Compare two semver-ish strings.
+ *
+ * Pre-release suffixes are stripped before comparison — "1.2.3-beta.1"
+ * must compare equal to "1.2.3" (parseInt would turn "3-beta.1" into 3,
+ * and non-numeric segments into NaN which compares equal).
+ *
  * @returns 1 if a > b, -1 if a < b, 0 if equal.
  */
 export declare function compareVersions(a: string, b: string): number;

package/dist/core/version-check.js

@@ -38,11 +38,17 @@ function normalizeVersion(tag) {
 }
 /**
  * Compare two semver-ish strings.
+ *
+ * Pre-release suffixes are stripped before comparison — "1.2.3-beta.1"
+ * must compare equal to "1.2.3" (parseInt would turn "3-beta.1" into 3,
+ * and non-numeric segments into NaN which compares equal).
+ *
  * @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));
+    const clean = (s) => s.split("-", 1)[0] ?? s;
+    const pa = clean(a).split(".").map((s) => parseInt(s, 10));
+    const pb = clean(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;

package/dist/describer/anthropic.d.ts

@@ -25,8 +25,8 @@ export declare class AnthropicDescriptionProvider implements DescriptionProvider
     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
-     * the assistant placeholder is appended to elicit a completion.
+     * The system prompt is sent via the native `system` field (never concatenated into
+     * the user message, so chunk content cannot compete with it).
      *
      * @param messages - The user messages to send.
      * @param timeoutMs - Request timeout in milliseconds.

package/dist/describer/anthropic.js

@@ -59,8 +59,8 @@ export class AnthropicDescriptionProvider {
     }
     /**
      * 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
-     * the assistant placeholder is appended to elicit a completion.
+     * The system prompt is sent via the native `system` field (never concatenated into
+     * the user message, so chunk content cannot compete with it).
      *
      * @param messages - The user messages to send.
      * @param timeoutMs - Request timeout in milliseconds.
@@ -74,7 +74,8 @@ export class AnthropicDescriptionProvider {
         const body = {
             model: this.config.model,
             max_tokens: 4096,
-            messages: [{ role: "user", content: systemPrompt + "\n\n" + messages.map((m) => `${m.role}: ${m.content}`).join("\n\n") + "\n\nassistant:" }],
+            system: systemPrompt,
+            messages: messages.map((m) => ({ role: m.role, content: m.content })),
         };
         const headers = {
             "x-api-key": apiKey,
@@ -85,7 +86,20 @@ export class AnthropicDescriptionProvider {
         const retryBaseDelayMs = this.config.retryBaseDelayMs ?? 1000;
         let lastError;
         for (let attempt = 0; attempt <= retryMax; attempt++) {
-            const response = await postJson(`${baseUrl}/messages`, body, headers, timeoutMs, this.config.proxy);
+            let response;
+            try {
+                response = await postJson(`${baseUrl}/messages`, body, headers, timeoutMs, this.config.proxy);
+            }
+            catch (err) {
+                // Network-level failures (ECONNREFUSED, socket timeouts) are transient —
+                // treat them like retryable HTTP statuses.
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt === retryMax)
+                    throw lastError;
+                const delayMs = retryBaseDelayMs * Math.pow(2, attempt) * (0.8 + Math.random() * 0.4);
+                await sleep(delayMs);
+                continue;
+            }
             if (response.ok) {
                 const json = (await response.json());
                 const text = json.content?.[0]?.text;
@@ -100,7 +114,7 @@ export class AnthropicDescriptionProvider {
                 throw error;
             }
             lastError = error;
-            const delayMs = retryBaseDelayMs * Math.pow(2, attempt);
+            const delayMs = retryBaseDelayMs * Math.pow(2, attempt) * (0.8 + Math.random() * 0.4);
             await sleep(delayMs);
         }
         throw lastError ?? new Error("Anthropic LLM request failed: unknown error");

package/dist/describer/describer.d.ts

@@ -11,6 +11,10 @@ import type { DescriptionConfig } from "../core/config.js";
  */
 export declare class LlmDescriptionProvider implements DescriptionProvider {
     private readonly config;
+    /** Consecutive batches that needed individual fallback; disables batching past BATCH_MAX_STREAK. */
+    private batchFailStreak;
+    /** Whether multi-chunk batching is still active (adaptive, per provider instance / index run). */
+    private adaptiveBatchActive;
     /**
      * @param config - Configuration for the LLM provider, including base URL, model, API key, proxy, and retry settings.
      */
@@ -23,6 +27,22 @@ export declare class LlmDescriptionProvider implements DescriptionProvider {
     }): Promise<string>;
     /** @inheritdoc */
     generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
+    /**
+     * Describe a group of chunks in a single LLM request and parse the response.
+     *
+     * Builds one chat request whose user message contains all chunks wrapped in
+     * `[CHUNK <n>]` markers and expects a `<n>: <description>` line per chunk.
+     * Labels are ordinals and are mapped back to chunks by position in the
+     * calling group; labels outside the group's range (hallucinations) are
+     * naturally dropped, prompting the caller to fall back to individual
+     * requests for the missing chunks.
+     *
+     * @param group - Chunks to describe in one request (length > 1)
+     * @param log - Logger for diagnostic messages
+     * @returns Map of ordinal label to description (may be partial or empty)
+     * @throws When the LLM request itself fails (caller falls back per chunk)
+     */
+    private batchDescribe;
     /**
      * 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.