cogmem 3.6.2

package/dist/embedding/ReEmbeddingPipeline.js

@@ -0,0 +1,119 @@
+export class ReEmbeddingPipeline {
+    neuronEmbeddingStore;
+    embeddingProvider;
+    memoryGraph;
+    db;
+    options;
+    running = false;
+    recentThroughput = [];
+    constructor(neuronEmbeddingStore, embeddingProvider, memoryGraph, db, options = {}) {
+        this.neuronEmbeddingStore = neuronEmbeddingStore;
+        this.embeddingProvider = embeddingProvider;
+        this.memoryGraph = memoryGraph;
+        this.db = db;
+        this.options = options;
+        this.initSchema();
+    }
+    async run(projectId) {
+        this.running = true;
+        const runStartedAt = Date.now();
+        let processed = 0;
+        try {
+            const modelId = this.embeddingProvider.modelId;
+            if (!this.neuronEmbeddingStore.hasStaleVectors(modelId)) {
+                this.clearProgress(projectId, modelId);
+                return { processed: 0, remaining: 0 };
+            }
+            const batchSize = Math.max(1, this.options.batchSize ?? 50);
+            const maxBudgetMs = this.options.maxBudgetMs ?? 60_000;
+            const startedAt = Date.now();
+            let cursor = this.readProgress(projectId, modelId);
+            while (true) {
+                const neuronIds = this.neuronEmbeddingStore.listStaleNeuronIds(modelId, projectId, cursor, batchSize);
+                if (neuronIds.length === 0) {
+                    this.clearProgress(projectId, modelId);
+                    this.recordThroughput(processed, Date.now() - runStartedAt);
+                    return { processed, remaining: 0 };
+                }
+                const live = neuronIds
+                    .map((id) => ({ id, neuron: this.memoryGraph.getNeuron(id) }))
+                    .filter((item) => Boolean(item.neuron?.content));
+                const missing = neuronIds.filter((id) => !live.some((item) => item.id === id));
+                for (const neuronId of missing)
+                    this.neuronEmbeddingStore.deleteNeuronEmbedding(neuronId);
+                if (live.length > 0) {
+                    const batchStartedAt = Date.now();
+                    const vectors = await this.embeddingProvider.embedBatch(live.map((item) => item.neuron.content));
+                    let batchProcessed = 0;
+                    for (let index = 0; index < live.length; index += 1) {
+                        const vector = vectors[index];
+                        if (!vector)
+                            continue;
+                        if (vector.length !== this.embeddingProvider.dimensions) {
+                            throw new Error(`Embedding dimension mismatch for ${modelId}: expected ${this.embeddingProvider.dimensions}, got ${vector.length}`);
+                        }
+                        this.neuronEmbeddingStore.upsert(live[index].id, modelId, vector, projectId);
+                        this.neuronEmbeddingStore.deleteStaleEmbeddingsForNeuron(live[index].id, modelId);
+                        processed += 1;
+                        batchProcessed += 1;
+                    }
+                    this.recordThroughput(batchProcessed, Date.now() - batchStartedAt);
+                }
+                cursor = neuronIds[neuronIds.length - 1];
+                this.saveProgress(projectId, modelId, cursor);
+                if (maxBudgetMs > 0 && Date.now() - startedAt >= maxBudgetMs) {
+                    return { processed, remaining: this.neuronEmbeddingStore.countStaleVectors(modelId, projectId) };
+                }
+            }
+        }
+        finally {
+            this.recordThroughput(processed, Date.now() - runStartedAt);
+            this.running = false;
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    getRecentThroughput() {
+        if (this.recentThroughput.length === 0)
+            return null;
+        return this.recentThroughput.reduce((sum, value) => sum + value, 0) / this.recentThroughput.length;
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS re_embedding_progress (
+        projectId TEXT NOT NULL,
+        modelId TEXT NOT NULL,
+        lastProcessedNeuronId TEXT NOT NULL DEFAULT '',
+        updatedAt INTEGER NOT NULL,
+        PRIMARY KEY (projectId, modelId)
+      );
+    `);
+    }
+    readProgress(projectId, modelId) {
+        const row = this.db.prepare(`
+      SELECT lastProcessedNeuronId FROM re_embedding_progress
+      WHERE projectId = ? AND modelId = ?
+    `).get(projectId, modelId);
+        return row?.lastProcessedNeuronId || '';
+    }
+    saveProgress(projectId, modelId, lastProcessedNeuronId) {
+        this.db.prepare(`
+      INSERT INTO re_embedding_progress (projectId, modelId, lastProcessedNeuronId, updatedAt)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(projectId, modelId) DO UPDATE SET
+        lastProcessedNeuronId = excluded.lastProcessedNeuronId,
+        updatedAt = excluded.updatedAt
+    `).run(projectId, modelId, lastProcessedNeuronId, Date.now());
+    }
+    clearProgress(projectId, modelId) {
+        this.db.prepare(`DELETE FROM re_embedding_progress WHERE projectId = ? AND modelId = ?`).run(projectId, modelId);
+    }
+    recordThroughput(processed, durationMs) {
+        if (processed <= 0 || durationMs <= 0)
+            return;
+        this.recentThroughput.push(processed / durationMs);
+        while (this.recentThroughput.length > 100)
+            this.recentThroughput.shift();
+    }
+}

package/dist/embedding/ReEmbeddingStatus.d.ts

@@ -0,0 +1,10 @@
+export interface ReEmbeddingStatus {
+    isRunning: boolean;
+    total: number;
+    completed: number;
+    failed: number;
+    percentComplete: number;
+    estimatedRemainingMs: number | null;
+    lastUpdatedAt: string;
+}
+//# sourceMappingURL=ReEmbeddingStatus.d.ts.map

package/dist/embedding/ReEmbeddingStatus.js

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

package/dist/embedding/index.d.ts

@@ -0,0 +1,11 @@
+export { EmbeddingUnavailableError } from './EmbeddingProvider.js';
+export type { EmbeddingProvider } from './EmbeddingProvider.js';
+export { OllamaEmbeddingProvider } from './OllamaEmbeddingProvider.js';
+export type { OllamaEmbeddingConfig } from './OllamaEmbeddingProvider.js';
+export { QwenAPIEmbeddingProvider } from './QwenAPIEmbeddingProvider.js';
+export type { QwenAPIEmbeddingConfig } from './QwenAPIEmbeddingProvider.js';
+export { NeuronEmbeddingStore } from './NeuronEmbeddingStore.js';
+export type { NearestNeuronEmbedding } from './NeuronEmbeddingStore.js';
+export { ReEmbeddingPipeline } from './ReEmbeddingPipeline.js';
+export type { ReEmbeddingOptions } from './ReEmbeddingPipeline.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/embedding/index.js

@@ -0,0 +1,5 @@
+export { EmbeddingUnavailableError } from './EmbeddingProvider.js';
+export { OllamaEmbeddingProvider } from './OllamaEmbeddingProvider.js';
+export { QwenAPIEmbeddingProvider } from './QwenAPIEmbeddingProvider.js';
+export { NeuronEmbeddingStore } from './NeuronEmbeddingStore.js';
+export { ReEmbeddingPipeline } from './ReEmbeddingPipeline.js';

package/dist/encryption/AesGcmEncryptionProvider.d.ts

@@ -0,0 +1,9 @@
+import type { EncryptionProvider } from './EncryptionProvider.js';
+export declare class AesGcmEncryptionProvider implements EncryptionProvider {
+    private readonly key;
+    constructor(key: Buffer);
+    static fromPassphrase(passphrase: string): AesGcmEncryptionProvider;
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+}
+//# sourceMappingURL=AesGcmEncryptionProvider.d.ts.map

package/dist/encryption/AesGcmEncryptionProvider.js

@@ -0,0 +1,42 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
+import { isEncryptedPayload } from './EncryptionProvider.js';
+export class AesGcmEncryptionProvider {
+    key;
+    constructor(key) {
+        this.key = key;
+        if (key.length !== 32) {
+            throw new Error(`AES-GCM key must be 32 bytes, got ${key.length}`);
+        }
+    }
+    static fromPassphrase(passphrase) {
+        return new AesGcmEncryptionProvider(createHash('sha256').update(passphrase).digest());
+    }
+    encrypt(plaintext) {
+        if (isEncryptedPayload(plaintext))
+            return plaintext;
+        const iv = randomBytes(12);
+        const cipher = createCipheriv('aes-256-gcm', this.key, iv);
+        const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return [
+            'enc:v1',
+            iv.toString('base64url'),
+            tag.toString('base64url'),
+            encrypted.toString('base64url'),
+        ].join(':');
+    }
+    decrypt(ciphertext) {
+        if (!isEncryptedPayload(ciphertext))
+            return ciphertext;
+        const [, version, ivRaw, tagRaw, encryptedRaw] = ciphertext.split(':');
+        if (version !== 'v1' || !ivRaw || !tagRaw || !encryptedRaw) {
+            throw new Error('Unsupported encrypted payload format');
+        }
+        const decipher = createDecipheriv('aes-256-gcm', this.key, Buffer.from(ivRaw, 'base64url'));
+        decipher.setAuthTag(Buffer.from(tagRaw, 'base64url'));
+        return Buffer.concat([
+            decipher.update(Buffer.from(encryptedRaw, 'base64url')),
+            decipher.final(),
+        ]).toString('utf8');
+    }
+}

package/dist/encryption/EncryptionProvider.d.ts

@@ -0,0 +1,6 @@
+export interface EncryptionProvider {
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+}
+export declare function isEncryptedPayload(value: string): boolean;
+//# sourceMappingURL=EncryptionProvider.d.ts.map

package/dist/encryption/EncryptionProvider.js

@@ -0,0 +1,3 @@
+export function isEncryptedPayload(value) {
+    return value.startsWith('enc:v1:');
+}

package/dist/encryption/index.d.ts

@@ -0,0 +1,4 @@
+export { AesGcmEncryptionProvider } from './AesGcmEncryptionProvider.js';
+export { isEncryptedPayload } from './EncryptionProvider.js';
+export type { EncryptionProvider } from './EncryptionProvider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/encryption/index.js

@@ -0,0 +1,2 @@
+export { AesGcmEncryptionProvider } from './AesGcmEncryptionProvider.js';
+export { isEncryptedPayload } from './EncryptionProvider.js';

package/dist/engine/BeliefExtractor.d.ts

@@ -0,0 +1,48 @@
+import type { BeliefCandidate, Neuron } from '../types/index.js';
+interface ExtractionContext {
+    neuron: Neuron;
+    sourceEventId: string;
+}
+export declare class BeliefExtractor {
+    extract(context: ExtractionContext): BeliefCandidate[];
+    private extractSchemaRules;
+    private extractFactRules;
+    private extractMultiSlotFacts;
+    private extractProceduralSequences;
+    private extractExecutablePlanGraphs;
+    private extractNestedFactGraphs;
+    private extractTemporalWindow;
+    private extractCondition;
+    private resolveValidityKind;
+    private getBaseContext;
+    private normalizeEntity;
+    private normalizeFactValue;
+    private parseSequenceSteps;
+    private buildConditionDsl;
+    private toConditionClause;
+    private parseConditionExpression;
+    private flattenConditionClauses;
+    private normalizeConditionOperators;
+    private stripOuterParentheses;
+    private isBalancedParentheses;
+    private splitTopLevelByOperators;
+    private parseNestedFactGraph;
+    private parseExecutablePlanGraph;
+    private parsePlanHandlers;
+    private parseHandlerSteps;
+    private parseRetryPolicies;
+    private parseMergePoints;
+    private parseBranchPoints;
+    private parseStateTransitions;
+    private parsePolicyExecutors;
+    private parseExecutionGuards;
+    private parseStateMachines;
+    private parsePolicyRuntime;
+    private parseMergeConstraints;
+    private parseRuntimeValidation;
+    private parseExecutorBindings;
+    private parseMergePropagation;
+    private dedupeCandidates;
+}
+export {};
+//# sourceMappingURL=BeliefExtractor.d.ts.map