cozo-memory 1.2.0 → 1.2.2

package/dist/memory-activation.js

@@ -18,22 +18,27 @@ class MemoryActivationService {
     /**
      * Calculate activation score for an observation
      * Formula: R = e^(-t/S)
+     * With emotional salience: decay rate is reduced by salienceBoostDecay
      */
-    calculateActivation(timeSinceAccess, strength) {
+    calculateActivation(timeSinceAccess, strength, salienceBoostDecay = 0.0) {
         if (timeSinceAccess === 0)
             return 1.0;
-        const exponent = -timeSinceAccess / strength;
+        // Apply salience decay reduction (slower decay for emotionally salient memories)
+        const effectiveTime = timeSinceAccess * (1.0 - salienceBoostDecay);
+        const exponent = -effectiveTime / strength;
         const activation = Math.pow(this.config.decayBase, exponent);
         return Math.max(0, Math.min(1, activation));
     }
     /**
      * Get current memory strength for an observation
      * S = initialStrength + (accessCount * strengthIncrement)
+     * With emotional salience boost: S = S * salienceBoostStrength
      */
-    calculateStrength(accessCount) {
-        const strength = this.config.initialStrength +
+    calculateStrength(accessCount, salienceBoostStrength = 1.0) {
+        const baseStrength = this.config.initialStrength +
             (accessCount * this.config.strengthIncrement);
-        return Math.min(strength, this.config.maxStrength);
+        const boostedStrength = baseStrength * salienceBoostStrength;
+        return Math.min(boostedStrength, this.config.maxStrength);
     }
     /**
      * Convert timestamp to time units since last access
@@ -57,12 +62,12 @@ class MemoryActivationService {
             const query = entityId
                 ? `
           ?[id, entity_id, text, metadata, created_at] := 
-            *observation{id, entity_id, text, metadata, created_at},
+            *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"},
             entity_id == $entity_id
         `
                 : `
           ?[id, entity_id, text, metadata, created_at] := 
-            *observation{id, entity_id, text, metadata, created_at}
+            *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"}
         `;
             const result = await this.db.run(query, entityId ? { entity_id: entityId } : {});
             const observations = result.rows;
@@ -71,15 +76,22 @@ class MemoryActivationService {
                 // Extract access metadata
                 const accessCount = (metadata?.access_count || 0);
                 const lastAccessTime = (metadata?.last_access_time || created_at);
-                // Calculate activation
+                // Extract emotional salience boosts (if present)
+                const salienceBoostStrength = (metadata?.salience_boost_strength || 1.0);
+                const salienceBoostDecay = (metadata?.salience_boost_decay || 0.0);
+                const salienceScore = (metadata?.emotional_salience || 0.0);
+                // Calculate activation with salience boosts
                 const timeSinceAccess = this.getTimeSinceAccess(lastAccessTime);
-                const strength = this.calculateStrength(accessCount);
-                const activation = this.calculateActivation(timeSinceAccess, strength);
+                const strength = this.calculateStrength(accessCount, salienceBoostStrength);
+                const activation = this.calculateActivation(timeSinceAccess, strength, salienceBoostDecay);
                 // Determine retention
                 const shouldRetain = activation >= this.config.retentionThreshold;
+                const salienceInfo = salienceScore > 0
+                    ? ` [Salience: ${salienceScore.toFixed(2)}, Boost: ×${salienceBoostStrength.toFixed(2)}]`
+                    : '';
                 const reason = shouldRetain
-                    ? `Active memory (activation: ${activation.toFixed(3)}, strength: ${strength.toFixed(1)})`
-                    : `Below threshold (activation: ${activation.toFixed(3)} < ${this.config.retentionThreshold})`;
+                    ? `Active memory (activation: ${activation.toFixed(3)}, strength: ${strength.toFixed(1)})${salienceInfo}`
+                    : `Below threshold (activation: ${activation.toFixed(3)} < ${this.config.retentionThreshold})${salienceInfo}`;
                 scores.push({
                     observationId: id,
                     entityId: entity_id,
@@ -105,15 +117,15 @@ class MemoryActivationService {
         try {
             // Get current observation
             const result = await this.db.run(`
-        ?[id, entity_id, text, metadata, created_at] := 
-          *observation{id, entity_id, text, metadata, created_at},
+        ?[id, entity_id, session_id, task_id, text, metadata, created_at] := 
+          *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"},
           id == $id
       `, { id: observationId });
             if (result.rows.length === 0) {
                 console.warn(`[MemoryActivation] Observation ${observationId} not found`);
                 return;
             }
-            const [id, entity_id, text, metadata, created_at] = result.rows[0];
+            const [id, entity_id, session_id, task_id, text, metadata, created_at] = result.rows[0];
             const currentMetadata = (metadata || {});
             // Update access metadata
             const accessCount = (currentMetadata.access_count || 0) + 1;
@@ -123,16 +135,28 @@ class MemoryActivationService {
                 access_count: accessCount,
                 last_access_time: lastAccessTime,
             };
+            // Get embedding (we need it for the update)
+            const embResult = await this.db.run(`
+        ?[embedding] := *observation{id: $id, embedding, @ "NOW"}
+      `, { id: observationId });
+            if (embResult.rows.length === 0) {
+                console.warn(`[MemoryActivation] Could not get embedding for observation ${observationId}`);
+                return;
+            }
+            const embedding = embResult.rows[0][0];
             // Update observation with new metadata
             await this.db.run(`
-        ?[id, entity_id, text, metadata, created_at] <- [
-          [$id, $entity_id, $text, $metadata, $created_at]
+        ?[id, entity_id, session_id, task_id, text, embedding, metadata, created_at] <- [
+          [$id, $entity_id, $session_id, $task_id, $text, $embedding, $metadata, $created_at]
         ]
-        :put observation {id, entity_id, text => metadata, created_at}
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
       `, {
                 id,
                 entity_id,
+                session_id,
+                task_id,
                 text,
+                embedding,
                 metadata: updatedMetadata,
                 created_at
             });
@@ -159,12 +183,12 @@ class MemoryActivationService {
             // Actually delete weak memories
             let pruned = 0;
             for (const candidate of candidates) {
-                // Delete the observation
+                // Delete the observation using :rm
                 await this.db.run(`
-          ?[id, entity_id, text, metadata, created_at] := 
-            *observation{id, entity_id, text, metadata, created_at},
+          ?[id, entity_id, session_id, task_id, text, metadata, created_at] := 
+            *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"},
             id == $id
-          :rm observation {id, entity_id, text => metadata, created_at}
+          :rm observation {id, created_at => entity_id, session_id, task_id, text, metadata}
         `, { id: candidate.observationId });
                 pruned++;
             }
@@ -244,8 +268,8 @@ class MemoryActivationService {
         try {
             // Get the observation
             const result = await this.db.run(`
-        ?[id, entity_id, text, metadata, created_at] := 
-          *observation{id, entity_id, text, metadata, created_at},
+        ?[id, entity_id, session_id, task_id, text, metadata, created_at] := 
+          *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"},
           id == $id
       `, { id: observationId });
             if (result.rows.length === 0) {
@@ -255,13 +279,13 @@ class MemoryActivationService {
             const [id, entity_id] = result.rows[0];
             // Get all observations for the same entity (excluding the current one)
             const relatedResult = await this.db.run(`
-        ?[id, entity_id, text, metadata, created_at] := 
-          *observation{id, entity_id, text, metadata, created_at},
+        ?[id, entity_id, session_id, task_id, text, metadata, created_at] := 
+          *observation{id, entity_id, session_id, task_id, text, metadata, created_at, @ "NOW"},
           entity_id == $entity_id,
           id != $id
       `, { entity_id, id: observationId });
             let boosted = 0;
-            for (const [relId, relEntityId, relText, relMetadata, relCreatedAt] of relatedResult.rows) {
+            for (const [relId, relEntityId, relSessionId, relTaskId, relText, relMetadata, relCreatedAt] of relatedResult.rows) {
                 const currentMetadata = (relMetadata || {});
                 // Simulate a partial access (priming effect)
                 const accessCount = (currentMetadata.access_count || 0) + boostFactor;
@@ -269,16 +293,26 @@ class MemoryActivationService {
                     ...currentMetadata,
                     access_count: accessCount,
                 };
+                // Get embedding
+                const embResult = await this.db.run(`
+          ?[embedding] := *observation{id: $id, embedding, @ "NOW"}
+        `, { id: relId });
+                if (embResult.rows.length === 0)
+                    continue;
+                const relEmbedding = embResult.rows[0][0];
                 // Update the related observation
                 await this.db.run(`
-          ?[id, entity_id, text, metadata, created_at] <- [
-            [$id, $entity_id, $text, $metadata, $created_at]
+          ?[id, entity_id, session_id, task_id, text, embedding, metadata, created_at] <- [
+            [$id, $entity_id, $session_id, $task_id, $text, $embedding, $metadata, $created_at]
           ]
-          :put observation {id, entity_id, text => metadata, created_at}
+          :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
         `, {
                     id: relId,
                     entity_id: relEntityId,
+                    session_id: relSessionId,
+                    task_id: relTaskId,
                     text: relText,
+                    embedding: relEmbedding,
                     metadata: updatedMetadata,
                     created_at: relCreatedAt
                 });

package/dist/memory-service.js

@@ -34,15 +34,51 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryService = void 0;
+const emotional_salience_js_1 = require("./emotional-salience.js");
+const zettelkasten_evolution_js_1 = require("./zettelkasten-evolution.js");
 const uuid_1 = require("uuid");
 const pdf_mjs_1 = require("pdfjs-dist/legacy/build/pdf.mjs");
 const fs = __importStar(require("fs"));
 class MemoryService {
     db;
     embeddings;
+    salienceService = null;
+    zettelkastenService = null;
     constructor(db, embeddings) {
         this.db = db;
         this.embeddings = embeddings;
+        // Services will be initialized when needed
+    }
+    getSalienceService() {
+        if (!this.salienceService) {
+            // Create a temporary CozoDb instance for salience service
+            // In production, this should use the actual CozoDB instance
+            const { CozoDb } = require('cozo-node');
+            const tempDb = new CozoDb();
+            this.salienceService = new emotional_salience_js_1.EmotionalSalienceService(tempDb, {
+                enableSalience: true,
+                salienceBoostFactor: 2.0,
+                decaySlowdownFactor: 0.5,
+                minSalienceThreshold: 0.3
+            });
+        }
+        return this.salienceService;
+    }
+    getZettelkastenService() {
+        if (!this.zettelkastenService) {
+            const { CozoDb } = require('cozo-node');
+            const tempDb = new CozoDb();
+            this.zettelkastenService = new zettelkasten_evolution_js_1.ZettelkastenEvolutionService(tempDb, this.embeddings, {
+                enableEvolution: true,
+                similarityThreshold: 0.7,
+                maxRelatedNotes: 5,
+                minKeywordFrequency: 2,
+                autoExtractKeywords: true,
+                autoBidirectionalLinks: true,
+                enrichmentDepth: 'shallow'
+            });
+        }
+        return this.zettelkastenService;
     }
     async createEntity(name, type, metadata = {}) {
         const id = (0, uuid_1.v4)();
@@ -73,6 +109,21 @@ class MemoryService {
     async addObservation(entityId, text, metadata = {}) {
         const id = (0, uuid_1.v4)();
         const embedding = await this.embeddings.embed(text);
+        // Calculate emotional salience automatically
+        const salienceService = this.getSalienceService();
+        const salienceResult = salienceService.calculateSalienceScore(text);
+        // Add salience metadata if score is above threshold
+        if (salienceResult.score >= 0.3) {
+            const boost = salienceService.calculateBoost(salienceResult.score);
+            metadata = {
+                ...metadata,
+                emotional_salience: salienceResult.score,
+                salience_category: salienceResult.category,
+                salience_keywords: salienceResult.keywords,
+                salience_boost_strength: boost.strengthMultiplier,
+                salience_boost_decay: boost.decayReduction
+            };
+        }
         const observation = {
             id: id,
             entity_id: entityId,
@@ -294,5 +345,22 @@ class MemoryService {
             total_chunks: chunks.length,
         };
     }
+    // Emotional Salience Methods
+    async getSalienceStats() {
+        return this.getSalienceService().getSalienceStats();
+    }
+    async getObservationSalience(observationId) {
+        return this.getSalienceService().getObservationSalience(observationId);
+    }
+    async applySalienceToExistingObservations(dryRun = false) {
+        return this.getSalienceService().applySalienceMetadata(dryRun);
+    }
+    // Zettelkasten Memory Evolution Methods
+    async getZettelkastenStats() {
+        return this.getZettelkastenService().getEvolutionStats();
+    }
+    async enrichObservationWithZettelkasten(observationId, observationText, observationEmbedding, entityId) {
+        return this.getZettelkastenService().enrichObservation(observationId, observationText, observationEmbedding, entityId);
+    }
 }
 exports.MemoryService = MemoryService;

package/dist/pre-storage-reasoning.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreStorageReasoningService = void 0;
+const ollama_1 = require("ollama");
+class PreStorageReasoningService {
+    db;
+    config;
+    ollama;
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = {
+            enablePreStorage: true,
+            ollamaModel: 'llama3.2:3b',
+            ollamaHost: 'http://localhost:11434',
+            extractEntities: true,
+            extractRelationships: true,
+            detectContradictions: true,
+            minConfidence: 0.6,
+            timeout: 10000,
+            ...config
+        };
+        this.ollama = new ollama_1.Ollama({ host: this.config.ollamaHost });
+    }
+    /**
+     * Analyze observation text before storage
+     */
+    async analyzeBeforeStorage(text, entityId, existingContext) {
+        const startTime = Date.now();
+        if (!this.config.enablePreStorage) {
+            return {
+                text,
+                entitySuggestions: [],
+                relationshipSuggestions: [],
+                contradictionWarnings: [],
+                processingTime: 0,
+                model: 'disabled'
+            };
+        }
+        try {
+            const analysis = {
+                text,
+                entitySuggestions: [],
+                relationshipSuggestions: [],
+                contradictionWarnings: [],
+                processingTime: 0,
+                model: this.config.ollamaModel
+            };
+            // Get entity context
+            const entityContext = await this.getEntityContext(entityId);
+            // Extract entities
+            if (this.config.extractEntities) {
+                analysis.entitySuggestions = await this.extractEntities(text, entityContext);
+            }
+            // Extract relationships
+            if (this.config.extractRelationships) {
+                analysis.relationshipSuggestions = await this.extractRelationships(text, entityContext, analysis.entitySuggestions);
+            }
+            // Detect contradictions
+            if (this.config.detectContradictions && existingContext) {
+                analysis.contradictionWarnings = await this.detectContradictions(text, existingContext);
+            }
+            analysis.processingTime = Date.now() - startTime;
+            return analysis;
+        }
+        catch (error) {
+            console.error('[PreStorageReasoning] Error analyzing observation:', error);
+            return {
+                text,
+                entitySuggestions: [],
+                relationshipSuggestions: [],
+                contradictionWarnings: [],
+                processingTime: Date.now() - startTime,
+                model: this.config.ollamaModel
+            };
+        }
+    }
+    /**
+     * Extract implied entities from text
+     */
+    async extractEntities(text, entityContext) {
+        const prompt = `You are an entity extraction expert. Analyze the following text and extract any entities (people, organizations, technologies, concepts, etc.) that are mentioned or implied.
+
+Context: ${entityContext}
+
+Text to analyze: "${text}"
+
+For each entity, provide:
+1. Name (exact name as it appears or should be named)
+2. Type (Person, Organization, Technology, Concept, Location, etc.)
+3. Confidence (0.0-1.0, how confident you are this is a distinct entity)
+4. Reason (brief explanation why this is an entity)
+
+Respond ONLY with valid JSON array format:
+[
+  {
+    "name": "Entity Name",
+    "type": "EntityType",
+    "confidence": 0.9,
+    "reason": "Brief reason"
+  }
+]
+
+If no entities found, return empty array: []`;
+        try {
+            const response = await this.ollama.generate({
+                model: this.config.ollamaModel,
+                prompt,
+                stream: false,
+                options: {
+                    temperature: 0.3,
+                    num_predict: 500
+                }
+            });
+            const jsonMatch = response.response.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                return [];
+            }
+            const entities = JSON.parse(jsonMatch[0]);
+            return entities.filter(e => e.confidence >= this.config.minConfidence);
+        }
+        catch (error) {
+            console.error('[PreStorageReasoning] Error extracting entities:', error);
+            return [];
+        }
+    }
+    /**
+     * Extract relationships from text
+     */
+    async extractRelationships(text, entityContext, extractedEntities) {
+        const entitiesStr = extractedEntities.length > 0
+            ? `\nExtracted entities: ${extractedEntities.map(e => e.name).join(', ')}`
+            : '';
+        const prompt = `You are a relationship extraction expert. Analyze the following text and extract relationships between entities.
+
+Context: ${entityContext}${entitiesStr}
+
+Text to analyze: "${text}"
+
+For each relationship, provide:
+1. fromEntity (source entity name)
+2. toEntity (target entity name)
+3. relationType (works_on, uses, manages, part_of, related_to, etc.)
+4. Confidence (0.0-1.0)
+5. Reason (brief explanation)
+
+Respond ONLY with valid JSON array format:
+[
+  {
+    "fromEntity": "Entity A",
+    "toEntity": "Entity B",
+    "relationType": "relationship_type",
+    "confidence": 0.8,
+    "reason": "Brief reason"
+  }
+]
+
+If no relationships found, return empty array: []`;
+        try {
+            const response = await this.ollama.generate({
+                model: this.config.ollamaModel,
+                prompt,
+                stream: false,
+                options: {
+                    temperature: 0.3,
+                    num_predict: 500
+                }
+            });
+            const jsonMatch = response.response.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                return [];
+            }
+            const relationships = JSON.parse(jsonMatch[0]);
+            return relationships.filter(r => r.confidence >= this.config.minConfidence);
+        }
+        catch (error) {
+            console.error('[PreStorageReasoning] Error extracting relationships:', error);
+            return [];
+        }
+    }
+    /**
+     * Detect contradictions with existing observations
+     */
+    async detectContradictions(newText, existingObservations) {
+        if (existingObservations.length === 0) {
+            return [];
+        }
+        const existingContext = existingObservations.slice(0, 5).join('\n- ');
+        const prompt = `You are a contradiction detection expert. Compare the new observation with existing observations and identify any contradictions.
+
+Existing observations:
+- ${existingContext}
+
+New observation: "${newText}"
+
+For each contradiction, provide:
+1. existingObservation (the contradicting observation text)
+2. contradiction (what contradicts)
+3. Confidence (0.0-1.0)
+4. Reason (brief explanation)
+
+Respond ONLY with valid JSON array format:
+[
+  {
+    "existingObservation": "Previous observation text",
+    "contradiction": "What contradicts",
+    "confidence": 0.9,
+    "reason": "Brief reason"
+  }
+]
+
+If no contradictions found, return empty array: []`;
+        try {
+            const response = await this.ollama.generate({
+                model: this.config.ollamaModel,
+                prompt,
+                stream: false,
+                options: {
+                    temperature: 0.3,
+                    num_predict: 500
+                }
+            });
+            const jsonMatch = response.response.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                return [];
+            }
+            const contradictions = JSON.parse(jsonMatch[0]);
+            return contradictions.filter(c => c.confidence >= this.config.minConfidence);
+        }
+        catch (error) {
+            console.error('[PreStorageReasoning] Error detecting contradictions:', error);
+            return [];
+        }
+    }
+    /**
+     * Get entity context for analysis
+     */
+    async getEntityContext(entityId) {
+        try {
+            const result = await this.db.run(`
+        ?[name, type] := *entity{id, name, type}, id = $id
+      `, { id: entityId });
+            if (result.rows.length === 0) {
+                return 'No entity context available';
+            }
+            const [name, type] = result.rows[0];
+            return `Entity: ${name} (${type})`;
+        }
+        catch (error) {
+            return 'No entity context available';
+        }
+    }
+    /**
+     * Get existing observations for contradiction detection
+     */
+    async getExistingObservations(entityId, limit = 10) {
+        try {
+            const result = await this.db.run(`
+        ?[text] := *observation{entity_id, text}, entity_id = $entity_id
+        :limit $limit
+      `, { entity_id: entityId, limit });
+            return result.rows.map((row) => row[0]);
+        }
+        catch (error) {
+            console.error('[PreStorageReasoning] Error getting existing observations:', error);
+            return [];
+        }
+    }
+    /**
+     * Auto-apply suggestions (create entities and relationships)
+     */
+    async autoApplySuggestions(analysis, autoCreateEntities = false, autoCreateRelationships = false) {
+        let entitiesCreated = 0;
+        let relationshipsCreated = 0;
+        // Auto-create entities
+        if (autoCreateEntities) {
+            for (const entity of analysis.entitySuggestions) {
+                try {
+                    // Check if entity already exists
+                    const existing = await this.db.run(`
+            ?[id] := *entity{id, name}, name = $name
+            :limit 1
+          `, { name: entity.name });
+                    if (existing.rows.length === 0) {
+                        // Create new entity
+                        const id = `entity-${Math.random().toString(36).substring(7)}`;
+                        await this.db.run(`
+              ?[id, name, type, metadata] <- [[
+                $id,
+                $name,
+                $type,
+                {"source": "pre_storage_reasoning", "confidence": $confidence}
+              ]]
+              :put entity {id, name, type}
+            `, {
+                            id,
+                            name: entity.name,
+                            type: entity.type,
+                            confidence: entity.confidence
+                        });
+                        entitiesCreated++;
+                    }
+                }
+                catch (error) {
+                    console.error(`[PreStorageReasoning] Error creating entity ${entity.name}:`, error);
+                }
+            }
+        }
+        // Auto-create relationships
+        if (autoCreateRelationships) {
+            for (const rel of analysis.relationshipSuggestions) {
+                try {
+                    // Find entity IDs
+                    const fromResult = await this.db.run(`
+            ?[id] := *entity{id, name}, name = $name
+            :limit 1
+          `, { name: rel.fromEntity });
+                    const toResult = await this.db.run(`
+            ?[id] := *entity{id, name}, name = $name
+            :limit 1
+          `, { name: rel.toEntity });
+                    if (fromResult.rows.length > 0 && toResult.rows.length > 0) {
+                        const fromId = fromResult.rows[0][0];
+                        const toId = toResult.rows[0][0];
+                        // Create relationship
+                        await this.db.run(`
+              ?[from_id, to_id, relation_type, strength, metadata] <- [[
+                $from_id,
+                $to_id,
+                $relation_type,
+                $confidence,
+                {"source": "pre_storage_reasoning"}
+              ]]
+              :put relationship {from_id, to_id, relation_type, strength, metadata}
+            `, {
+                            from_id: fromId,
+                            to_id: toId,
+                            relation_type: rel.relationType,
+                            confidence: rel.confidence
+                        });
+                        relationshipsCreated++;
+                    }
+                }
+                catch (error) {
+                    console.error(`[PreStorageReasoning] Error creating relationship:`, error);
+                }
+            }
+        }
+        return { entitiesCreated, relationshipsCreated };
+    }
+}
+exports.PreStorageReasoningService = PreStorageReasoningService;