opencode-rag-plugin 1.17.3 → 1.18.1

package/dist/quirks/quirk-store.js

@@ -0,0 +1,217 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { retrieve } from "../retriever/retriever.js";
+import { isQuirkAllowed } from "./monitor.js";
+const QUIRK_FILE_PREFIX = "quirk:";
+const QUIKK_JSONL = "quirks.jsonl";
+function jsonlPath(storePath) {
+    return path.join(storePath, QUIKK_JSONL);
+}
+function isMemoryStore(storePath) {
+    return storePath.startsWith("memory:");
+}
+/** In-memory backup for memory:// stores. */
+const memQuirks = new Map();
+function readJsonl(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const raw = readFileSync(filePath, "utf-8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").map((l) => JSON.parse(l));
+}
+function appendJsonl(filePath, q) {
+    const dir = path.dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    appendFileSync(filePath, JSON.stringify(q) + "\n", "utf-8");
+}
+function rewriteJsonl(filePath, quirks) {
+    const dir = path.dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(filePath, quirks.map((q) => JSON.stringify(q)).join("\n") + "\n", "utf-8");
+}
+function nowISO() {
+    return new Date().toISOString();
+}
+/** Add a new quirk to the vector store, keyword index, and audit log. */
+export async function addQuirk(deps, input) {
+    const allowed = isQuirkAllowed(input.content);
+    if (!allowed.ok) {
+        throw new Error(`Quirk rejected by trust monitor: ${allowed.reason}`);
+    }
+    const id = `quirk:${randomUUID()}`;
+    const lastObserved = nowISO();
+    const confidence = input.confidence ?? 1;
+    const quirk = {
+        id,
+        content: input.content,
+        quirkType: input.quirkType,
+        tags: input.tags ?? [],
+        confidence,
+        lastObserved,
+        sourceRef: input.sourceRef,
+    };
+    const prefix = deps.cfg.embedding.documentPrefix ?? "";
+    const chunkContent = prefix + input.content;
+    const embeddings = await deps.embedder.embed([chunkContent], "document");
+    const embedding = embeddings[0];
+    if (!embedding || embedding.length === 0) {
+        throw new Error("Embedding returned empty vector for quirk content");
+    }
+    const chunk = {
+        id,
+        content: input.content,
+        description: "",
+        embedding,
+        metadata: {
+            filePath: QUIRK_FILE_PREFIX + id,
+            startLine: 0,
+            endLine: 0,
+            language: "quirk",
+            kind: "quirk",
+            quirkType: input.quirkType,
+            tags: input.tags ?? [],
+            confidence,
+            lastObserved,
+        },
+    };
+    await deps.store.addChunks([chunk]);
+    deps.keywordIndex.addChunks([chunk]);
+    if (!isMemoryStore(deps.storePath)) {
+        appendJsonl(jsonlPath(deps.storePath), quirk);
+    }
+    else {
+        memQuirks.set(id, quirk);
+    }
+    return quirk;
+}
+/** Remove a quirk by its ID. */
+export async function removeQuirk(deps, id) {
+    const filePath = QUIRK_FILE_PREFIX + id;
+    await deps.store.deleteByFilePath(filePath);
+    deps.keywordIndex.removeByFilePath(filePath);
+    if (!isMemoryStore(deps.storePath)) {
+        const jp = jsonlPath(deps.storePath);
+        const all = readJsonl(jp).filter((q) => q.id !== id);
+        rewriteJsonl(jp, all);
+    }
+    else {
+        memQuirks.delete(id);
+    }
+}
+/** List all quirks sorted by lastObserved descending. */
+export async function listQuirks(deps) {
+    if (!isMemoryStore(deps.storePath)) {
+        const jp = jsonlPath(deps.storePath);
+        if (existsSync(jp)) {
+            const all = readJsonl(jp);
+            all.sort((a, b) => b.lastObserved.localeCompare(a.lastObserved));
+            return all;
+        }
+        // Fallback: scan the store
+        const filePaths = await deps.store.getFilePaths();
+        const quirkPaths = filePaths.filter((fp) => fp.startsWith(QUIRK_FILE_PREFIX));
+        const result = [];
+        for (const fp of quirkPaths) {
+            const chunks = await deps.store.getChunksByFilePath(fp);
+            for (const c of chunks) {
+                result.push({
+                    id: c.id,
+                    content: c.content,
+                    quirkType: c.metadata.quirkType,
+                    tags: c.metadata.tags ?? [],
+                    confidence: c.metadata.confidence ?? 1,
+                    lastObserved: c.metadata.lastObserved ?? "",
+                    sourceRef: undefined,
+                });
+            }
+        }
+        result.sort((a, b) => b.lastObserved.localeCompare(a.lastObserved));
+        return result;
+    }
+    const all = [...memQuirks.values()];
+    all.sort((a, b) => b.lastObserved.localeCompare(a.lastObserved));
+    return all;
+}
+/** Recall quirks matching a query, with confidence re-weighting. */
+export async function recallQuirks(deps, query, options) {
+    const topK = options?.topK ?? 10;
+    const minConfidence = deps.cfg.memory?.minConfidence ?? 0.5;
+    const filter = { kinds: ["quirk"] };
+    if (options?.quirkType) {
+        filter.languages = [options.quirkType];
+    }
+    const recallMinScore = deps.cfg.memory?.recallMinScore ?? 0.72;
+    const raw = await retrieve(query, deps.embedder, deps.store, {
+        topK: topK * 3,
+        minScore: recallMinScore,
+        keywordIndex: deps.keywordIndex,
+        keywordWeight: deps.cfg.retrieval.hybridSearch?.keywordWeight,
+        hybridEnabled: false,
+        queryPrefix: deps.cfg.embedding.queryPrefix,
+        filter,
+    });
+    // Confidence re-weighting + type/tag filtering
+    const filtered = raw.filter((r) => {
+        const conf = r.chunk.metadata.confidence ?? 1;
+        if (conf < minConfidence)
+            return false;
+        if (options?.quirkType && r.chunk.metadata.quirkType !== options.quirkType)
+            return false;
+        if (options?.tags?.length) {
+            const chunkTags = r.chunk.metadata.tags ?? [];
+            if (!options.tags.some((t) => chunkTags.includes(t)))
+                return false;
+        }
+        return true;
+    });
+    // Re-weight score by confidence, re-sort
+    for (const r of filtered) {
+        const conf = r.chunk.metadata.confidence ?? 1;
+        r.score = r.score * Math.min(1, Math.max(0.01, conf));
+    }
+    filtered.sort((a, b) => b.score - a.score);
+    return filtered.slice(0, topK);
+}
+/** Lint quirks for low confidence, staleness, duplicates, and orphan source refs. */
+export async function lintQuirks(deps) {
+    const issues = [];
+    const quirks = await listQuirks(deps);
+    const cfg = deps.cfg.memory;
+    for (const q of quirks) {
+        if (q.confidence < (cfg?.minConfidence ?? 0.5)) {
+            issues.push(`Low confidence (${q.confidence}): "${q.content.slice(0, 60)}..." [${q.id}]`);
+        }
+        if (cfg?.decay?.enabled && q.lastObserved) {
+            const ageDays = (Date.now() - new Date(q.lastObserved).getTime()) / 86_400_000;
+            const halfLife = cfg.decay.halfLifeDays;
+            if (halfLife > 0 && ageDays > halfLife * 2) {
+                issues.push(`Stale (${Math.round(ageDays)}d old): "${q.content.slice(0, 60)}..." [${q.id}]`);
+            }
+        }
+    }
+    // Duplicate detection (lexically similar content)
+    for (let i = 0; i < quirks.length; i++) {
+        for (let j = i + 1; j < quirks.length; j++) {
+            const sim = lexicalSimilarity(quirks[i].content, quirks[j].content);
+            if (sim > 0.85) {
+                issues.push(`Near-duplicate (${(sim * 100).toFixed(0)}% similar): "${quirks[i].content.slice(0, 50)}..." ↔ "${quirks[j].content.slice(0, 50)}..."`);
+            }
+        }
+    }
+    return issues;
+}
+/** Simple Jaccard-based lexical similarity (word overlap). */
+export function lexicalSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\W+/).filter(Boolean));
+    const wordsB = new Set(b.toLowerCase().split(/\W+/).filter(Boolean));
+    const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
+    const union = new Set([...wordsA, ...wordsB]);
+    return union.size === 0 ? 0 : intersection.size / union.size;
+}
+//# sourceMappingURL=quirk-store.js.map

package/dist/quirks/types.d.ts

@@ -0,0 +1,20 @@
+/** Quirk sub-type labels. */
+export type QuirkType = "gotcha" | "preference" | "decision" | "environment-constraint";
+/** Input for adding a new quirk. */
+export interface QuirkInput {
+    content: string;
+    quirkType?: string;
+    tags?: string[];
+    confidence?: number;
+    sourceRef?: string;
+}
+/** A quirk entry stored in the vectordb and audit log. */
+export interface Quirk {
+    id: string;
+    content: string;
+    quirkType?: string;
+    tags: string[];
+    confidence: number;
+    lastObserved: string;
+    sourceRef?: string;
+}

package/dist/quirks/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/retriever/keyword-index.js

@@ -184,6 +184,9 @@ export class KeywordIndex {
                     startLine: chunk.metadata.startLine,
                     endLine: chunk.metadata.endLine,
                     language: chunk.metadata.language,
+                    kind: chunk.metadata.kind ?? "",
+                    quirkType: chunk.metadata.quirkType ?? "",
+                    tags: chunk.metadata.tags ? JSON.stringify(chunk.metadata.tags) : "",
                 },
             ])),
         };
@@ -215,6 +218,14 @@ export class KeywordIndex {
             index.invertedIndex.set(token, docMap);
         }
         for (const [id, data] of Object.entries(parsed.chunkMap)) {
+            let tags;
+            try {
+                if (data.tags)
+                    tags = JSON.parse(data.tags);
+            }
+            catch {
+                tags = undefined;
+            }
             index.chunkMap.set(id, {
                 id: data.id,
                 content: data.content,
@@ -224,6 +235,9 @@ export class KeywordIndex {
                     startLine: data.startLine,
                     endLine: data.endLine,
                     language: data.language,
+                    kind: data.kind || undefined,
+                    quirkType: data.quirkType || undefined,
+                    tags,
                 },
             });
         }
@@ -251,6 +265,8 @@ function matchesFilter(chunk, 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) => globMatch(p, chunk.metadata.filePath));
     }

package/dist/vectorstore/lancedb.d.ts

@@ -1,4 +1,4 @@
-import type { VectorStore, Chunk, SearchResult, MetadataFilter } from "../core/interfaces.js";
+import type { VectorStore, Chunk, ChunkSummary, SearchResult, MetadataFilter } from "../core/interfaces.js";
 /**
  * L2-normalize a vector to unit length. Cosine models require unit vectors
  * for the dot product to equal cosine similarity.
@@ -40,6 +40,15 @@ export declare class LanceDbStore implements VectorStore {
     private getTable;
     private initTable;
     private tableHasDescriptionColumn;
+    private hasColumn;
+    /** Add kind/quirkType/tags columns if missing from an existing table. */
+    private migrateNewColumns;
+    /**
+     * 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.
+     */
+    private ensureColumnsNullable;
     /**
      * Store chunks in the LanceDB table. New rows are inserted first, then
      * any old rows at the same (filePath, startLine) with different IDs are
@@ -80,15 +89,7 @@ export declare class LanceDbStore implements VectorStore {
      * @param limit - Maximum number of rows to return.
      * @returns An array of chunk summaries.
      */
-    getChunks(offset: number, limit: number): Promise<{
-        id: string;
-        filePath: string;
-        language: string;
-        startLine: number;
-        endLine: number;
-        content: string;
-        description: string;
-    }[]>;
+    getChunks(offset: number, limit: number): Promise<ChunkSummary[]>;
     /**
      * Perform ANN search internally, returning results scored as cosine similarity (0-1).
      * This method is called by `search()` and handles the actual query logic.
@@ -99,9 +100,18 @@ export declare class LanceDbStore implements VectorStore {
     private searchInternal;
     /**
      * Return the total number of chunks stored in the table.
-     * @returns The chunk count, or 0 if the table does not exist.
+     * Guarded by a 30s timeout — returns 0 if the store is unresponsive
+     * (e.g. corrupted version-manifest accumulation) so the pipeline can
+     * proceed with a fresh index instead of hanging forever.
+     * @returns The chunk count, or 0 if the table does not exist or times out.
      */
     count(): Promise<number>;
+    /**
+     * Compact fragments and prune old version manifests to prevent the
+     * version-manifest accumulation that causes countRows() to hang.
+     * Should be called at the end of a successful index pass.
+     */
+    optimize(): Promise<void>;
     /**
      * Return all unique file paths currently stored in the index.
      * @returns An array of normalized file paths.

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,18 +487,36 @@ 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__");
     }
     /**
      * Return the total number of chunks stored in the table.
-     * @returns The chunk count, or 0 if the table does not exist.
+     * Guarded by a 30s timeout — returns 0 if the store is unresponsive
+     * (e.g. corrupted version-manifest accumulation) so the pipeline can
+     * proceed with a fresh index instead of hanging forever.
+     * @returns The chunk count, or 0 if the table does not exist or times out.
      */
     async count() {
         try {
@@ -418,12 +525,35 @@ export class LanceDbStore {
             if (!tableNames.includes(TABLE_NAME))
                 return 0;
             const table = await this.getTable();
-            return await table.countRows();
+            const COUNT_TIMEOUT_MS = 30_000;
+            const result = await Promise.race([
+                table.countRows(),
+                new Promise((resolve) => setTimeout(() => resolve(null), COUNT_TIMEOUT_MS)),
+            ]);
+            if (result === null) {
+                console.warn(`[lancedb] count() timed out after ${COUNT_TIMEOUT_MS / 1000}s — treating store as empty.`);
+                return 0;
+            }
+            return result;
         }
         catch {
             return 0;
         }
     }
+    /**
+     * Compact fragments and prune old version manifests to prevent the
+     * version-manifest accumulation that causes countRows() to hang.
+     * Should be called at the end of a successful index pass.
+     */
+    async optimize() {
+        try {
+            const table = await this.getTable();
+            await table.optimize({ cleanupOlderThan: new Date(), deleteUnverified: false });
+        }
+        catch {
+            // Optimize is best-effort — must not break indexing.
+        }
+    }
     /**
      * Return all unique file paths currently stored in the index.
      * @returns An array of normalized file paths.
@@ -641,6 +771,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 +788,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.d.ts

@@ -21,4 +21,6 @@ export declare class InMemoryVectorStore implements VectorStore {
     getChunksByFilePath(filePath: string): Promise<Chunk[]>;
     /** Release any held resources. No-op for the in-memory store. */
     close(): Promise<void>;
+    /** No-op for the in-memory store. */
+    optimize(): Promise<void>;
 }

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() {
@@ -70,6 +73,9 @@ export class InMemoryVectorStore {
     /** Release any held resources. No-op for the in-memory store. */
     async close() {
     }
+    /** No-op for the in-memory store. */
+    async optimize() {
+    }
 }
 /**
  * Compute the cosine similarity between two equal-length vectors.