hippo-memory 1.65.0 → 1.67.0

package/dist/store-port.js

@@ -1,17 +1,32 @@
 // The async seam the server reaches its store through, so an add-on can serve from a database other than hippo.db.
 import { readApiKeyRecord } from './auth.js';
-import { appendAuditEvent } from './audit.js';
+import { appendAuditEvent, listAuditEventsAfter } from './audit.js';
 import { closeHippoDb, openHippoDb, withWriteScope } from './db.js';
+import { StoreNotPortedError } from './db/sqlite-blocked.js';
+import { embeddingIndexStateAt, loadStoredVectors } from './embeddings.js';
 import { activeGoalsWithPolicies, localGoalRecallRows, writeGoalRecallLog, } from './goals.js';
+import { loadPhysicsState } from './physics-state.js';
 import { planningFallacyEvidenceAt } from './predictions/planning-fallacy.js';
 import { writeRecallTrace } from './recall-trace.js';
 import { loadEntriesByIds, loadFreshRawMemories } from './store/entry-reads.js';
+import { auditHighIdAt, revokeKeyAt } from './store/key-audit.js';
 import { strengthenRetrievedInOwnTx } from './store/entry-writes.js';
 import { loadLatestHandoff } from './store/handoffs.js';
 import { updateStats } from './store/index-and-stats.js';
-import { loadRecallSearchEntries } from './store/search-rows.js';
+import { loadRecallSearchEntries, loadVectorCandidateEntries } from './store/search-rows.js';
 import { listSessionEvents, loadActiveTaskSnapshot } from './store/sessions.js';
 import { recordTokenUse } from './token-ledger.js';
+export function hasGroup(store, group) {
+    return group === 'base' || store[group] !== undefined;
+}
+/** The group's methods; a store without them throws StoreNotPortedError, which answers 501 as any unported path does. */
+export function requireGroup(store, group) {
+    const groups = store;
+    const methods = groups[group];
+    if (methods === undefined)
+        throw new StoreNotPortedError(store.kind, group);
+    return methods;
+}
 function onHandle(hippoRoot, fn) {
     const db = openHippoDb(hippoRoot);
     try {
@@ -67,9 +82,38 @@ export function sqliteStore(hippoRoot) {
         async recordTokens(use) {
             onHandle(hippoRoot, (db) => recordTokenUse(db, use));
         },
+        vectors: {
+            async embeddingIndexState() {
+                return embeddingIndexStateAt(hippoRoot);
+            },
+            async storedVectors(ids) {
+                return loadStoredVectors(hippoRoot, ids);
+            },
+            async nearestEntries(queryVector, spec) {
+                return loadVectorCandidateEntries(hippoRoot, queryVector, spec);
+            },
+            async physicsParticles(ids) {
+                // loadPhysicsState reads every row for an empty list.
+                return ids.length === 0 ? new Map() : onHandle(hippoRoot, (db) => loadPhysicsState(db, [...ids]));
+            },
+        },
+        keyAudit: sqliteKeyAudit(hippoRoot),
         async close() { },
     };
 }
+function sqliteKeyAudit(hippoRoot) {
+    return {
+        async revokeApiKey(revoke) {
+            return onHandle(hippoRoot, (db) => revokeKeyAt(db, revoke));
+        },
+        async auditEventsAfter(opts) {
+            return onHandle(hippoRoot, (db) => listAuditEventsAfter(db, opts));
+        },
+        async auditHighId() {
+            return onHandle(hippoRoot, auditHighIdAt);
+        },
+    };
+}
 /** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
 export function continuityAt(hippoRoot, tenantId, eventLimit, key) {
     const activeSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId, key ?? undefined);

package/dist/vector-store.d.ts

@@ -18,6 +18,14 @@ export interface VectorMatch {
     id: string;
     score: number;
 }
+/** A stored vector, decoded. */
+export interface VectorRow {
+    readonly id: string;
+    readonly vector: Float32Array;
+}
+/** The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top k.
+ *  The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the same bytes ranks alike. */
+export declare function rankVectorRows(query: readonly number[], rows: Iterable<VectorRow>, k: number): VectorMatch[];
 /** The `k` stored vectors closest to `query` among `memories m` rows passing `where` (SQL starting with ` AND`).
  *  Filters run before the cut, so rows a caller may not see can never push admitted rows out of the top k. */
 export declare function topVectorMatches(db: DatabaseSyncLike, query: readonly number[], k: number, where: string, params: readonly (string | number)[]): VectorMatch[];

package/dist/vector-store.js

@@ -24,8 +24,8 @@ export function encodeVector(vector) {
     return new Uint8Array(Float32Array.from(vector).buffer);
 }
 export function decodeVector(blob) {
-    // A view needs 4-byte alignment; copy when SQLite hands back an unaligned slice.
-    const bytes = blob.byteOffset % 4 === 0 ? blob : blob.slice();
+    // A view needs 4-byte alignment; Buffer#slice is a view too, so copy with the constructor.
+    const bytes = blob.byteOffset % 4 === 0 ? blob : new Uint8Array(blob);
     return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
 }
 /** Insert or replace vectors, skipping empty or non-finite ones; the caller owns any surrounding transaction. */
@@ -92,28 +92,22 @@ export function storedVectorIds(db) {
 export function hasStoredVectors(db) {
     return db.prepare('SELECT 1 FROM memory_vectors LIMIT 1').get() !== undefined;
 }
-/** The `k` stored vectors closest to `query` among `memories m` rows passing `where` (SQL starting with ` AND`).
- *  Filters run before the cut, so rows a caller may not see can never push admitted rows out of the top k. */
-export function topVectorMatches(db, query, k, where, params) {
+/** The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top k.
+ *  The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the same bytes ranks alike. */
+export function rankVectorRows(query, rows, k) {
+    const top = [];
     if (k <= 0 || query.length === 0)
-        return [];
+        return top;
     const q = Float32Array.from(query);
     let qNorm = 0;
     for (let i = 0; i < q.length; i++)
         qNorm += q[i] * q[i];
     qNorm = Math.sqrt(qNorm);
     if (qNorm < 1e-10)
-        return [];
-    // SHORTCUT: brute-force cosine over every vector of matching dim, fine to ~100k rows; an ANN index (sqlite-vec, HNSW) is the upgrade.
-    const rows = db.prepare(`
-    SELECT v.memory_id AS id, v.vector AS vector
-    FROM memory_vectors v JOIN memories m ON m.id = v.memory_id
-    WHERE v.dim = ?${where}
-  `).iterate(q.length, ...params);
-    const top = [];
-    // SAFETY: the SELECT above names exactly these two columns; node:sqlite returns BLOBs as Uint8Array.
-    for (const row of rows) {
-        const v = decodeVector(row.vector);
+        return top;
+    for (const { id, vector: v } of rows) {
+        if (v.length !== q.length)
+            continue;
         let dot = 0;
         let norm = 0;
         for (let i = 0; i < v.length; i++) {
@@ -123,12 +117,30 @@ export function topVectorMatches(db, query, k, where, params) {
         if (norm < 1e-20)
             continue;
         const score = dot / (qNorm * Math.sqrt(norm));
-        if (top.length === k && !beats(score, row.id, top[k - 1]))
+        if (top.length === k && !beats(score, id, top[k - 1]))
             continue;
-        insertSorted(top, { id: row.id, score }, k);
+        insertSorted(top, { id, score }, k);
     }
     return top;
 }
+function* decodedRows(rows) {
+    for (const row of rows)
+        yield { id: row.id, vector: decodeVector(row.vector) };
+}
+/** The `k` stored vectors closest to `query` among `memories m` rows passing `where` (SQL starting with ` AND`).
+ *  Filters run before the cut, so rows a caller may not see can never push admitted rows out of the top k. */
+export function topVectorMatches(db, query, k, where, params) {
+    if (k <= 0 || query.length === 0)
+        return [];
+    // SHORTCUT: brute-force cosine over every vector of matching dim, fine to ~100k rows; an ANN index (sqlite-vec, HNSW) is the upgrade.
+    const rows = db.prepare(`
+    SELECT v.memory_id AS id, v.vector AS vector
+    FROM memory_vectors v JOIN memories m ON m.id = v.memory_id
+    WHERE v.dim = ?${where}
+  `).iterate(query.length, ...params);
+    // SAFETY: the SELECT above names exactly these two columns; node:sqlite returns BLOBs as Uint8Array.
+    return rankVectorRows(query, decodedRows(rows), k);
+}
 // Ties break on id so the cut is the same on every run.
 function beats(score, id, other) {
     return score > other.score || (score === other.score && id < other.id);

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.65.0";
+export declare const PACKAGE_VERSION = "1.67.0";
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export declare const EXPIRING_KEYS_MIN_BINARY = "1.64.0";
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.65.0';
+export const PACKAGE_VERSION = '1.67.0';
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export const EXPIRING_KEYS_MIN_BINARY = '1.64.0';
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.65.0",
+  "version": "1.67.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.65.0",
+  "version": "1.67.0",
   "type": "module",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.65.0",
+  "version": "1.67.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.65.0",
+  "version": "1.67.0",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",