opencode-rag-plugin 1.19.3 → 1.19.5

package/dist/indexer/stats.d.ts

@@ -38,6 +38,8 @@ export interface IndexRunStats {
     }>;
     /** Number of files where description generation failed. */
     descriptionFailedFiles: number;
+    /** True when the pass was skipped because another pass holds the lock. */
+    skipped: boolean;
 }
 /** Summary of the current index health without running a full pass. */
 export interface IndexStatusSummary {

package/dist/indexer/stats.js

@@ -24,6 +24,7 @@ export function createIndexStats(totalFiles, manifestStatus) {
         extractionFailures: 0,
         extractionErrors: [],
         descriptionFailedFiles: 0,
+        skipped: false,
     };
 }
 //# sourceMappingURL=stats.js.map

package/dist/indexer/watch.js

@@ -120,9 +120,16 @@ export function createWatchIgnore(cwd, config, storePath) {
     const manifestPath = manifestPathFor(storePath);
     const dirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
     const fileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
+    // Prefix check with a trailing separator so sibling dirs like
+    // `<storePath>2` are NOT ignored; case-insensitive on win32 so a
+    // differently-cased store path cannot cause self-triggering watch loops.
+    const storePrefix = storePath.endsWith(path.sep) ? storePath : storePath + path.sep;
+    const win32 = process.platform === "win32";
     return (watchedPath) => {
         const resolved = path.resolve(watchedPath);
-        if (resolved.startsWith(storePath))
+        const compareResolved = win32 ? resolved.toLowerCase() : resolved;
+        const compareStorePrefix = win32 ? storePrefix.toLowerCase() : storePrefix;
+        if (resolved === storePath || compareResolved.startsWith(compareStorePrefix))
             return true;
         if (resolved === manifestPath)
             return true;

package/dist/indexer/worker.js

@@ -128,6 +128,21 @@ export async function prepareFile(file, cwd, previous, config, keywordIndex, des
                 },
             };
         }
+        // No chunks from non-empty content: file may genuinely be chunk-less.
+        // BUT if the content is empty and the file is unchanged (hash matches),
+        // this is the re-describe fast-path edge — keep the old index entry
+        // instead of deleting it (a delete would wipe previously-indexed chunks
+        // just because we lacked content to re-chunk).
+        if (previous && previous.hash === file.hash && file.content.trim().length === 0) {
+            return {
+                normalizedPath: file.normalizedPath, hash: file.hash, fileLabel,
+                isModified: false,
+                earlyResult: {
+                    normalizedPath: file.normalizedPath, hash: file.hash, chunkCount: previous.chunkCount, fileLabel,
+                    isNew: false, isModified: false, isUnchanged: true, isEmpty: false, isTooSmall: false, isRemoved: false, hadChunks: previous.chunkCount > 0,
+                },
+            };
+        }
         return {
             normalizedPath: file.normalizedPath, hash: file.hash, fileLabel,
             isModified: false,
@@ -138,6 +153,12 @@ export async function prepareFile(file, cwd, previous, config, keywordIndex, des
         };
     }
     logger.debug(`  ${fileLabel}: ${chunks.length} chunks produced`);
+    // Remove stale keyword entries for a previously-indexed revision of this
+    // file (new UUIDs are generated for every chunk) so hybrid search never
+    // surfaces old content and the persisted index stops growing unboundedly.
+    if (previous) {
+        keywordIndex?.removeByFilePath(file.normalizedPath);
+    }
     keywordIndex?.addChunks(chunks);
     const docPrefix = config.embedding.documentPrefix ?? "";
     const relPath = path.relative(cwd, file.filePath).replace(/\\/g, "/");

package/dist/mcp/cli.js

@@ -16,6 +16,10 @@ export async function runMcpServer(options) {
     }
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
+    // If the parent MCP client disconnects, stdin closes — exit instead of
+    // becoming a zombie that holds the store open forever.
+    process.stdin.on("end", shutdown);
+    process.stdin.on("close", shutdown);
     await new Promise(() => { });
 }
 //# sourceMappingURL=cli.js.map

package/dist/mcp/handlers.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Handler implementations for all MCP tools: semantic search, file skeleton, symbol usage lookup, and image description.
  */
-import type { EmbeddingProvider, VectorStore, KeywordIndex, SearchResult } from "../core/interfaces.js";
+import { type EmbeddingProvider, type VectorStore, type KeywordIndex, type SearchResult } from "../core/interfaces.js";
 import type { RagConfig } from "../core/config.js";
 import { type ImageVisionProvider } from "../chunker/image.js";
 import { retrieve } from "../retriever/retriever.js";

package/dist/mcp/handlers.js

@@ -1,10 +1,14 @@
+/**
+ * @fileoverview Handler implementations for all MCP tools: semantic search, file skeleton, symbol usage lookup, and image description.
+ */
+import { CODE_SEARCH_FILTER } from "../core/interfaces.js";
 import { SUPPORTED_IMAGE_EXTENSIONS } from "../chunker/image.js";
 import { retrieve } from "../retriever/retriever.js";
 import { optimizeContext, DEFAULT_CONTEXT_OPTIMIZATION } from "../retriever/context-optimizer.js";
 import { Parser } from "web-tree-sitter";
 import { initParser, loadLanguage, walkTree } from "../chunker/grammar.js";
 import { readFileSync } from "node:fs";
-import { resolve, isAbsolute, relative } from "node:path";
+import { resolve, isAbsolute, relative, sep as pathSep } from "node:path";
 /**
  * Resolve a user-supplied file path against the worktree root, refusing to
  * escape the worktree. Absolute paths are accepted only if they already reside
@@ -19,7 +23,9 @@ export function resolveFilePath(filePath, worktree) {
     const rel = relative(root, candidate);
     if (rel === "")
         return root;
-    if (rel.startsWith("..") || isAbsolute(rel)) {
+    // ".." or "../..." escapes; a sibling literally named "..foo" must NOT be
+    // rejected. isAbsolute(rel) covers cross-drive paths on Windows.
+    if (rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute(rel)) {
         throw new Error(`Path "${filePath}" escapes worktree root "${root}" — access denied.`);
     }
     return candidate;
@@ -178,6 +184,7 @@ export async function handleSearchSemantic(params, embedder, store, cfg, keyword
         keywordWeight: cfg.retrieval.hybridSearch?.keywordWeight,
         hybridEnabled: cfg.retrieval.hybridSearch?.enabled,
         queryPrefix: cfg.embedding.queryPrefix,
+        filter: CODE_SEARCH_FILTER,
     };
     const rawResults = await retrieveFn_(query, embedder, store, retrieveOpts);
     if (rawResults.length === 0) {
@@ -256,7 +263,7 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
     const symbolName = params.symbolName.trim();
     const topK = params.topK ?? 30;
     const kwResults = keywordIndex
-        ? keywordIndex.search(symbolName, topK)
+        ? keywordIndex.search(symbolName, topK, CODE_SEARCH_FILTER)
         : [];
     const count = await store.count();
     const vsResults = count > 0
@@ -265,6 +272,7 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
             minScore: 0,
             keywordIndex: undefined,
             queryPrefix: cfg.embedding.queryPrefix,
+            filter: CODE_SEARCH_FILTER,
         })
         : [];
     const seen = new Set();
@@ -302,7 +310,10 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
         }
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
-            const lineNum = i + 1;
+            // tree-sitter line numbers are absolute file lines (startLine + offset),
+            // NOT chunk-relative — chunk-relative numbers were wrong for every
+            // chunk not starting at line 1 and broke the definition skip.
+            const lineNum = m.startLine + i;
             if (definitionLine !== undefined && lineNum === definitionLine)
                 continue;
             const symbolPattern = new RegExp(`\\b${escapeRegex(symbolName)}\\b`);
@@ -317,7 +328,12 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
                 fileGroups.set(m.filePath, group);
             }
             if (!group.usages.some((g) => g.line === lineNum)) {
-                group.usages.push({ line: lineNum, content: line.trimEnd(), context: contextLines });
+                group.usages.push({
+                    line: lineNum,
+                    content: line.trimEnd(),
+                    context: contextLines,
+                    matchedIndex: i - ctxStart,
+                });
             }
         }
     }
@@ -340,7 +356,8 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
         formattedLines.push("|------|------|");
         for (const usage of group.usages) {
             const ctx = usage.context;
-            const codeLine = ctx[Math.min(2, ctx.length - 1)] ?? usage.content;
+            // Show the actual matched line (not an arbitrary middle context line)
+            const codeLine = ctx[usage.matchedIndex] ?? usage.content;
             const escaped = codeLine.length > 100 ? codeLine.slice(0, 97) + "..." : codeLine;
             formattedLines.push(`| ${usage.line} | \`${escaped}\` |`);
             allMatches.push({ ...usage, filePath, language: group.language });

package/dist/mcp/server.js

@@ -97,6 +97,9 @@ export async function createMcpServer(options) {
             await server.close();
             await ctx.store.close();
             ctx.keywordIndex.close();
+            // Release keep-alive sockets held by the embedder/description providers
+            const { destroyAllPooledConnections } = await import("../embedder/http.js");
+            destroyAllPooledConnections();
         },
     };
 }

package/dist/opencode/create-read-tool.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview Creates the RAG-backed read tool that returns full file contents with supplementary semantic context.
  */
 import { tool } from "@opencode-ai/plugin/tool";
-import type { EmbeddingProvider, KeywordIndex, VectorStore, SearchResult } from "../core/interfaces.js";
+import { type EmbeddingProvider, type KeywordIndex, type VectorStore, type SearchResult } from "../core/interfaces.js";
 import type { RagConfig } from "../core/config.js";
 export interface RagReadToolOptions {
     /** Workspace root directory. */

package/dist/opencode/create-read-tool.js

@@ -3,6 +3,7 @@
  */
 import fs from "node:fs/promises";
 import { tool } from "@opencode-ai/plugin/tool";
+import { CODE_SEARCH_FILTER } from "../core/interfaces.js";
 import { retrieve } from "../retriever/retriever.js";
 import { normalizeReadArgs, resolveWorkspacePath } from "./tool-args.js";
 import { buildReadQuery } from "./read-query.js";
@@ -58,19 +59,23 @@ export function createRagReadTool(options) {
                         let rawResults;
                         if (sessionID && sessionRetrievalCache) {
                             const cached = sessionRetrievalCache.get(sessionID);
-                            if (cached && cached.messageText === messageText) {
+                            // The cache key must include the FILE and line range: without
+                            // them, the first read of a message reused its retrieval results
+                            // for every later read of a DIFFERENT file in the same message.
+                            const cacheKey = `${messageText}::${resolvedPath}::${normalized.startLine ?? ""}-${normalized.endLine ?? ""}`;
+                            if (cached && cached.messageText === cacheKey) {
                                 rawResults = cached.rawResults;
                             }
                             else {
                                 const retrievalQuery = buildSessionQuery(messageText, resolvedPath, normalized);
-                                rawResults = await retrieve(retrievalQuery, embedder, store, { topK: retrievalTopK, keywordIndex, hybridEnabled: config.retrieval.hybridSearch?.enabled, queryPrefix: config.embedding.queryPrefix });
+                                rawResults = await retrieve(retrievalQuery, embedder, store, { topK: retrievalTopK, keywordIndex, hybridEnabled: config.retrieval.hybridSearch?.enabled, queryPrefix: config.embedding.queryPrefix, filter: CODE_SEARCH_FILTER });
                                 const maxSize = options.maxSessionCacheSize ?? 50;
                                 if (!sessionRetrievalCache.has(sessionID) && sessionRetrievalCache.size >= maxSize) {
                                     const oldest = sessionRetrievalCache.keys().next().value;
                                     if (oldest !== undefined)
                                         sessionRetrievalCache.delete(oldest);
                                 }
-                                sessionRetrievalCache.set(sessionID, { messageText, rawResults });
+                                sessionRetrievalCache.set(sessionID, { messageText: cacheKey, rawResults });
                             }
                         }
                         else {
@@ -80,7 +85,7 @@ export function createRagReadTool(options) {
                                 startLine: normalized.startLine,
                                 endLine: normalized.endLine,
                             });
-                            rawResults = await retrieve(retrievalQuery, embedder, store, { topK: retrievalTopK, keywordIndex, hybridEnabled: config.retrieval.hybridSearch?.enabled, queryPrefix: config.embedding.queryPrefix });
+                            rawResults = await retrieve(retrievalQuery, embedder, store, { topK: retrievalTopK, keywordIndex, hybridEnabled: config.retrieval.hybridSearch?.enabled, queryPrefix: config.embedding.queryPrefix, filter: CODE_SEARCH_FILTER });
                         }
                         // Collect related files from raw results (before filtering)
                         relatedFiles = collectRelatedFiles(rawResults, resolvedPath, readRelatedFilesMax);
@@ -120,9 +125,16 @@ export function createRagReadTool(options) {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
+                const code = err?.code;
+                // Distinguish path problems (ENOENT / outside workspace) from RAG
+                // retrieval failures — "OpenCodeRAG retrieval failed" was misleading
+                // for a simple missing file.
+                const isPathProblem = code === "ENOENT" || code === "EACCES" || /ENOENT|outside the workspace|does not exist/i.test(message);
                 return {
                     title: "Read",
-                    output: retrievalErrorMessage(message),
+                    output: isPathProblem
+                        ? `Could not read file: ${message}`
+                        : retrievalErrorMessage(message),
                     metadata: {
                         tool: "read",
                         filePath: resolvedPath,

package/dist/opencode/tool-args.js

@@ -2,6 +2,7 @@
  * @fileoverview Normalizes and validates read tool arguments, and resolves file paths relative to the workspace root.
  */
 import path from "node:path";
+import { realpathSync } from "node:fs";
 /**
  * Normalize raw read tool arguments into a consistent internal shape.
  *
@@ -58,10 +59,31 @@ export function resolveWorkspacePath(worktree, inputPath) {
         : path.resolve(worktree, inputPath);
     const normalizedWorktree = path.resolve(worktree);
     const normalizedResolved = path.resolve(resolved);
-    if (!normalizedResolved.startsWith(normalizedWorktree + path.sep) &&
+    // Case-insensitive on win32: an absolute path with different casing must
+    // not be falsely rejected as "outside the workspace".
+    const cmp = (p) => (process.platform === "win32" ? p.toLowerCase() : p);
+    if (!cmp(normalizedResolved).startsWith(cmp(normalizedWorktree) + path.sep) &&
         normalizedResolved !== normalizedWorktree) {
         throw new Error(`read path "${inputPath}" resolves outside the workspace "${normalizedWorktree}"`);
     }
+    // Resolve symlinks/junctions: a link INSIDE the workspace pointing outside
+    // must not let the agent read arbitrary files (node_modules junctions are
+    // common on Windows). realpath failure (e.g. missing file) falls back to
+    // the lexical check above — the read itself will fail with ENOENT.
+    try {
+        const realResolved = realpathSync(normalizedResolved);
+        const realWorktree = realpathSync(normalizedWorktree);
+        if (!cmp(realResolved).startsWith(cmp(realWorktree) + path.sep) &&
+            realResolved !== realWorktree) {
+            throw new Error(`read path "${inputPath}" resolves outside the workspace "${normalizedWorktree}" (via symlink "${realResolved}")`);
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && /outside the workspace/.test(err.message)) {
+            throw err;
+        }
+        // otherwise: realpath unavailable — keep the lexical result
+    }
     return toForwardSlash(normalizedResolved);
 }
 /**

package/dist/opencode/tools.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview Factory functions for OpenCode autonomous-agent tools (file skeleton, find usages, describe image).
  */
 import type { ToolDefinition } from "@opencode-ai/plugin";
-import type { EmbeddingProvider, VectorStore, KeywordIndex } from "../core/interfaces.js";
+import { type EmbeddingProvider, type VectorStore, type KeywordIndex } from "../core/interfaces.js";
 import type { RagConfig } from "../core/config.js";
 import { type ImageVisionProvider } from "../chunker/image.js";
 import { retrieve } from "../retriever/retriever.js";

package/dist/opencode/tools.js

@@ -13,6 +13,7 @@
  * These complement the general-purpose search_semantic tool.
  */
 import { tool } from "@opencode-ai/plugin/tool";
+import { CODE_SEARCH_FILTER } from "../core/interfaces.js";
 import { SUPPORTED_IMAGE_EXTENSIONS, createImageVisionProvider, getMimeType } from "../chunker/image.js";
 import { resizeImage } from "../content/image.js";
 import { retrieve } from "../retriever/retriever.js";
@@ -362,7 +363,7 @@ export function createFindUsagesTool(options) {
     async function searchViaKeywordIndex(symbol, topK) {
         if (!keywordIndex)
             return [];
-        return keywordIndex.search(symbol, topK);
+        return keywordIndex.search(symbol, topK, CODE_SEARCH_FILTER);
     }
     async function searchViaVectorStore(symbol, topK) {
         const count = await store.count();
@@ -373,6 +374,7 @@ export function createFindUsagesTool(options) {
             minScore: 0,
             keywordIndex: undefined,
             queryPrefix: cfg.embedding.queryPrefix,
+            filter: CODE_SEARCH_FILTER,
         });
     }
     function escapeRegex(s) {

package/dist/plugin.d.ts

@@ -4,7 +4,7 @@
  * automatic context injection and documentation mode.
  */
 import type { Plugin, Hooks } from "@opencode-ai/plugin";
-import type { EmbeddingProvider, DescriptionProvider, KeywordIndex, VectorStore } from "./core/interfaces.js";
+import { type EmbeddingProvider, type DescriptionProvider, type KeywordIndex, type VectorStore } from "./core/interfaces.js";
 import { type RagConfig } from "./core/config.js";
 import { createEmbedder } from "./embedder/factory.js";
 import { retrieve } from "./retriever/retriever.js";