hippo-memory 1.68.0 → 1.70.0

package/dist/store-port.js

@@ -1,166 +0,0 @@
-// The async seam the server reaches its store through, so an add-on can serve from a database other than hippo.db.
-import { listApiKeyRows, readApiKeyRecord } from './auth.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 { createKeyAt, createSelfKeyAt } from './store/key-writes.js';
-import { strengthenRetrievedInOwnTx } from './store/entry-writes.js';
-import { loadLatestHandoff } from './store/handoffs.js';
-import { updateStats } from './store/index-and-stats.js';
-import { loadRecallSearchEntries, loadVectorCandidateEntries } from './store/search-rows.js';
-import { listSessionEvents, loadActiveTaskSnapshot } from './store/sessions.js';
-import { entriesWithoutVectorAt, writeVectorsAt } from './store/vector-writes.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 {
-        return fn(db);
-    }
-    finally {
-        closeHippoDb(db);
-    }
-}
-/** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
-export function storeFor(ctx) {
-    return ctx.store ?? sqliteStore(ctx.hippoRoot);
-}
-/** The built-in store: today's synchronous hippo.db functions behind the port, each call on its own short-lived handles, so close has nothing to release. */
-export function sqliteStore(hippoRoot) {
-    return {
-        kind: 'sqlite',
-        async findApiKey(keyId) {
-            return onHandle(hippoRoot, (db) => readApiKeyRecord(db, keyId));
-        },
-        async searchRecallEntries(query, args) {
-            return loadRecallSearchEntries(hippoRoot, query, args.limit, args.tenantId, args.requestedScope, args.explicitScopeMode, args.includeSuperseded, args.originProjects, args.ownScope);
-        },
-        async entriesByIds(ids, tenantId) {
-            return loadEntriesByIds(hippoRoot, ids, tenantId);
-        },
-        async activeGoals(opts) {
-            return activeGoalsWithPolicies(hippoRoot, opts);
-        },
-        async freshRawEntries(count, tenantId, sessionId, origins) {
-            return loadFreshRawMemories(hippoRoot, count, tenantId, sessionId, origins ?? undefined);
-        },
-        async continuity(tenantId, eventLimit, key) {
-            return continuityAt(hippoRoot, tenantId, eventLimit, key);
-        },
-        async planningFallacyEvidence(tenantId, classQueryTokens) {
-            return planningFallacyEvidenceAt(hippoRoot, tenantId, classQueryTokens);
-        },
-        async appendAuditEvents(events) {
-            if (events.length === 0)
-                return;
-            onHandle(hippoRoot, (db) => withWriteScope(db, 'append_audit_events', () => {
-                for (const event of events)
-                    appendAuditEvent(db, event);
-            }));
-        },
-        async finishRecall(writes) {
-            finishRecallAt(hippoRoot, writes);
-        },
-        async bumpRecallStats(recalled) {
-            updateStats(hippoRoot, { recalled });
-        },
-        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),
-        keyWrites: sqliteKeyWrites(hippoRoot),
-        vectorWrites: {
-            async entriesWithoutVector(query) {
-                return onHandle(hippoRoot, (db) => entriesWithoutVectorAt(db, query));
-            },
-            async writeVectors(write) {
-                return onHandle(hippoRoot, (db) => writeVectorsAt(db, write));
-            },
-        },
-        async close() { },
-    };
-}
-function sqliteKeyWrites(hippoRoot) {
-    return {
-        async createApiKey(mint) {
-            onHandle(hippoRoot, (db) => createKeyAt(db, mint));
-        },
-        async createSelfApiKey(mint) {
-            return onHandle(hippoRoot, (db) => createSelfKeyAt(db, mint));
-        },
-        async listApiKeys(query) {
-            return onHandle(hippoRoot, (db) => listApiKeyRows(db, query));
-        },
-    };
-}
-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);
-    const sessionId = activeSnapshot?.session_id ?? undefined;
-    return {
-        activeSnapshot,
-        sessionHandoff: sessionId ? loadLatestHandoff(hippoRoot, tenantId, sessionId, {}, key ?? undefined) : null,
-        recentSessionEvents: sessionId ? listSessionEvents(hippoRoot, tenantId, { session_id: sessionId, limit: eventLimit }) : [],
-    };
-}
-/** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
-export function finishRecallAt(hippoRoot, writes) {
-    onHandle(hippoRoot, (db) => {
-        withWriteScope(db, 'finish_recall', () => {
-            writeGoalRecallLog(db, localGoalRecallRows(db, writes.goalLog));
-            for (const event of writes.audit)
-                appendAuditEvent(db, event);
-        });
-        // Each opens its own transaction, so neither can share the scope above.
-        if (writes.trace)
-            writeRecallTrace(db, writes.trace);
-        if (writes.strengthen)
-            strengthenRetrievedInOwnTx(db, writes.strengthen.ids, writes.strengthen.opts);
-    });
-}
-//# sourceMappingURL=store-port.js.map