@gmickel/gno 2.8.2 → 2.8.4

package/src/store/vector/partition-index.ts

@@ -0,0 +1,100 @@
+/**
+ * Maintenance of an activated vector partition's vec0 index
+ * (`vec_v1_<partition>`), which mirrors the partition's `vector_variants`.
+ * `gno vec sync` and `gno vec rebuild` use it on indexes embedded since 2.7.
+ * Neither changes authority, owners or variants, so the variant epoch stays.
+ *
+ * @module src/store/vector/partition-index
+ */
+import type { Database } from "bun:sqlite";
+
+export interface StoredPartition {
+  partitionId: string;
+  dimensions: number;
+}
+
+const tableName = (partition: StoredPartition): string =>
+  `vec_v1_${partition.partitionId}`;
+
+const createTable = (db: Database, partition: StoredPartition): void => {
+  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName(partition)} USING vec0(
+    variant_id INTEGER PRIMARY KEY,
+    embedding FLOAT[${partition.dimensions}] distance_metric=cosine
+  )`);
+};
+
+const insertVariants = (
+  db: Database,
+  partition: StoredPartition,
+  rows: Iterable<{ variantId: number; embedding: Uint8Array }>
+): number => {
+  let inserted = 0;
+  for (const row of rows) {
+    db.run(
+      `INSERT INTO ${tableName(partition)}(variant_id, embedding) VALUES (?, ?)`,
+      [row.variantId, row.embedding]
+    );
+    inserted += 1;
+  }
+  return inserted;
+};
+
+/**
+ * Remove index rows without a matching variant (orphans and stale
+ * embeddings), then add the variants the index lacks. Requires sqlite-vec.
+ */
+export function syncPartitionIndex(
+  db: Database,
+  partition: StoredPartition
+): { added: number; removed: number } {
+  const table = tableName(partition);
+  return db
+    .transaction(() => {
+      createTable(db, partition);
+      const stale = db
+        .query<{ variantId: number }, [string]>(`
+          SELECT x.variant_id AS variantId FROM ${table} x
+          LEFT JOIN vector_variants v ON v.variant_id = x.variant_id
+            AND v.partition_id = ?
+          WHERE v.variant_id IS NULL OR x.embedding != v.embedding
+        `)
+        .all(partition.partitionId);
+      for (const { variantId } of stale) {
+        db.run(`DELETE FROM ${table} WHERE variant_id = ?`, [variantId]);
+      }
+      const missing = db
+        .query<{ variantId: number; embedding: Uint8Array }, [string]>(`
+          SELECT v.variant_id AS variantId, v.embedding FROM vector_variants v
+          LEFT JOIN ${table} x ON x.variant_id = v.variant_id
+          WHERE v.partition_id = ? AND x.variant_id IS NULL
+        `)
+        .all(partition.partitionId);
+      return {
+        added: insertVariants(db, partition, missing),
+        removed: stale.length,
+      };
+    })
+    .immediate();
+}
+
+/** Drop and repopulate the index from the partition's variants. */
+export function rebuildPartitionIndex(
+  db: Database,
+  partition: StoredPartition
+): number {
+  return db
+    .transaction(() => {
+      db.exec(`DROP TABLE IF EXISTS ${tableName(partition)}`);
+      createTable(db, partition);
+      return insertVariants(
+        db,
+        partition,
+        db
+          .query<{ variantId: number; embedding: Uint8Array }, [string]>(
+            "SELECT variant_id AS variantId, embedding FROM vector_variants WHERE partition_id = ?"
+          )
+          .iterate(partition.partitionId)
+      );
+    })
+    .immediate();
+}

package/src/store/vector/stored-vectors.ts

@@ -53,25 +53,30 @@ interface PartitionVectorRow {
   embedding: Uint8Array;
 }
 
+const unitVector = (vector: Float32Array): Float32Array => {
+  let norm = 0;
+  for (const value of vector) norm += value * value;
+  norm = Math.sqrt(norm);
+  return norm > 0 ? vector.map((value) => value / norm) : vector;
+};
+
 /**
- * Chunk vectors of current active documents, ordered by chunk seq, keyed by
- * document id. Partition vectors count only while their owner still yields
- * the stored input (the rule vector search applies). `firstChunkOnly` keeps
- * the lowest-seq vector per document.
+ * The similarity source vector of each current active document, keyed by
+ * document id: the stored vector of its first chunk (lowest seq whose vector
+ * is current), unit-normalized. Every similarity surface (CLI, MCP, REST and
+ * graph edges) uses this one rule, so scores agree. Partition vectors count
+ * only while their owner still yields the stored input (the rule vector
+ * search applies).
  */
-export function readStoredDocumentVectors(
+export function readSimilaritySourceVectors(
   db: Database,
   source: StoredVectorSource,
-  documents: StoredVectorDocument[],
-  options: { firstChunkOnly?: boolean } = {}
-): Map<number, Float32Array[]> {
-  const vectors = new Map<number, Float32Array[]>();
+  documents: StoredVectorDocument[]
+): Map<number, Float32Array> {
+  const vectors = new Map<number, Float32Array>();
   const add = (documentId: number, blob: Uint8Array): void => {
-    const existing = vectors.get(documentId);
-    if (existing && options.firstChunkOnly) return;
-    const embedding = decodeEmbedding(blob);
-    if (existing) existing.push(embedding);
-    else vectors.set(documentId, [embedding]);
+    if (!vectors.has(documentId))
+      vectors.set(documentId, unitVector(decodeEmbedding(blob)));
   };
   if (documents.length === 0) return vectors;
 
@@ -95,7 +100,7 @@ export function readStoredDocumentVectors(
         JSON.stringify(documents.map((document) => document.id))
       );
     for (const row of rows) {
-      if (options.firstChunkOnly && vectors.has(row.documentId)) continue;
+      if (vectors.has(row.documentId)) continue;
       const input = formatDocForEmbedding(
         row.text,
         row.title ?? undefined,

package/browser-extension/artifacts/gno-browser-clipper-v2.8.2.zip.sha256

@@ -1 +0,0 @@
-7bc830276cb923a482b662b980208b0978bf8ddbfbade0873e67d9757cf9c989  gno-browser-clipper-v2.8.2.zip