squish-memory 1.1.5 → 1.2.0

package/core/memory/contradiction-resolver.ts

@@ -0,0 +1,494 @@
+/**
+ * Contradiction Resolver
+ * Detects and auto-resolves contradictions when writing new memories
+ * Implements supersession logic for outdated information
+ */
+
+import { eq, and, inArray } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+import { createAssociation } from '../associations.js';
+
+export interface ContradictionResult {
+  hasContradiction: boolean;
+  supersededMemories: string[];
+  confidence: number;
+  reason: string;
+}
+
+export interface ContradictionCheck {
+  newContent: string;
+  newType: string;
+  projectId?: string;
+  entities?: string[];
+}
+
+/**
+ * Calculate temporal relationship between two time periods
+ * Returns: 'existing_is_newer', 'existing_is_older', 'overlapping', or 'unknown'
+ */
+function calculateTemporalRelationship(
+  existingValidFrom: string | null,
+  existingValidTo: string | null,
+  newTime: Date
+): 'existing_is_newer' | 'existing_is_older' | 'overlapping' | 'unknown' {
+  if (!existingValidFrom && !existingValidTo) {
+    return 'unknown';
+  }
+  
+  const existingFrom = existingValidFrom ? new Date(existingValidFrom) : null;
+  const existingTo = existingValidTo ? new Date(existingValidTo) : null;
+  
+  // If existing fact is completely in the future compared to new time
+  if (existingFrom && existingFrom > newTime) {
+    return 'existing_is_newer';
+  }
+  
+  // If existing fact is completely in the past compared to new time
+  if (existingTo && existingTo < newTime) {
+    return 'existing_is_older';
+  }
+  
+  // If time periods overlap or we can't determine
+  return 'overlapping';
+}
+
+/**
+ * Check if two temporal periods conflict (don't overlap reasonably)
+ */
+function checkTemporalPeriodConflict(
+  existingStart: string | null,
+  existingEnd: string | null,
+  newStart: Date,
+  newEnd: Date | null
+): boolean {
+  // If we don't have enough info, assume no conflict
+  if (!existingStart || !existingEnd) {
+    return false;
+  }
+  
+  const existingStartDate = new Date(existingStart);
+  const existingEndDate = new Date(existingEnd);
+  
+  // Normalize newEnd (use distant future if null)
+  const normalizedNewEnd = newEnd || new Date(8640000000000000); // Far future
+  
+  // Check if periods overlap
+  const overlaps = !(existingStartDate > normalizedNewEnd || 
+                    existingEndDate < newStart);
+  
+  // Conflict if they don't overlap
+  return !overlaps;
+}
+
+// Patterns that indicate updated/corrected information
+const UPDATE_PATTERNS = [
+  /\b(now|currently|actually|in fact|correct(ed)?|update(d)?)\b/gi,
+  /\b(changed to|switched to|moved to)\b/gi,
+  /\b(formerly|previously|used to be)\b/gi,
+  /\binstead of\b/gi,
+  /\b(no longer|not anymore)\b/gi,
+  /\b(as of|starting|beginning|from now|effective)\s+(\d{4}|\w+\s+\d{1,2})/gi, // Temporal updates
+];
+
+// Negation patterns
+const NEGATION_PATTERNS = [
+  /\b(not|no|never|don't|doesn't|didn't|won't|wouldn't|shouldn't|can't|cannot)\b/gi,
+];
+
+// Temporal sensitivity patterns - content that is likely time-sensitive
+const TEMPORAL_SENSITIVITY_PATTERNS = [
+  /\b(date|time|version|release|deadline|schedule|timeline)\b/i,
+  /\b(\d{4}|january|february|march|april|may|june|july|august|september|october|november|december)\b/i,
+  /\b(today|tomorrow|yesterday|next\s+week|last\s+week|this\s+week)\b/i,
+];
+
+// Key entity extraction for contradiction detection
+function extractKeyEntities(content: string): string[] {
+  // Simple extraction of capitalized phrases and key terms
+  const entities: string[] = [];
+  
+  // Match capitalized multi-word phrases (likely proper nouns)
+  const properNouns = content.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+\b/g) || [];
+  entities.push(...properNouns);
+  
+  // Match quoted strings (often important values)
+  const quoted = content.match(/"([^"]+)"|'([^']+)'/g) || [];
+  entities.push(...quoted.map(q => q.replace(/['"]/g, '')));
+  
+  // Match key-value patterns
+  const keyValues = content.match(/(\w+)\s*[=:]\s*(\S+)/g) || [];
+  entities.push(...keyValues);
+  
+  return [...new Set(entities)];
+}
+
+// Calculate content similarity (Jaccard on words)
+function calculateSimilarity(a: string, b: string): number {
+  const tokensA = new Set(a.toLowerCase().split(/\s+/).filter(t => t.length > 2));
+  const tokensB = new Set(b.toLowerCase().split(/\s+/).filter(t => t.length > 2));
+  
+  const intersection = new Set([...tokensA].filter(x => tokensB.has(x)));
+  const union = new Set([...tokensA, ...tokensB]);
+  
+  return union.size > 0 ? intersection.size / union.size : 0;
+}
+
+// Check if content has negation
+function hasNegation(content: string): boolean {
+  return NEGATION_PATTERNS.some(pattern => pattern.test(content));
+}
+
+// Check if content indicates an update
+function hasUpdateIndicator(content: string): boolean {
+  return UPDATE_PATTERNS.some(pattern => pattern.test(content));
+}
+
+// Extract the "subject" of a memory (what it's about)
+function extractSubject(content: string): string {
+  // Take first significant clause
+  const sentences = content.split(/[.!?\n]/);
+  const firstSentence = sentences[0]?.trim() || content;
+  
+  // Limit to first 100 chars for subject matching
+  return firstSentence.substring(0, 100).toLowerCase();
+}
+
+/**
+ * Detect contradictions between new memory and existing memories
+ */
+export async function detectContradictions(check: ContradictionCheck): Promise<ContradictionResult> {
+  const result: ContradictionResult = {
+    hasContradiction: false,
+    supersededMemories: [],
+    confidence: 0,
+    reason: '',
+  };
+
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+    
+    // Get memories from same project with similar content
+    const whereClause = check.projectId
+      ? eq(schema.memories.projectId, check.projectId)
+      : undefined;
+    
+    const existingMemories = await (db as any)
+      .select()
+      .from(schema.memories)
+      .where(whereClause)
+      .limit(100);
+    
+    if (existingMemories.length === 0) {
+      return result;
+    }
+    
+    const newSubject = extractSubject(check.newContent);
+    const newEntities = extractKeyEntities(check.newContent);
+    const newHasNegation = hasNegation(check.newContent);
+    const newHasUpdate = hasUpdateIndicator(check.newContent);
+    
+    const toSupersede: string[] = [];
+    let maxConfidence = 0;
+    let reasons: string[] = [];
+    
+    for (const existing of existingMemories) {
+      // Skip already superseded memories
+      if (existing.status === 'superseded' || existing.status === 'merged') {
+        continue;
+      }
+      
+      // Skip protected memories
+      if (existing.isProtected) {
+        continue;
+      }
+      
+      const existingSubject = extractSubject(existing.content);
+      const similarity = calculateSimilarity(check.newContent, existing.content);
+      const subjectSimilarity = calculateSimilarity(newSubject, existingSubject);
+      
+      // Check for entity overlap
+      const existingEntities = extractKeyEntities(existing.content);
+      const entityOverlap = newEntities.filter(e => 
+        existingEntities.some(ee => ee.toLowerCase().includes(e.toLowerCase()) || 
+                                    e.toLowerCase().includes(ee.toLowerCase()))
+      );
+      
+       // Calculate temporal relationship between memories
+       const temporalRelationship = calculateTemporalRelationship(
+         existing.validFrom, 
+         existing.validTo, 
+         new Date() // current time for new memory
+       );
+       
+       // Detect contradiction scenarios with temporal awareness
+       
+       // Scenario 1: High similarity with negation in new content
+       if (similarity > 0.5 && newHasNegation && subjectSimilarity > 0.4) {
+         // Adjust confidence based on temporal relevance
+         let temporalFactor = 1.0;
+         if (temporalRelationship === 'existing_is_newer') {
+           temporalFactor = 0.7; // Lower confidence if existing is newer
+         } else if (temporalRelationship === 'existing_is_older') {
+           temporalFactor = 1.2; // Higher confidence if existing is older
+         }
+         
+         toSupersede.push(existing.id);
+         maxConfidence = Math.max(maxConfidence, similarity * 0.9 * temporalFactor);
+         reasons.push(`negation of similar content (${(similarity * 100).toFixed(0)}% similar)`);
+         continue;
+       }
+       
+       // Scenario 2: Update indicator with overlapping subject
+       if (newHasUpdate && subjectSimilarity > 0.5) {
+         // Boost confidence for updates when existing is older
+         let temporalFactor = 1.0;
+         if (temporalRelationship === 'existing_is_older') {
+           temporalFactor = 1.3; // Higher confidence for updating older info
+         }
+         
+         toSupersede.push(existing.id);
+         maxConfidence = Math.max(maxConfidence, subjectSimilarity * 0.85 * temporalFactor);
+         reasons.push(`update to existing information`);
+         continue;
+       }
+       
+       // Scenario 3: Same type, high subject similarity, different conclusion
+       if (existing.type === check.newType && subjectSimilarity > 0.6) {
+         // Check if conclusions differ
+         const existingHasNegation = hasNegation(existing.content);
+         
+         // XOR: one has negation, other doesn't
+         if (newHasNegation !== existingHasNegation) {
+           // Adjust confidence based on temporal relationship
+           let temporalFactor = 1.0;
+           if (temporalRelationship === 'existing_is_newer') {
+             temporalFactor = 0.8; // Lower confidence if contradicting newer info
+           } else if (temporalRelationship === 'existing_is_older') {
+             temporalFactor = 1.1; // Higher confidence if contradicting older info
+           }
+           
+           toSupersede.push(existing.id);
+           maxConfidence = Math.max(maxConfidence, subjectSimilarity * 0.8 * temporalFactor);
+           reasons.push(`contradicting statement about same topic`);
+           continue;
+         }
+       }
+       
+       // Scenario 4: Entity overlap with correction signals
+       if (entityOverlap.length >= 2 && similarity > 0.3) {
+         const correctionSignals = /\b(fixed|changed|updated|replaced|removed|added)\b/i.test(check.newContent);
+         if (correctionSignals) {
+           // Consider temporal relevance for corrections
+           let temporalFactor = 1.0;
+           if (temporalRelationship === 'existing_is_older') {
+             temporalFactor = 1.2; // Higher confidence for correcting older info
+           }
+           
+           toSupersede.push(existing.id);
+           maxConfidence = Math.max(maxConfidence, 0.75 * temporalFactor);
+           reasons.push(`correction involving ${entityOverlap.slice(0, 2).join(', ')}`);
+           continue;
+         }
+       }
+       
+       // Scenario 5: Very high similarity (near-duplicate) - supersede older
+       if (similarity > 0.85) {
+         // Prefer to supersede older memories with newer ones
+         let temporalFactor = 1.0;
+         if (temporalRelationship === 'existing_is_older') {
+           temporalFactor = 1.1; // Slight boost for superseding older
+         } else if (temporalRelationship === 'existing_is_newer') {
+           temporalFactor = 0.9; // Slight reduction for superseding newer
+         }
+         
+         toSupersede.push(existing.id);
+         maxConfidence = Math.max(maxConfidence, similarity * temporalFactor);
+         reasons.push(`near-duplicate replacement`);
+         continue;
+       }
+       
+       // Scenario 6: Temporal inconsistency - same subject but different time periods
+       if (subjectSimilarity > 0.7 && similarity > 0.4 && 
+           existing.validFrom && existing.validTo) {
+         // Check if temporal periods don't overlap reasonably
+         const newValidFrom = new Date(); // When we learned this
+         const newValidTo = null; // Open-ended by default
+         
+         const hasTemporalConflict = checkTemporalPeriodConflict(
+           existing.validFrom, existing.validTo,
+           newValidFrom, newValidTo
+         );
+         
+         if (hasTemporalConflict) {
+           toSupersede.push(existing.id);
+           maxConfidence = Math.max(maxConfidence, 0.8);
+           reasons.push(`temporal inconsistency with existing fact`);
+           continue;
+         }
+       }
+    }
+    
+    if (toSupersede.length > 0) {
+      result.hasContradiction = true;
+      result.supersededMemories = [...new Set(toSupersede)]; // Dedupe
+      result.confidence = maxConfidence;
+      result.reason = reasons[0] || 'contradiction detected';
+    }
+    
+  } catch (error) {
+    logger.error('Error detecting contradictions', error);
+  }
+  
+  return result;
+}
+
+/**
+ * Apply supersession to memories - archive old ones and create associations
+ */
+export async function applySupersession(
+  newMemoryId: string,
+  supersededIds: string[],
+  confidence: number
+): Promise<void> {
+  if (supersededIds.length === 0) return;
+  
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+    const now = new Date();
+    
+    // Update superseded memories
+    await (db as any)
+      .update(schema.memories)
+      .set({
+        status: 'superseded',
+        supersededBy: newMemoryId,
+        supersededAt: now,
+        updatedAt: now,
+      })
+      .where(inArray(schema.memories.id, supersededIds));
+    
+    // Create associations for traceability
+    for (const oldId of supersededIds) {
+      await createAssociation(newMemoryId, oldId, 'supersedes', confidence);
+    }
+    
+    logger.info('Applied supersession', {
+      newMemoryId,
+      supersededCount: supersededIds.length,
+      confidence,
+    });
+    
+  } catch (error) {
+    logger.error('Error applying supersession', error);
+  }
+}
+
+/**
+ * Check for temporal contradictions (facts that are no longer valid)
+ */
+export async function checkTemporalContradictions(
+  content: string,
+  projectId?: string
+): Promise<string[]> {
+  const supersededIds: string[] = [];
+  
+  try {
+    // Look for temporal update patterns
+    const temporalUpdates = content.match(
+      /\b(as of|starting|beginning|from now|effective)\s+(\d{4}|\w+\s+\d{1,2})/gi
+    );
+    
+    if (!temporalUpdates || temporalUpdates.length === 0) {
+      return supersededIds;
+    }
+    
+    const db = await getDb();
+    const schema = await getSchema();
+    
+    // Find memories with overlapping subject but older validTo dates
+    const subject = extractSubject(content);
+    
+    const whereClause = projectId
+      ? and(
+          eq(schema.memories.projectId, projectId),
+          eq(schema.memories.status, 'active')
+        )
+      : eq(schema.memories.status, 'active');
+    
+    const candidates = await (db as any)
+      .select()
+      .from(schema.memories)
+      .where(whereClause)
+      .limit(50);
+    
+    for (const candidate of candidates) {
+      const candidateSubject = extractSubject(candidate.content);
+      const similarity = calculateSimilarity(subject, candidateSubject);
+      
+      if (similarity > 0.5 && candidate.validTo) {
+        const validToDate = new Date(candidate.validTo);
+        const now = new Date();
+        
+        // If the candidate's validity period has passed
+        if (validToDate < now) {
+          supersededIds.push(candidate.id);
+        }
+      }
+    }
+    
+  } catch (error) {
+    logger.error('Error checking temporal contradictions', error);
+  }
+  
+  return supersededIds;
+}
+
+/**
+ * Integrated contradiction resolution for the write path
+ * Call this before storing a new memory
+ */
+export async function resolveContradictions(
+  content: string,
+  type: string,
+  projectId?: string
+): Promise<{
+  shouldProceed: boolean;
+  supersededIds: string[];
+  confidence: number;
+  reason: string;
+}> {
+  // Detect standard contradictions
+  const contradictionResult = await detectContradictions({
+    newContent: content,
+    newType: type,
+    projectId,
+  });
+  
+  // Also check temporal contradictions
+  const temporalSuperseded = await checkTemporalContradictions(content, projectId);
+  
+  // Combine results
+  const allSuperseded = [
+    ...new Set([
+      ...contradictionResult.supersededMemories,
+      ...temporalSuperseded,
+    ]),
+  ];
+  
+  const maxConfidence = Math.max(
+    contradictionResult.confidence,
+    temporalSuperseded.length > 0 ? 0.7 : 0
+  );
+  
+  return {
+    shouldProceed: true, // Always proceed, but track supersessions
+    supersededIds: allSuperseded,
+    confidence: maxConfidence,
+    reason: contradictionResult.reason || 
+            (temporalSuperseded.length > 0 ? 'temporal supersession' : ''),
+  };
+}

package/core/memory/edit-workflow.ts

@@ -0,0 +1,174 @@
+import { randomUUID } from 'crypto';
+import { eq, and, sql } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { MemoryRecord } from './memories.js';
+import { Conflict } from './conflict-detector.js';
+
+export interface EditProposal {
+  id: string;
+  memoryId: string;
+  currentContent: string;
+  proposedContent: string;
+  reason: string;
+  conflictWarnings: string[];
+  status: 'pending' | 'approved' | 'rejected' | 'expired';
+  version: number;
+  createdAt: Date;
+  reviewedAt?: Date;
+  reviewNotes?: string;
+}
+
+export async function createEditProposal(
+  memoryId: string,
+  currentContent: string,
+  proposedContent: string,
+  reason: string,
+  userId?: string
+): Promise<EditProposal> {
+  const db = createDatabaseClient(await getDb());
+  const schema = await getSchema();
+  const { memoryEditProposals } = schema;
+
+  const proposalId = randomUUID();
+  const now = new Date();
+
+  await db.insert(memoryEditProposals).values({
+    id: proposalId,
+    memoryId,
+    currentContent,
+    proposedContent,
+    reason,
+    conflictWarnings: [],
+    status: 'pending',
+    version: 1,
+    createdAt: now,
+    userId,
+  });
+
+  // Run conflict detection
+  const conflicts = await detectConflicts(memoryId, proposedContent);
+  await db.update(memoryEditProposals)
+    .set({ conflictWarnings: conflicts })
+    .where(eq(memoryEditProposals.id, proposalId));
+
+  return {
+    id: proposalId,
+    memoryId,
+    currentContent,
+    proposedContent,
+    reason,
+    conflictWarnings: conflicts,
+    status: 'pending',
+    version: 1,
+    createdAt: now,
+  };
+}
+
+export async function approveEditProposal(proposalId: string): Promise<boolean> {
+  const db = createDatabaseClient(await getDb());
+  const schema = await getSchema();
+  const { memoryEditProposals, memories } = schema;
+
+  // Get proposal
+  const proposal = await db.select()
+    .from(memoryEditProposals)
+    .where(eq(memoryEditProposals.id, proposalId))
+    .limit(1);
+
+  if (proposal.length === 0) return false;
+
+  // Update memory content
+  await db.update(memories)
+    .set({
+      content: proposal[0].proposedContent,
+      version: sql`${memories.version} + 1`,
+      updatedAt: new Date()
+    })
+    .where(eq(memories.id, proposal[0].memoryId));
+
+  // Mark proposal as approved
+  await db.update(memoryEditProposals)
+    .set({ status: 'approved', reviewedAt: new Date() })
+    .where(eq(memoryEditProposals.id, proposalId));
+
+  return true;
+}
+
+export async function rejectEditProposal(proposalId: string, reviewNotes: string): Promise<boolean> {
+  const db = createDatabaseClient(await getDb());
+  const schema = await getSchema();
+  const { memoryEditProposals } = schema;
+
+  await db.update(memoryEditProposals)
+    .set({ status: 'rejected', reviewNotes, reviewedAt: new Date() })
+    .where(eq(memoryEditProposals.id, proposalId));
+
+  return true;
+}
+
+export async function detectConflicts(memoryId: string, proposedContent: string): Promise<string[]> {
+  const db = createDatabaseClient(await getDb());
+  const schema = await getSchema();
+  const { memories } = schema;
+
+  // Get current memory
+  const currentMemory = await db.select()
+    .from(memories)
+    .where(eq(memories.id, memoryId))
+    .limit(1);
+
+  if (currentMemory.length === 0) return [];
+
+  const conflicts: string[] = [];
+
+  // Check for temporal contradictions
+  if (currentMemory[0].validFrom && currentMemory[0].validTo) {
+    const now = new Date();
+    if (now < new Date(currentMemory[0].validFrom) || now > new Date(currentMemory[0].validTo)) {
+      conflicts.push('Current time is outside validity period');
+    }
+  }
+
+  // Check for semantic contradictions with other memories
+  const similarMemories = await db.select()
+    .from(memories)
+    .where(
+      and(
+        eq(memories.projectId, currentMemory[0].projectId),
+        sql`memories.id != ${memoryId}`,
+        sql`memories.content ILIKE ${proposedContent}`
+      )
+    )
+    .limit(5);
+
+  for (const memory of similarMemories) {
+    if (memory.id !== memoryId) {
+      conflicts.push(`Potential contradiction with memory ${memory.id}`);
+    }
+  }
+
+  return conflicts;
+}
+
+export async function getEditProposals(
+  memoryId?: string,
+  status?: 'pending' | 'approved' | 'rejected'
+): Promise<EditProposal[]> {
+  const db = createDatabaseClient(await getDb());
+  const schema = await getSchema();
+  const { memoryEditProposals } = schema;
+
+  let query = db.select().from(memoryEditProposals);
+
+  if (memoryId) {
+    query = query.where(eq(memoryEditProposals.memoryId, memoryId));
+  }
+  if (status) {
+    query = query.where(eq(memoryEditProposals.status, status));
+  }
+
+  const proposals = await query;
+  return proposals as EditProposal[];
+}