@massa-ai/core 1.2.1

package/dist/data/vector/postgres-vector-store.js

@@ -0,0 +1,703 @@
+/**
+ * PostgreSQL + pgvector Vector Store
+ *
+ * High-performance vector store using PostgreSQL with pgvector extension.
+ *
+ * Index strategy (per embedding dimension):
+ *   ≤ 2000 dims  →  HNSW on vector column (vector_cosine_ops)   O(log n)
+ *   > 2000 dims  →  Two-phase binary quantization search:
+ *                     Phase 1: ANN on bit column (bit_hamming_ops, HNSW)  → candidates
+ *                     Phase 2: exact cosine re-rank on vector column       → top-k
+ *
+ * All write/delete/list operations use raw SQL to avoid the Prisma 7.7.0 + Bun ORM bug
+ * (isObjectEnumValue is not a function).
+ */
+import { BaseVectorStore } from './base-vector-store.js';
+import { SearchSource, } from '@massa-ai/shared';
+import { logger } from '@massa-ai/shared';
+import { installGuardOnTable } from '../../services/project-identity/identity-guard-installer.js';
+export class PostgresVectorStore extends BaseVectorStore {
+    pool = null;
+    config;
+    initialized = false;
+    schemaDimensions = null;
+    tableName = 'vector_documents';
+    /** True when the table has embedding_bq column + HNSW index. Set during init. */
+    bqEnabled = false;
+    constructor(config) {
+        super();
+        this.config = {
+            poolSize: 10,
+            indexType: 'hnsw',
+            // efConstruction=128 is the pgvector-recommended value for high-dim vectors (4096d qwen3).
+            indexParams: { m: 16, efConstruction: 128, lists: 100 },
+            ...config,
+        };
+    }
+    // ── Table / dimension helpers ──────────────────────────────────────────────
+    getTableName(dimensions) {
+        return `vector_documents_${dimensions}d`;
+    }
+    /**
+     * Clamp a raw pgvector cosine-similarity (`1 - (embedding <=> query)`) into
+     * the [0,1] relevance contract exposed by SearchResult.score. pgvector
+     * returns NULL — which parseFloats to NaN — for rows whose embedding is
+     * missing or zero-norm, and cosine similarity can dip below 0 for
+     * anti-correlated vectors. Both are normalized to 0 so every search result
+     * always carries a finite, in-range score.
+     */
+    normalizeScore(raw) {
+        const value = typeof raw === "number" ? raw : parseFloat(String(raw));
+        if (!Number.isFinite(value))
+            return 0;
+        return Math.min(1, Math.max(0, value));
+    }
+    // ── Binary quantization ────────────────────────────────────────────────────
+    /**
+     * Convert float32 embedding to a bit-string for binary quantization.
+     * Positive (≥ 0) → '1', Negative (< 0) → '0'.
+     * The result is passed to PostgreSQL as `$1::bit(N)`.
+     */
+    floatsToBit(v) {
+        return v.map((x) => (x >= 0 ? '1' : '0')).join('');
+    }
+    // ── Initialization ─────────────────────────────────────────────────────────
+    async ensureInitialized() {
+        if (this.pool && this.initialized)
+            return this.pool;
+        const pg = await import('pg');
+        const PgPool = pg.default?.Pool ?? pg.Pool;
+        const poolConfig = {
+            connectionString: this.config.connectionString,
+            max: this.config.poolSize,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 5000,
+        };
+        const pool = new PgPool(poolConfig);
+        this.pool = pool;
+        const client = await pool.connect();
+        try {
+            await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+            const providerDimensions = await this.getEmbeddingDimensions();
+            this.tableName = this.getTableName(providerDimensions);
+            this.schemaDimensions = providerDimensions;
+            // Ensure table exists (migration is the preferred path)
+            const { rows } = await client.query(`SELECT tablename FROM pg_tables WHERE tablename = $1`, [this.tableName]);
+            if (rows.length === 0) {
+                logger.warn(`Table ${this.tableName} not found. Creating fallback table.`, {
+                    note: 'Run "prisma migrate deploy" to create tables via migrations',
+                });
+                await this.createFallbackTable(client, providerDimensions);
+            }
+            // UX guard: warn if chunks exist in another dim table for some projects but
+            // the current dim table is empty — indicates an embedding-model change
+            // without reindex, which makes all semantic search return 0 results.
+            await this.detectOrphanedChunks(client, providerDimensions);
+        }
+        finally {
+            client.release();
+        }
+        await this.createVectorIndex();
+        this.initialized = true;
+        logger.info('PostgresVectorStore initialized', {
+            poolSize: this.config.poolSize,
+            indexType: this.config.indexType,
+            dimensions: this.schemaDimensions,
+            tableName: this.tableName,
+            bqEnabled: this.bqEnabled,
+        });
+        return pool;
+    }
+    /**
+     * Detect chunks indexed under a different dimension than the current provider.
+     *
+     * When the user changes EMBEDDING_PROVIDER or the embedding model, the new
+     * provider's dims may not match existing rows (which are stored in
+     * vector_documents_<oldDim>d). Search then silently hits an empty table for
+     * affected projects. We warn so the user knows a reindex is required.
+     */
+    async detectOrphanedChunks(client, currentDim) {
+        try {
+            const { rows: dimTables } = await client.query(`SELECT tablename FROM pg_tables
+         WHERE tablename ~ '^vector_documents_[0-9]+d$'
+           AND tablename <> $1`, [this.tableName]);
+            if (dimTables.length === 0)
+                return;
+            // Check if the CURRENT dim table has any rows
+            const { rows: currentRows } = await client.query(`SELECT COUNT(*)::int AS n FROM ${this.tableName}`);
+            const currentCount = currentRows[0]?.n ?? 0;
+            for (const { tablename } of dimTables) {
+                const { rows: projects } = await client.query(`SELECT project_id, COUNT(*)::int AS n
+             FROM ${tablename}
+            WHERE project_id NOT IN (SELECT DISTINCT project_id FROM ${this.tableName})
+            GROUP BY project_id`);
+                if (projects.length === 0)
+                    continue;
+                const otherDim = tablename.match(/_([0-9]+)d$/)?.[1];
+                logger.warn(`[vector] Orphaned chunks detected: ${tablename} has data for projects not in ${this.tableName}. ` +
+                    `Embedding model likely changed from ${otherDim}d → ${currentDim}d. Reindex required.`, {
+                    currentTable: this.tableName,
+                    currentCount,
+                    orphanedTable: tablename,
+                    affectedProjects: projects.map((p) => ({ projectId: p.project_id, chunks: p.n })),
+                });
+            }
+        }
+        catch (err) {
+            // Detection is best-effort; don't fail initialization
+            logger.debug('[vector] Orphaned chunks detection failed', { error: err.message });
+        }
+    }
+    async createFallbackTable(client, dimensions) {
+        const hasBq = dimensions > 2000;
+        const bqCol = hasBq ? `, embedding_bq bit(${dimensions})` : '';
+        await client.query(`
+      CREATE TABLE ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        metadata JSONB DEFAULT '{}',
+        embedding vector(${dimensions})${bqCol},
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `);
+        await client.query(`
+      CREATE INDEX idx_${this.tableName}_project_id ON ${this.tableName}(project_id)
+    `);
+        // Project-identity guard on this runtime-created dimension table
+        // (design: runtime tables install guards during initialization). The
+        // installer is idempotent (DROP IF EXISTS + CREATE) and never throws.
+        const guardCode = await installGuardOnTable(client, "public", this.tableName, "project_id");
+        if (guardCode) {
+            logger.warn('[project-identity] guard install failed (sanitized)', {
+                table: this.tableName,
+                code: guardCode,
+            });
+        }
+    }
+    // ── Index creation ─────────────────────────────────────────────────────────
+    async createVectorIndex() {
+        if (this.schemaDimensions && this.schemaDimensions > 2000) {
+            await this.createBqIndex();
+            return;
+        }
+        const pool = this.pool;
+        const indexName = `idx_${this.tableName}_embedding`;
+        const { rows } = await pool.query(`SELECT indexname FROM pg_indexes WHERE indexname = $1`, [indexName]);
+        if (rows.length > 0) {
+            logger.debug('HNSW index already exists', { indexName });
+            return;
+        }
+        logger.info('Creating HNSW index (this may take a while for large tables)...');
+        if (this.config.indexType === 'hnsw') {
+            const m = this.config.indexParams?.m ?? 16;
+            const efConstruction = this.config.indexParams?.efConstruction ?? 128;
+            await pool.query(`
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS ${indexName}
+        ON ${this.tableName}
+        USING hnsw (embedding vector_cosine_ops)
+        WITH (m = ${m}, ef_construction = ${efConstruction})
+      `);
+            logger.info('HNSW index created', { m, efConstruction });
+        }
+        else {
+            const lists = this.config.indexParams?.lists ?? 100;
+            await pool.query(`
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS ${indexName}
+        ON ${this.tableName}
+        USING ivfflat (embedding vector_cosine_ops)
+        WITH (lists = ${lists})
+      `);
+            logger.info('IVFFlat index created', { lists });
+        }
+    }
+    /**
+     * Create HNSW index on the binary-quantized bit column.
+     * bit_hamming_ops supports any dimension (no pgvector limit).
+     */
+    async createBqIndex() {
+        const pool = this.pool;
+        const bqIndexName = `idx_${this.tableName}_embedding_bq`;
+        // Check if index already exists
+        const { rows: idxRows } = await pool.query(`SELECT indexname FROM pg_indexes WHERE indexname = $1`, [bqIndexName]);
+        if (idxRows.length > 0) {
+            logger.debug('BQ HNSW index already exists', { bqIndexName });
+            this.bqEnabled = true;
+            return;
+        }
+        // Verify the embedding_bq column actually exists
+        const { rows: colRows } = await pool.query(`SELECT column_name
+       FROM information_schema.columns
+       WHERE table_name = $1 AND column_name = 'embedding_bq'`, [this.tableName]);
+        if (colRows.length === 0) {
+            logger.warn('embedding_bq column not found — BQ disabled. Run prisma migrate deploy.', {
+                tableName: this.tableName,
+            });
+            return;
+        }
+        logger.info('Creating HNSW index on binary-quantized column...', {
+            tableName: this.tableName,
+            dimensions: this.schemaDimensions,
+        });
+        const m = this.config.indexParams?.m ?? 16;
+        const efConstruction = this.config.indexParams?.efConstruction ?? 128;
+        await pool.query(`
+      CREATE INDEX CONCURRENTLY IF NOT EXISTS ${bqIndexName}
+      ON ${this.tableName}
+      USING hnsw (embedding_bq bit_hamming_ops)
+      WITH (m = ${m}, ef_construction = ${efConstruction})
+    `);
+        this.bqEnabled = true;
+        logger.info('BQ HNSW index created', { bqIndexName, m, efConstruction });
+    }
+    // ── Write operations (raw SQL — avoids Prisma+Bun ORM bug) ────────────────
+    async addDocument(id, content, metadata) {
+        const pool = await this.ensureInitialized();
+        const projectId = metadata?.projectId || 'default';
+        const embedding = await this.embedContent(content);
+        if (this.schemaDimensions && embedding.length !== this.schemaDimensions) {
+            throw new Error(`Embedding dimension mismatch: got ${embedding.length}, expected ${this.schemaDimensions}`);
+        }
+        const vectorString = `[${embedding.join(',')}]`;
+        if (this.bqEnabled) {
+            const bqString = this.floatsToBit(embedding);
+            await pool.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding, embedding_bq)
+         VALUES ($1, $2, $3, $4, $5::vector, $6::bit(${this.schemaDimensions}))
+         ON CONFLICT (id) DO UPDATE SET
+           content = EXCLUDED.content,
+           metadata = EXCLUDED.metadata,
+           embedding = EXCLUDED.embedding,
+           embedding_bq = EXCLUDED.embedding_bq,
+           updated_at = NOW()`, [id, projectId, content, JSON.stringify(metadata ?? {}), vectorString, bqString]);
+        }
+        else {
+            await pool.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding)
+         VALUES ($1, $2, $3, $4, $5::vector)
+         ON CONFLICT (id) DO UPDATE SET
+           content = EXCLUDED.content,
+           metadata = EXCLUDED.metadata,
+           embedding = EXCLUDED.embedding,
+           updated_at = NOW()`, [id, projectId, content, JSON.stringify(metadata ?? {}), vectorString]);
+        }
+    }
+    /**
+     * Insert documents, embedding them in sub-batches to avoid overwhelming
+     * the embedding backend. Each sub-batch is its own short transaction
+     * (matches PostgresVectorStore semantics — partial progress survives an
+     * Ollama crash mid-file, instead of rolling back the whole file).
+     * Fails-open per-document when a whole sub-batch's embed call errors.
+     */
+    async addDocuments(documents) {
+        if (documents.length === 0)
+            return;
+        const pool = await this.ensureInitialized();
+        // Match PostgresVectorStore: Ollama bge-m3 crashes on large batches (50+)
+        const EMBED_SUB_BATCH_SIZE = 8;
+        let totalInserted = 0;
+        let totalFailed = 0;
+        for (let i = 0; i < documents.length; i += EMBED_SUB_BATCH_SIZE) {
+            const subBatch = documents.slice(i, i + EMBED_SUB_BATCH_SIZE);
+            let embeddings = null;
+            try {
+                embeddings = await this.embedBatch(subBatch.map((d) => d.content));
+            }
+            catch (error) {
+                logger.warn('[postgres] Sub-batch embedding failed, falling back per-document', {
+                    subBatchIndex: Math.floor(i / EMBED_SUB_BATCH_SIZE),
+                    count: subBatch.length,
+                    error: error.message,
+                });
+            }
+            if (embeddings) {
+                try {
+                    await this.insertSubBatch(pool, subBatch, embeddings);
+                    totalInserted += subBatch.length;
+                    continue;
+                }
+                catch (error) {
+                    logger.warn('[postgres] Sub-batch insert failed, falling back per-document', {
+                        subBatchIndex: Math.floor(i / EMBED_SUB_BATCH_SIZE),
+                        count: subBatch.length,
+                        error: error.message,
+                    });
+                }
+            }
+            // Per-document fallback for this sub-batch
+            for (const doc of subBatch) {
+                try {
+                    const embedding = await this.embedContent(doc.content);
+                    await this.insertSubBatch(pool, [doc], [embedding]);
+                    totalInserted++;
+                }
+                catch (singleError) {
+                    totalFailed++;
+                    logger.warn('[postgres] Skipping document due to embedding/insert error', {
+                        id: doc.id,
+                        error: singleError.message,
+                    });
+                }
+            }
+        }
+        logger.debug('[postgres] Batch documents added to vector store', {
+            inserted: totalInserted,
+            failed: totalFailed,
+            total: documents.length,
+        });
+    }
+    /** Insert a pre-embedded sub-batch inside a single short transaction. */
+    async insertSubBatch(pool, subBatch, embeddings) {
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            for (let i = 0; i < subBatch.length; i++) {
+                const doc = subBatch[i];
+                const embedding = embeddings[i];
+                const projectId = doc.metadata?.projectId || 'default';
+                if (this.schemaDimensions && embedding.length !== this.schemaDimensions) {
+                    throw new Error(`Embedding dimension mismatch: got ${embedding.length}, expected ${this.schemaDimensions}`);
+                }
+                const vectorString = `[${embedding.join(',')}]`;
+                if (this.bqEnabled) {
+                    const bqString = this.floatsToBit(embedding);
+                    await client.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding, embedding_bq)
+             VALUES ($1, $2, $3, $4, $5::vector, $6::bit(${this.schemaDimensions}))
+             ON CONFLICT (id) DO UPDATE SET
+               content = EXCLUDED.content,
+               metadata = EXCLUDED.metadata,
+               embedding = EXCLUDED.embedding,
+               embedding_bq = EXCLUDED.embedding_bq,
+               updated_at = NOW()`, [doc.id, projectId, doc.content, JSON.stringify(doc.metadata ?? {}), vectorString, bqString]);
+                }
+                else {
+                    await client.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding)
+             VALUES ($1, $2, $3, $4, $5::vector)
+             ON CONFLICT (id) DO UPDATE SET
+               content = EXCLUDED.content,
+               metadata = EXCLUDED.metadata,
+               embedding = EXCLUDED.embedding,
+               updated_at = NOW()`, [doc.id, projectId, doc.content, JSON.stringify(doc.metadata ?? {}), vectorString]);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    // ── Search ─────────────────────────────────────────────────────────────────
+    async search(query, limit = 10, projectId) {
+        const embedding = await this.embedContent(query);
+        return this.searchByEmbedding(embedding, limit, projectId);
+    }
+    async searchByEmbedding(embedding, limit = 10, projectId) {
+        const pool = await this.ensureInitialized();
+        if (this.schemaDimensions && embedding.length !== this.schemaDimensions) {
+            throw new Error(`Embedding dimension mismatch: got ${embedding.length}, expected ${this.schemaDimensions}`);
+        }
+        if (this.bqEnabled) {
+            return this.searchTwoPhase(pool, embedding, limit, projectId);
+        }
+        return this.searchDirect(pool, embedding, limit, projectId);
+    }
+    /**
+     * Direct cosine similarity search (for dims ≤ 2000 with HNSW index).
+     */
+    async searchDirect(pool, embedding, limit, projectId) {
+        const vectorString = `[${embedding.join(',')}]`;
+        const queryText = projectId
+            ? `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) as similarity
+         FROM ${this.tableName} WHERE project_id = $2
+         ORDER BY embedding <=> $1::vector LIMIT $3`
+            : `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) as similarity
+         FROM ${this.tableName}
+         ORDER BY embedding <=> $1::vector LIMIT $2`;
+        const params = projectId ? [vectorString, projectId, limit] : [vectorString, limit];
+        const { rows } = await pool.query(queryText, params);
+        return rows.map((row) => ({
+            id: row.id,
+            content: row.content,
+            score: this.normalizeScore(row.similarity),
+            source: SearchSource.VECTOR,
+            metadata: row.metadata,
+        }));
+    }
+    /**
+     * Two-phase binary-quantization search (for dims > 2000).
+     *
+     * Phase 1: ANN using Hamming distance on bit column → `candidates` rows
+     * Phase 2: exact cosine re-rank on float vector → top `limit` rows
+     */
+    async searchTwoPhase(pool, embedding, limit, projectId) {
+        const dims = this.schemaDimensions;
+        const bqQuery = this.floatsToBit(embedding);
+        const vectorString = `[${embedding.join(',')}]`;
+        // Fetch enough candidates so re-ranking is meaningful
+        const candidates = Math.min(limit * 20, 200);
+        // Phase 1: ANN on binary column
+        const phase1Text = projectId
+            ? `SELECT id FROM ${this.tableName}
+         WHERE project_id = $2 AND embedding_bq IS NOT NULL
+         ORDER BY embedding_bq <~> $1::bit(${dims})
+         LIMIT $3`
+            : `SELECT id FROM ${this.tableName}
+         WHERE embedding_bq IS NOT NULL
+         ORDER BY embedding_bq <~> $1::bit(${dims})
+         LIMIT $2`;
+        const phase1Params = projectId ? [bqQuery, projectId, candidates] : [bqQuery, candidates];
+        const { rows: candidateRows } = await pool.query(phase1Text, phase1Params);
+        if (candidateRows.length === 0)
+            return [];
+        const candidateIds = candidateRows.map((r) => r.id);
+        const placeholders = candidateIds.map((_, i) => `$${i + 2}`).join(', ');
+        // Phase 2: exact re-rank among candidates
+        const { rows } = await pool.query(`SELECT id, content, metadata,
+              1 - (embedding <=> $1::vector) AS similarity
+       FROM ${this.tableName}
+       WHERE id IN (${placeholders})
+       ORDER BY embedding <=> $1::vector
+       LIMIT ${limit}`, [vectorString, ...candidateIds]);
+        return rows.map((row) => ({
+            id: row.id,
+            content: row.content,
+            score: this.normalizeScore(row.similarity),
+            source: SearchSource.VECTOR,
+            metadata: row.metadata,
+        }));
+    }
+    // ── Delete / update ────────────────────────────────────────────────────────
+    async delete(id) {
+        const pool = await this.ensureInitialized();
+        const { rowCount } = await pool.query(`DELETE FROM ${this.tableName} WHERE id = $1`, [id]);
+        return (rowCount ?? 0) > 0;
+    }
+    async deleteByProject(projectId) {
+        const pool = await this.ensureInitialized();
+        const { rowCount } = await pool.query(`DELETE FROM ${this.tableName} WHERE project_id = $1`, [projectId]);
+        return rowCount ?? 0;
+    }
+    async update(id, content, metadata) {
+        await this.delete(id);
+        await this.addDocument(id, content, metadata);
+    }
+    // ── Stats / metadata ───────────────────────────────────────────────────────
+    async getStats(projectId) {
+        const pool = await this.ensureInitialized();
+        const queryText = projectId
+            ? `SELECT COUNT(*) as count,
+                SUM(LENGTH(content) + LENGTH(metadata::text) + COALESCE(LENGTH(embedding::text), 0)) as size
+         FROM ${this.tableName} WHERE project_id = $1`
+            : `SELECT COUNT(*) as count,
+                SUM(LENGTH(content) + LENGTH(metadata::text) + COALESCE(LENGTH(embedding::text), 0)) as size
+         FROM ${this.tableName}`;
+        const params = projectId ? [projectId] : [];
+        const { rows } = await pool.query(queryText, params);
+        const bqIndexName = `idx_${this.tableName}_embedding_bq`;
+        const floatIndexName = `idx_${this.tableName}_embedding`;
+        const activeIndex = this.bqEnabled ? bqIndexName : floatIndexName;
+        const { rows: idxRows } = await pool.query(`SELECT indexname FROM pg_indexes WHERE indexname = $1`, [activeIndex]);
+        return {
+            totalDocuments: parseInt(rows[0]?.count ?? '0'),
+            totalSize: parseInt(rows[0]?.size ?? '0'),
+            embeddingDimensions: this.schemaDimensions ?? undefined,
+            indexType: this.config.indexType,
+            indexStatus: idxRows.length > 0 ? 'ready' : 'none',
+        };
+    }
+    async listProjects() {
+        const pool = await this.ensureInitialized();
+        const { rows } = await pool.query(`
+      SELECT project_id,
+             COUNT(*) AS doc_count,
+             MAX(updated_at) AS last_updated,
+             SUM(LENGTH(content)) AS total_size
+      FROM ${this.tableName}
+      WHERE id NOT LIKE '_metadata:%'
+      GROUP BY project_id
+      ORDER BY last_updated DESC
+    `);
+        return rows.map((row) => ({
+            projectId: row.project_id,
+            projectPath: null,
+            documentCount: parseInt(row.doc_count),
+            totalSize: parseInt(row.total_size ?? '0'),
+            lastIndexed: row.last_updated?.toISOString() ?? null,
+        }));
+    }
+    // ── Misc ───────────────────────────────────────────────────────────────────
+    /**
+     * Get or create a collection (for IVectorStore interface compatibility).
+     *
+     * Mirrors PostgresVectorStore.getCollection semantics: returns a handle bound
+     * to this store's pool/table that scopes read/write by `name` (the projectId).
+     * IndexManager uses this for _metadata document lookup/persistence.
+     */
+    async getCollection(name) {
+        const pool = await this.ensureInitialized();
+        return new PostgresVectorCollection(pool, name, this.tableName, this);
+    }
+    async healthCheck() {
+        try {
+            if (!this.pool)
+                return false;
+            const { rows } = await this.pool.query('SELECT 1');
+            return rows.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.initialized = false;
+            logger.info('PostgresVectorStore closed');
+        }
+    }
+    // ── Package-internal accessors for PostgresVectorCollection ─────────────────
+    /** Embedding dimensions declared by the table schema, or null if unknown. */
+    getSchemaDimensions() {
+        return this.schemaDimensions;
+    }
+    /** True when the table has the embedding_bq column + index. */
+    isBqEnabled() {
+        return this.bqEnabled;
+    }
+    /** Encode a float embedding to a pgvector bit-string (binary quantization). */
+    toBitString(embedding) {
+        return this.floatsToBit(embedding);
+    }
+    /** Batch-embed texts via the shared provider (exposed for the collection). */
+    async embedBatchPublic(contents) {
+        return this.embedBatch(contents);
+    }
+}
+/**
+ * PostgreSQL Vector Collection implementation.
+ *
+ * Mirrors PostgreSQLVectorCollection semantics so IndexManager (the only caller of
+ * getCollection) works identically across backends. Scopes all read/write by
+ * `name` (the projectId). `query` supports the `where.id` fast path used for
+ * _metadata document lookup; `add` embeds content on demand when no embedding
+ * is supplied.
+ */
+class PostgresVectorCollection {
+    pool;
+    name;
+    tableName;
+    store;
+    constructor(pool, name, tableName, store) {
+        this.pool = pool;
+        this.name = name;
+        this.tableName = tableName;
+        this.store = store;
+    }
+    async count() {
+        const { rows } = await this.pool.query(`SELECT COUNT(*)::int AS count FROM ${this.tableName} WHERE project_id = $1`, [this.name]);
+        return rows[0]?.count || 0;
+    }
+    async query(params) {
+        const nResults = params?.nResults || 10;
+        const whereId = params?.where?.id;
+        // Fast path used by IndexManager for metadata lookup
+        if (whereId) {
+            const { rows } = await this.pool.query(`SELECT id, content, metadata
+         FROM ${this.tableName}
+         WHERE project_id = $1 AND id = $2
+         LIMIT $3`, [this.name, whereId, nResults]);
+            return rows.map((row) => ({
+                id: row.id,
+                content: row.content,
+                score: 1,
+                source: SearchSource.VECTOR,
+                metadata: typeof row.metadata === 'string' ? JSON.parse(row.metadata || '{}') : (row.metadata ?? {}),
+            }));
+        }
+        // Fallback: simple project-scoped fetch
+        const { rows } = await this.pool.query(`SELECT id, content, metadata
+       FROM ${this.tableName}
+       WHERE project_id = $1
+       ORDER BY updated_at DESC
+       LIMIT $2`, [this.name, nResults]);
+        return rows.map((row) => ({
+            id: row.id,
+            content: row.content,
+            score: 1,
+            source: SearchSource.VECTOR,
+            metadata: typeof row.metadata === 'string' ? JSON.parse(row.metadata || '{}') : (row.metadata ?? {}),
+        }));
+    }
+    async add(documents) {
+        if (!documents.length)
+            return;
+        // Embed any documents that arrived without a pre-computed embedding.
+        const needsEmbedding = documents.filter((d) => !d.embedding);
+        if (needsEmbedding.length > 0) {
+            const embeddings = await this.store.embedBatchPublic(needsEmbedding.map((d) => d.content));
+            needsEmbedding.forEach((d, i) => {
+                d.embedding = embeddings[i];
+            });
+        }
+        const schemaDims = this.store.getSchemaDimensions();
+        const bqEnabled = this.store.isBqEnabled();
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            for (const doc of documents) {
+                const embedding = doc.embedding;
+                const projectId = doc.metadata?.projectId || this.name;
+                if (schemaDims && embedding.length !== schemaDims) {
+                    throw new Error(`Embedding dimension mismatch: got ${embedding.length}, expected ${schemaDims}`);
+                }
+                const vectorString = `[${embedding.join(',')}]`;
+                if (bqEnabled) {
+                    const bqString = this.store.toBitString(embedding);
+                    await client.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding, embedding_bq)
+             VALUES ($1, $2, $3, $4, $5::vector, $6::bit(${schemaDims}))
+             ON CONFLICT (id) DO UPDATE SET
+               content = EXCLUDED.content,
+               metadata = EXCLUDED.metadata,
+               embedding = EXCLUDED.embedding,
+               embedding_bq = EXCLUDED.embedding_bq,
+               updated_at = NOW()`, [doc.id, projectId, doc.content, JSON.stringify(doc.metadata ?? {}), vectorString, bqString]);
+                }
+                else {
+                    await client.query(`INSERT INTO ${this.tableName} (id, project_id, content, metadata, embedding)
+             VALUES ($1, $2, $3, $4, $5::vector)
+             ON CONFLICT (id) DO UPDATE SET
+               content = EXCLUDED.content,
+               metadata = EXCLUDED.metadata,
+               embedding = EXCLUDED.embedding,
+               updated_at = NOW()`, [doc.id, projectId, doc.content, JSON.stringify(doc.metadata ?? {}), vectorString]);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async delete(ids) {
+        if (!ids.length)
+            return;
+        const client = await this.pool.connect();
+        try {
+            for (const id of ids) {
+                await client.query(`DELETE FROM ${this.tableName} WHERE id = $1 AND project_id = $2`, [id, this.name]);
+            }
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+//# sourceMappingURL=postgres-vector-store.js.map