@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/sqlite/shard-manager.js

@@ -0,0 +1,288 @@
+import { getDatabase } from "./sqlite-bootstrap.js";
+import { join, basename } from "node:path";
+import { existsSync } from "node:fs";
+import { CONFIG } from "../../config.js";
+import { connectionManager } from "./connection-manager.js";
+import { log } from "../logger.js";
+import { vectorSearch } from "./vector-search.js";
+const Database = getDatabase();
+const METADATA_DB_NAME = "metadata.db";
+export class ShardManager {
+    metadataDb;
+    metadataPath;
+    constructor() {
+        this.metadataPath = join(CONFIG.storagePath, METADATA_DB_NAME);
+        this.metadataDb = connectionManager.getConnection(this.metadataPath);
+        this.initMetadataDb();
+    }
+    initMetadataDb() {
+        this.metadataDb.run(`
+      CREATE TABLE IF NOT EXISTS shards (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope TEXT NOT NULL,
+        scope_hash TEXT NOT NULL,
+        shard_index INTEGER NOT NULL,
+        db_path TEXT NOT NULL,
+        vector_count INTEGER DEFAULT 0,
+        is_active INTEGER DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        UNIQUE(scope, scope_hash, shard_index)
+      )
+    `);
+        this.metadataDb.run(`
+      CREATE INDEX IF NOT EXISTS idx_active_shards 
+      ON shards(scope, scope_hash, is_active)
+    `);
+    }
+    getShardPath(scope, scopeHash, shardIndex) {
+        const dir = join(CONFIG.storagePath, `${scope}s`);
+        return join(dir, `${scope}_${scopeHash}_shard_${shardIndex}.db`);
+    }
+    resolveStoredPath(storedPath, scope) {
+        const fileName = basename(storedPath);
+        return join(CONFIG.storagePath, `${scope}s`, fileName);
+    }
+    getActiveShard(scope, scopeHash) {
+        const stmt = this.metadataDb.prepare(`
+      SELECT * FROM shards 
+      WHERE scope = ? AND scope_hash = ? AND is_active = 1
+      ORDER BY shard_index DESC LIMIT 1
+    `);
+        const row = stmt.get(scope, scopeHash);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            scope: row.scope,
+            scopeHash: row.scope_hash,
+            shardIndex: row.shard_index,
+            dbPath: this.resolveStoredPath(row.db_path, row.scope),
+            vectorCount: row.vector_count,
+            isActive: row.is_active === 1,
+            createdAt: row.created_at,
+        };
+    }
+    getAllShards(scope, scopeHash) {
+        let stmt;
+        let rows;
+        if (scopeHash === "") {
+            stmt = this.metadataDb.prepare(`
+        SELECT * FROM shards 
+        WHERE scope = ?
+        ORDER BY shard_index ASC
+      `);
+            rows = stmt.all(scope);
+        }
+        else {
+            stmt = this.metadataDb.prepare(`
+        SELECT * FROM shards 
+        WHERE scope = ? AND scope_hash = ?
+        ORDER BY shard_index ASC
+      `);
+            rows = stmt.all(scope, scopeHash);
+        }
+        return rows.map((row) => ({
+            id: row.id,
+            scope: row.scope,
+            scopeHash: row.scope_hash,
+            shardIndex: row.shard_index,
+            dbPath: this.resolveStoredPath(row.db_path, row.scope),
+            vectorCount: row.vector_count,
+            isActive: row.is_active === 1,
+            createdAt: row.created_at,
+        }));
+    }
+    createShard(scope, scopeHash, shardIndex) {
+        const fullPath = this.getShardPath(scope, scopeHash, shardIndex);
+        const storedPath = join(`${scope}s`, basename(fullPath)).replace(/\\/g, "/");
+        const now = Date.now();
+        const stmt = this.metadataDb.prepare(`
+      INSERT INTO shards (scope, scope_hash, shard_index, db_path, vector_count, is_active, created_at)
+      VALUES (?, ?, ?, ?, 0, 1, ?)
+    `);
+        const result = stmt.run(scope, scopeHash, shardIndex, storedPath, now);
+        const db = connectionManager.getConnection(fullPath);
+        this.initShardDb(db);
+        return {
+            id: Number(result.lastInsertRowid),
+            scope,
+            scopeHash,
+            shardIndex,
+            dbPath: fullPath,
+            vectorCount: 0,
+            isActive: true,
+            createdAt: now,
+        };
+    }
+    initShardDb(db) {
+        db.run(`
+      CREATE TABLE IF NOT EXISTS shard_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        db.run(`
+      INSERT OR REPLACE INTO shard_metadata (key, value) 
+      VALUES ('embedding_dimensions', '${CONFIG.embeddingDimensions}')
+    `);
+        db.run(`
+      INSERT OR REPLACE INTO shard_metadata (key, value) 
+      VALUES ('embedding_model', '${CONFIG.embeddingModel}')
+    `);
+        db.run(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        vector BLOB NOT NULL,
+        tags_vector BLOB,
+        container_tag TEXT NOT NULL,
+        tags TEXT,
+        type TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        metadata TEXT,
+        display_name TEXT,
+        user_name TEXT,
+        user_email TEXT,
+        project_path TEXT,
+        project_name TEXT,
+        git_repo_url TEXT,
+        is_pinned INTEGER DEFAULT 0
+      )
+    `);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_container_tag ON memories(container_tag)`);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_type ON memories(type)`);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_created_at ON memories(created_at DESC)`);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_is_pinned ON memories(is_pinned)`);
+    }
+    isShardValid(shard) {
+        if (!existsSync(shard.dbPath)) {
+            log("Shard DB file missing", { dbPath: shard.dbPath, shardId: shard.id });
+            return false;
+        }
+        try {
+            const db = connectionManager.getConnection(shard.dbPath);
+            const result = db
+                .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='memories'`)
+                .get();
+            if (!result) {
+                log("Shard DB missing 'memories' table", {
+                    dbPath: shard.dbPath,
+                    shardId: shard.id,
+                });
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            log("Error validating shard DB", {
+                dbPath: shard.dbPath,
+                error: String(error),
+            });
+            return false;
+        }
+    }
+    ensureShardTables(shard) {
+        try {
+            const db = connectionManager.getConnection(shard.dbPath);
+            this.initShardDb(db);
+        }
+        catch (error) {
+            log("Error ensuring shard tables", {
+                dbPath: shard.dbPath,
+                error: String(error),
+            });
+        }
+    }
+    getWriteShard(scope, scopeHash) {
+        let shard = this.getActiveShard(scope, scopeHash);
+        if (!shard) {
+            return this.createShard(scope, scopeHash, 0);
+        }
+        if (!this.isShardValid(shard)) {
+            log("Active shard is invalid, recreating", {
+                scope,
+                scopeHash,
+                shardIndex: shard.shardIndex,
+                dbPath: shard.dbPath,
+            });
+            connectionManager.closeConnection(shard.dbPath);
+            const deleteStmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
+            deleteStmt.run(shard.id);
+            return this.createShard(scope, scopeHash, shard.shardIndex);
+        }
+        if (shard.vectorCount >= CONFIG.maxVectorsPerShard) {
+            this.markShardReadOnly(shard.id);
+            return this.createShard(scope, scopeHash, shard.shardIndex + 1);
+        }
+        return shard;
+    }
+    markShardReadOnly(shardId) {
+        const stmt = this.metadataDb.prepare(`
+      UPDATE shards SET is_active = 0 WHERE id = ?
+    `);
+        stmt.run(shardId);
+    }
+    incrementVectorCount(shardId) {
+        const stmt = this.metadataDb.prepare(`
+      UPDATE shards SET vector_count = vector_count + 1 WHERE id = ?
+    `);
+        stmt.run(shardId);
+    }
+    decrementVectorCount(shardId) {
+        const stmt = this.metadataDb.prepare(`
+      UPDATE shards SET vector_count = vector_count - 1 WHERE id = ? AND vector_count > 0
+    `);
+        stmt.run(shardId);
+    }
+    getShardByPath(dbPath) {
+        const fileName = basename(dbPath);
+        const stmt = this.metadataDb.prepare(`SELECT * FROM shards WHERE db_path LIKE '%' || ?`);
+        const row = stmt.get(fileName);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            scope: row.scope,
+            scopeHash: row.scope_hash,
+            shardIndex: row.shard_index,
+            dbPath: this.resolveStoredPath(row.db_path, row.scope),
+            vectorCount: row.vector_count,
+            isActive: row.is_active === 1,
+            createdAt: row.created_at,
+        };
+    }
+    async deleteShard(shardId) {
+        const stmt = this.metadataDb.prepare(`SELECT * FROM shards WHERE id = ?`);
+        const row = stmt.get(shardId);
+        if (row) {
+            const fullPath = this.resolveStoredPath(row.db_path, row.scope);
+            await vectorSearch.deleteShardIndexes({
+                id: row.id,
+                scope: row.scope,
+                scopeHash: row.scope_hash,
+                shardIndex: row.shard_index,
+                dbPath: fullPath,
+                vectorCount: row.vector_count,
+                isActive: row.is_active === 1,
+                createdAt: row.created_at,
+            });
+            connectionManager.closeConnection(fullPath);
+            try {
+                const fs = require("node:fs");
+                if (fs.existsSync(fullPath)) {
+                    fs.unlinkSync(fullPath);
+                }
+            }
+            catch (error) {
+                log("Error deleting shard file", {
+                    dbPath: fullPath,
+                    error: String(error),
+                });
+            }
+            const deleteStmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
+            deleteStmt.run(shardId);
+        }
+    }
+}
+export const shardManager = new ShardManager();

package/dist/services/sqlite/sqlite-bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare function getDatabase(): typeof import("bun:sqlite").Database;
+//# sourceMappingURL=sqlite-bootstrap.d.ts.map

package/dist/services/sqlite/sqlite-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-bootstrap.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/sqlite-bootstrap.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,IAAI,cAAc,YAAY,EAAE,QAAQ,CAMlE"}

package/dist/services/sqlite/sqlite-bootstrap.js

@@ -0,0 +1,8 @@
+let Database;
+export function getDatabase() {
+    if (!Database) {
+        const bunSqlite = require("bun:sqlite");
+        Database = bunSqlite.Database;
+    }
+    return Database;
+}

package/dist/services/sqlite/types.d.ts

@@ -0,0 +1,42 @@
+export interface ShardInfo {
+    id: number;
+    scope: "user" | "project";
+    scopeHash: string;
+    shardIndex: number;
+    dbPath: string;
+    vectorCount: number;
+    isActive: boolean;
+    createdAt: number;
+}
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    vector: Float32Array;
+    tagsVector?: Float32Array;
+    containerTag: string;
+    tags?: string;
+    type?: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: string;
+    displayName?: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+}
+export interface SearchResult {
+    id: string;
+    memory: string;
+    similarity: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    displayName?: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/sqlite/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/services/sqlite/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/sqlite/vector-search.d.ts

@@ -0,0 +1,29 @@
+import type { MemoryRecord, SearchResult, ShardInfo } from "./types.js";
+import type { VectorBackend } from "../vector-backends/types.js";
+declare const Database: typeof import("bun:sqlite").Database;
+type DatabaseType = typeof Database.prototype;
+export declare class VectorSearch {
+    private readonly backendPromise;
+    private readonly fallbackBackend;
+    constructor(backend?: VectorBackend, fallbackBackend?: VectorBackend);
+    private getBackend;
+    insertVector(db: DatabaseType, record: MemoryRecord, shard?: ShardInfo): Promise<void>;
+    searchInShard(shard: ShardInfo, queryVector: Float32Array, containerTag: string, limit: number, queryText?: string): Promise<SearchResult[]>;
+    searchAcrossShards(shards: ShardInfo[], queryVector: Float32Array, containerTag: string, limit: number, similarityThreshold: number, queryText?: string): Promise<SearchResult[]>;
+    deleteVector(db: DatabaseType, memoryId: string, shard?: ShardInfo): Promise<void>;
+    updateVector(db: DatabaseType, memoryId: string, vector: Float32Array, shard?: ShardInfo, tagsVector?: Float32Array): Promise<void>;
+    listMemories(db: DatabaseType, containerTag: string, limit: number): any[];
+    getAllMemories(db: DatabaseType): any[];
+    getMemoryById(db: DatabaseType, memoryId: string): any | null;
+    getMemoriesBySessionID(db: DatabaseType, sessionID: string): any[];
+    countVectors(db: DatabaseType, containerTag: string): number;
+    countAllVectors(db: DatabaseType): number;
+    getDistinctTags(db: DatabaseType): any[];
+    pinMemory(db: DatabaseType, memoryId: string): void;
+    unpinMemory(db: DatabaseType, memoryId: string): void;
+    rebuildIndexForShard(db: DatabaseType, scope: string, scopeHash: string, shardIndex: number): Promise<void>;
+    deleteShardIndexes(shard: ShardInfo): Promise<void>;
+}
+export declare const vectorSearch: VectorSearch;
+export {};
+//# sourceMappingURL=vector-search.d.ts.map

package/dist/services/sqlite/vector-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-search.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/vector-search.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,QAAA,MAAM,QAAQ,sCAAgB,CAAC;AAC/B,KAAK,YAAY,GAAG,OAAO,QAAQ,CAAC,SAAS,CAAC;AAM9C,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyB;IACxD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgB;gBAEpC,OAAO,CAAC,EAAE,aAAa,EAAE,eAAe,GAAE,aAAsC;YAO9E,UAAU;IAIlB,YAAY,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAyCtF,aAAa,CACjB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,YAAY,EACzB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC;IAyHpB,kBAAkB,CACtB,MAAM,EAAE,SAAS,EAAE,EACnB,WAAW,EAAE,YAAY,EACzB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,mBAAmB,EAAE,MAAM,EAC3B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC;IAiBpB,YAAY,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlF,YAAY,CAChB,EAAE,EAAE,YAAY,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,YAAY,EACpB,KAAK,CAAC,EAAE,SAAS,EACjB,UAAU,CAAC,EAAE,YAAY,GACxB,OAAO,CAAC,IAAI,CAAC;IAkBhB,YAAY,CAAC,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE;IAW1E,cAAc,CAAC,EAAE,EAAE,YAAY,GAAG,GAAG,EAAE;IAKvC,aAAa,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI;IAK7D,sBAAsB,CAAC,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,EAAE;IAgBlE,YAAY,CAAC,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAM5D,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,MAAM;IAMzC,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,GAAG,EAAE;IAexC,SAAS,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnD,WAAW,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK/C,oBAAoB,CACxB,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;IAgBV,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAI1D;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/services/sqlite/vector-search.js

@@ -0,0 +1,268 @@
+import { getDatabase } from "./sqlite-bootstrap.js";
+import { connectionManager } from "./connection-manager.js";
+import { log } from "../logger.js";
+import { CONFIG } from "../../config.js";
+import { createVectorBackend } from "../vector-backends/backend-factory.js";
+import { ExactScanBackend } from "../vector-backends/exact-scan-backend.js";
+const Database = getDatabase();
+function toBlob(vector) {
+    return vector ? new Uint8Array(vector.buffer) : null;
+}
+export class VectorSearch {
+    backendPromise;
+    fallbackBackend;
+    constructor(backend, fallbackBackend = new ExactScanBackend()) {
+        this.backendPromise = backend
+            ? Promise.resolve(backend)
+            : createVectorBackend({ vectorBackend: CONFIG.vectorBackend });
+        this.fallbackBackend = fallbackBackend;
+    }
+    async getBackend() {
+        return this.backendPromise;
+    }
+    async insertVector(db, record, shard) {
+        const insertMemory = db.prepare(`
+      INSERT INTO memories (
+        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        insertMemory.run(record.id, record.content, toBlob(record.vector), toBlob(record.tagsVector), record.containerTag, record.tags || null, record.type || null, record.createdAt, record.updatedAt, record.metadata || null, record.displayName || null, record.userName || null, record.userEmail || null, record.projectPath || null, record.projectName || null, record.gitRepoUrl || null);
+        try {
+            if (shard) {
+                const backend = await this.getBackend();
+                await backend.insert({ id: record.id, vector: record.vector, shard, kind: "content" });
+                if (record.tagsVector) {
+                    await backend.insert({ id: record.id, vector: record.tagsVector, shard, kind: "tags" });
+                }
+            }
+        }
+        catch (error) {
+            db.prepare(`DELETE FROM memories WHERE id = ?`).run(record.id);
+            throw error;
+        }
+    }
+    async searchInShard(shard, queryVector, containerTag, limit, queryText) {
+        const db = connectionManager.getConnection(shard.dbPath);
+        const backend = await this.getBackend();
+        let contentResults;
+        let tagsResults;
+        try {
+            await backend.rebuildFromShard({ db, shard, kind: "content" });
+            await backend.rebuildFromShard({ db, shard, kind: "tags" });
+            contentResults = await backend.search({
+                db,
+                shard,
+                kind: "content",
+                queryVector,
+                limit: limit * 4,
+            });
+            tagsResults = await backend.search({
+                db,
+                shard,
+                kind: "tags",
+                queryVector,
+                limit: limit * 4,
+            });
+        }
+        catch (error) {
+            log("Vector search degraded to exact scan in shard", {
+                shardId: shard.id,
+                backend: backend.getBackendName(),
+                error: String(error),
+            });
+            await this.fallbackBackend.rebuildFromShard({ db, shard, kind: "content" });
+            await this.fallbackBackend.rebuildFromShard({ db, shard, kind: "tags" });
+            contentResults = await this.fallbackBackend.search({
+                db,
+                shard,
+                kind: "content",
+                queryVector,
+                limit: limit * 4,
+            });
+            tagsResults = await this.fallbackBackend.search({
+                db,
+                shard,
+                kind: "tags",
+                queryVector,
+                limit: limit * 4,
+            });
+        }
+        const scoreMap = new Map();
+        for (const r of contentResults) {
+            scoreMap.set(r.id, { contentSim: 1 - r.distance, tagsSim: 0 });
+        }
+        for (const r of tagsResults) {
+            const entry = scoreMap.get(r.id);
+            if (entry) {
+                entry.tagsSim = 1 - r.distance;
+            }
+            else {
+                scoreMap.set(r.id, { contentSim: 0, tagsSim: 1 - r.distance });
+            }
+        }
+        const ids = Array.from(scoreMap.keys());
+        if (ids.length === 0)
+            return [];
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = db
+            .prepare(`
+      SELECT * FROM memories
+      WHERE id IN (${placeholders}) AND container_tag = ?
+    `)
+            .all(...ids, containerTag);
+        const queryWords = queryText
+            ? queryText
+                .toLowerCase()
+                .split(/[\s,]+/)
+                .filter((w) => w.length > 1)
+            : [];
+        const hydratedResults = rows.map((row) => {
+            const scores = scoreMap.get(row.id);
+            const memoryTagsStr = row.tags || "";
+            const memoryTags = memoryTagsStr.split(",").map((t) => t.trim().toLowerCase());
+            let exactMatchBoost = 0;
+            if (queryWords.length > 0 && memoryTags.length > 0) {
+                const matches = queryWords.filter((w) => memoryTags.some((t) => t.includes(w) || w.includes(t))).length;
+                exactMatchBoost = matches / Math.max(queryWords.length, 1);
+            }
+            const finalTagsSim = Math.max(scores.tagsSim, exactMatchBoost);
+            const similarity = scores.contentSim * 0.6 + finalTagsSim * 0.4;
+            return {
+                id: row.id,
+                memory: row.content,
+                similarity,
+                tags: memoryTagsStr ? memoryTagsStr.split(",") : [],
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                containerTag: row.container_tag,
+                displayName: row.display_name,
+                userName: row.user_name,
+                userEmail: row.user_email,
+                projectPath: row.project_path,
+                projectName: row.project_name,
+                gitRepoUrl: row.git_repo_url,
+                isPinned: row.is_pinned,
+            };
+        });
+        hydratedResults.sort((a, b) => b.similarity - a.similarity);
+        return hydratedResults;
+    }
+    async searchAcrossShards(shards, queryVector, containerTag, limit, similarityThreshold, queryText) {
+        const shardPromises = shards.map(async (shard) => {
+            try {
+                return await this.searchInShard(shard, queryVector, containerTag, limit, queryText);
+            }
+            catch (error) {
+                log("Shard search error", { shardId: shard.id, error: String(error) });
+                return [];
+            }
+        });
+        const resultsArray = await Promise.all(shardPromises);
+        const allResults = resultsArray.flat();
+        allResults.sort((a, b) => b.similarity - a.similarity);
+        return allResults.filter((r) => r.similarity >= similarityThreshold).slice(0, limit);
+    }
+    async deleteVector(db, memoryId, shard) {
+        db.prepare(`DELETE FROM memories WHERE id = ?`).run(memoryId);
+        if (shard) {
+            const backend = await this.getBackend();
+            await backend.delete({ id: memoryId, shard, kind: "content" });
+            await backend.delete({ id: memoryId, shard, kind: "tags" });
+        }
+    }
+    async updateVector(db, memoryId, vector, shard, tagsVector) {
+        db.prepare(`UPDATE memories SET vector = ?, tags_vector = ? WHERE id = ?`).run(toBlob(vector), toBlob(tagsVector), memoryId);
+        if (shard) {
+            const backend = await this.getBackend();
+            await backend.insert({ id: memoryId, vector, shard, kind: "content" });
+            if (tagsVector) {
+                await backend.insert({ id: memoryId, vector: tagsVector, shard, kind: "tags" });
+            }
+            else {
+                await backend.delete({ id: memoryId, shard, kind: "tags" });
+            }
+        }
+    }
+    listMemories(db, containerTag, limit) {
+        const stmt = db.prepare(`
+      SELECT * FROM memories
+      WHERE container_tag = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+        return stmt.all(containerTag, limit);
+    }
+    getAllMemories(db) {
+        const stmt = db.prepare(`SELECT * FROM memories ORDER BY created_at DESC`);
+        return stmt.all();
+    }
+    getMemoryById(db, memoryId) {
+        const stmt = db.prepare(`SELECT * FROM memories WHERE id = ?`);
+        return stmt.get(memoryId);
+    }
+    getMemoriesBySessionID(db, sessionID) {
+        const stmt = db.prepare(`
+      SELECT * FROM memories
+      WHERE metadata LIKE ?
+      ORDER BY created_at DESC
+    `);
+        const rows = stmt.all(`%"sessionID":"${sessionID}"%`);
+        return rows.map((row) => ({
+            ...row,
+            tags: row.tags ? row.tags.split(",") : [],
+            metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        }));
+    }
+    countVectors(db, containerTag) {
+        const stmt = db.prepare(`SELECT COUNT(*) as count FROM memories WHERE container_tag = ?`);
+        const result = stmt.get(containerTag);
+        return result.count;
+    }
+    countAllVectors(db) {
+        const stmt = db.prepare(`SELECT COUNT(*) as count FROM memories`);
+        const result = stmt.get();
+        return result.count;
+    }
+    getDistinctTags(db) {
+        const stmt = db.prepare(`
+      SELECT DISTINCT
+        container_tag,
+        display_name,
+        user_name,
+        user_email,
+        project_path,
+        project_name,
+        git_repo_url
+      FROM memories
+    `);
+        return stmt.all();
+    }
+    pinMemory(db, memoryId) {
+        const stmt = db.prepare(`UPDATE memories SET is_pinned = 1 WHERE id = ?`);
+        stmt.run(memoryId);
+    }
+    unpinMemory(db, memoryId) {
+        const stmt = db.prepare(`UPDATE memories SET is_pinned = 0 WHERE id = ?`);
+        stmt.run(memoryId);
+    }
+    async rebuildIndexForShard(db, scope, scopeHash, shardIndex) {
+        const backend = await this.getBackend();
+        const shard = {
+            id: 0,
+            scope: scope,
+            scopeHash,
+            shardIndex,
+            dbPath: "",
+            vectorCount: 0,
+            isActive: true,
+            createdAt: Date.now(),
+        };
+        await backend.rebuildFromShard({ db, shard, kind: "content" });
+        await backend.rebuildFromShard({ db, shard, kind: "tags" });
+    }
+    async deleteShardIndexes(shard) {
+        const backend = await this.getBackend();
+        await backend.deleteShardIndexes({ shard });
+    }
+}
+export const vectorSearch = new VectorSearch();

package/dist/services/tags.d.ts

@@ -0,0 +1,24 @@
+export interface TagInfo {
+    tag: string;
+    displayName: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+}
+export declare function getGitEmail(): string | null;
+export declare function getGitName(): string | null;
+export declare function getGitRepoUrl(directory: string): string | null;
+export declare function getGitCommonDir(directory: string): string | null;
+export declare function getGitTopLevel(directory: string): string | null;
+export declare function getProjectRoot(directory: string): string;
+export declare function getProjectIdentity(directory: string): string;
+export declare function getProjectName(directory: string): string;
+export declare function getUserTagInfo(): TagInfo;
+export declare function getProjectTagInfo(directory: string): TagInfo;
+export declare function getTags(directory: string): {
+    user: TagInfo;
+    project: TagInfo;
+};
+//# sourceMappingURL=tags.d.ts.map

package/dist/services/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/services/tags.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAU3C;AAED,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAU1C;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW9D;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBhE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW/D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAYxD;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAY5D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,wBAAgB,cAAc,IAAI,OAAO,CAoBxC;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAa5D;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG;IAC1C,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB,CAKA"}