opencode-rag-plugin 1.17.3 → 1.18.0

package/dist/vectorstore/lancedb.js

@@ -6,7 +6,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeFilePath, manifestPathFor } from "../core/manifest.js";
 const TABLE_NAME = "chunks";
-const QUERY_COLUMNS = ["id", "content", "description", "filePath", "startLine", "endLine", "language"];
+const QUERY_COLUMNS = ["id", "content", "description", "filePath", "startLine", "endLine", "language", "kind", "quirkType", "tags"];
 /**
  * L2-normalize a vector to unit length. Cosine models require unit vectors
  * for the dot product to equal cosine similarity.
@@ -109,12 +109,14 @@ export class LanceDbStore {
         if (tableNames.includes(TABLE_NAME)) {
             this.table = await db.openTable(TABLE_NAME);
             if (await this.tableHasDescriptionColumn()) {
+                await this.migrateNewColumns();
                 return this.table;
             }
             // Schema missing 'description' column -- try to add it gracefully first.
             try {
                 await this.table.addColumns([{ name: "description", valueSql: "''" }]);
                 console.warn("[lancedb] Added missing 'description' column to existing table.");
+                await this.migrateNewColumns();
                 return this.table;
             }
             catch {
@@ -150,6 +152,9 @@ export class LanceDbStore {
             startLine: 0,
             endLine: 0,
             language: "",
+            kind: "",
+            quirkType: "",
+            tags: "",
         };
         this.table = await db.createTable({
             name: TABLE_NAME,
@@ -175,6 +180,58 @@ export class LanceDbStore {
             return false;
         }
     }
+    async hasColumn(name) {
+        try {
+            const schema = await this.table.schema();
+            return schema.fields.some((f) => f.name === name);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Add kind/quirkType/tags columns if missing from an existing table. */
+    async migrateNewColumns() {
+        const missing = [];
+        for (const col of ["kind", "quirkType", "tags"]) {
+            if (!(await this.hasColumn(col))) {
+                missing.push({ name: col, valueSql: "''" });
+            }
+        }
+        if (missing.length > 0) {
+            try {
+                await this.table.addColumns(missing);
+                console.warn(`[lancedb] Added missing columns: ${missing.map((c) => c.name).join(", ")}`);
+            }
+            catch {
+                console.warn("[lancedb] Could not auto-add missing columns. " +
+                    "Run 'opencode-rag index --force' to rebuild the index with the correct schema.");
+                return;
+            }
+        }
+        await this.ensureColumnsNullable(["kind", "quirkType", "tags"]);
+    }
+    /**
+     * Ensure that kind/quirkType/tags columns are nullable so that queries
+     * with WHERE clauses on these columns do not panic on old fragments
+     * written before the columns existed.
+     */
+    async ensureColumnsNullable(columns) {
+        for (const col of columns) {
+            if (!(await this.hasColumn(col)))
+                continue;
+            try {
+                const schema = await this.table.schema();
+                const field = schema.fields.find((f) => f.name === col);
+                if (field && field.nullable === false) {
+                    await this.table.alterColumns([{ path: col, nullable: true }]);
+                    console.warn(`[lancedb] Made column '${col}' nullable to avoid null-fragment panics.`);
+                }
+            }
+            catch {
+                console.warn(`[lancedb] Could not alter nullability of column '${col}'.`);
+            }
+        }
+    }
     /**
      * Store chunks in the LanceDB table. New rows are inserted first, then
      * any old rows at the same (filePath, startLine) with different IDs are
@@ -214,6 +271,9 @@ export class LanceDbStore {
             startLine: c.metadata.startLine,
             endLine: c.metadata.endLine,
             language: c.metadata.language,
+            kind: c.metadata.kind ?? "",
+            quirkType: c.metadata.quirkType ?? "",
+            tags: c.metadata.tags ? JSON.stringify(c.metadata.tags) : "",
         }));
         if (rows.length === 0)
             return;
@@ -292,6 +352,15 @@ export class LanceDbStore {
         }
     }
     rowToSearchResult(row) {
+        let tags;
+        try {
+            const raw = row.tags;
+            if (raw)
+                tags = JSON.parse(raw);
+        }
+        catch {
+            tags = undefined;
+        }
         return {
             score: Math.min(1, Math.max(0, 1 - (row._distance ?? 0) / 2)),
             chunk: {
@@ -303,6 +372,9 @@ export class LanceDbStore {
                     startLine: row.startLine,
                     endLine: row.endLine,
                     language: row.language,
+                    kind: row.kind || undefined,
+                    quirkType: row.quirkType || undefined,
+                    tags,
                 },
             },
         };
@@ -346,17 +418,31 @@ export class LanceDbStore {
             .where(`filePath = '${normalizedPath}'`)
             .toArray();
         return rows
-            .map((row) => ({
-            id: row.id,
-            content: row.content,
-            description: row.description ?? "",
-            metadata: {
-                filePath: row.filePath,
-                startLine: row.startLine,
-                endLine: row.endLine,
-                language: row.language,
-            },
-        }))
+            .map((row) => {
+            let tags;
+            try {
+                const raw = row.tags;
+                if (raw)
+                    tags = JSON.parse(raw);
+            }
+            catch {
+                tags = undefined;
+            }
+            return {
+                id: row.id,
+                content: row.content,
+                description: row.description ?? "",
+                metadata: {
+                    filePath: row.filePath,
+                    startLine: row.startLine,
+                    endLine: row.endLine,
+                    language: row.language,
+                    kind: row.kind || undefined,
+                    quirkType: row.quirkType || undefined,
+                    tags,
+                },
+            };
+        })
             .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
     }
     /**
@@ -380,6 +466,9 @@ export class LanceDbStore {
             endLine: row.endLine,
             content: row.content,
             description: row.description ?? "",
+            kind: row.kind ?? "",
+            quirkType: row.quirkType ?? "",
+            tags: row.tags ?? "",
         }));
     }
     /**
@@ -398,11 +487,26 @@ export class LanceDbStore {
         const count = await table.countRows();
         if (count === 0)
             return [];
-        let query = table.vectorSearch(l2Normalize(embedding)).distanceType("cosine");
         const whereClause = buildWhereClause(filter);
-        if (whereClause)
-            query = query.where(whereClause);
-        const results = await query.limit(topK).toArray();
+        let results;
+        try {
+            let query = table.vectorSearch(l2Normalize(embedding)).distanceType("cosine");
+            if (whereClause)
+                query = query.where(whereClause);
+            results = await query.limit(topK).toArray();
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("non-nullable") && filter) {
+                const fallbackQuery = table.vectorSearch(l2Normalize(embedding)).distanceType("cosine");
+                const rawResults = await fallbackQuery.limit(topK * 5).toArray();
+                return rawResults
+                    .map((row) => this.rowToSearchResult(row))
+                    .filter((r) => r.chunk.id !== "__seed__")
+                    .filter((r) => matchesFilterLocal(r.chunk, filter))
+                    .slice(0, topK);
+            }
+            throw err;
+        }
         return results
             .map((row) => this.rowToSearchResult(row))
             .filter((r) => r.chunk.id !== "__seed__");
@@ -641,6 +745,10 @@ function buildWhereClause(filter) {
         const langs = filter.languages.map((l) => `'${l.replace(/'/g, "''")}'`).join(",");
         parts.push(`language IN (${langs})`);
     }
+    if (filter.kinds?.length) {
+        const kinds = filter.kinds.map((k) => `'${k.replace(/'/g, "''")}'`).join(",");
+        parts.push(`kind IN (${kinds})`);
+    }
     if (filter.pathPatterns?.length) {
         const likes = filter.pathPatterns.map((p) => {
             const escaped = p.replace(/'/g, "''");
@@ -654,4 +762,26 @@ function buildWhereClause(filter) {
     }
     return parts.length ? parts.join(" AND ") : undefined;
 }
+/** Client-side metadata filter for use as a fallback when LanceDB WHERE panics. */
+function matchesFilterLocal(chunk, filter) {
+    if (!filter)
+        return true;
+    if (filter.languages?.length && !filter.languages.includes(chunk.metadata.language))
+        return false;
+    if (filter.kinds?.length && !filter.kinds.includes(chunk.metadata.kind ?? ""))
+        return false;
+    if (filter.pathPatterns?.length) {
+        return filter.pathPatterns.some((p) => globMatchLocal(p, chunk.metadata.filePath));
+    }
+    return true;
+}
+function globMatchLocal(pattern, filePath) {
+    const GLOBSTAR = "\x00GS\x00";
+    let re = pattern.replace(/\*\*/g, GLOBSTAR);
+    re = re.replace(/([.+^${}()|[\]\\])/g, "\\$1");
+    re = re.replace(new RegExp(GLOBSTAR, "g"), ".*");
+    re = re.replace(/\*/g, "[^/]*");
+    re = re.replace(/\?/g, ".");
+    return new RegExp("^" + re + "$").test(filePath);
+}
 //# sourceMappingURL=lancedb.js.map

package/dist/vectorstore/memory.js

@@ -45,6 +45,9 @@ export class InMemoryVectorStore {
             endLine: c.metadata.endLine,
             content: c.content,
             description: c.description ?? "",
+            kind: c.metadata.kind ?? "",
+            quirkType: c.metadata.quirkType ?? "",
+            tags: c.metadata.tags ? JSON.stringify(c.metadata.tags) : "",
         }));
     }
     async listFiles() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-rag-plugin",
-  "version": "1.17.3",
+  "version": "1.18.0",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",