squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/contradiction-resolver.js

@@ -1,368 +0,0 @@
-/**
- * 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';
-/**
- * Calculate temporal relationship between two time periods
- * Returns: 'existing_is_newer', 'existing_is_older', 'overlapping', or 'unknown'
- */
-function calculateTemporalRelationship(existingValidFrom, existingValidTo, newTime) {
-    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, existingEnd, newStart, newEnd) {
-    // 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) {
-    // Simple extraction of capitalized phrases and key terms
-    const entities = [];
-    // 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, b) {
-    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) {
-    return NEGATION_PATTERNS.some(pattern => pattern.test(content));
-}
-// Check if content indicates an update
-function hasUpdateIndicator(content) {
-    return UPDATE_PATTERNS.some(pattern => pattern.test(content));
-}
-// Extract the "subject" of a memory (what it's about)
-function extractSubject(content) {
-    // 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) {
-    const result = {
-        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
-            .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 = [];
-        let maxConfidence = 0;
-        let reasons = [];
-        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, supersededIds, confidence) {
-    if (supersededIds.length === 0)
-        return;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Update superseded memories
-        await db
-            .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, projectId) {
-    const supersededIds = [];
-    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
-            .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, type, projectId) {
-    // 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' : ''),
-    };
-}
-//# sourceMappingURL=contradiction-resolver.js.map

package/dist/core/memory/edit-workflow.d.ts

@@ -1,19 +0,0 @@
-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 declare function createEditProposal(memoryId: string, currentContent: string, proposedContent: string, reason: string, userId?: string): Promise<EditProposal>;
-export declare function approveEditProposal(proposalId: string): Promise<boolean>;
-export declare function rejectEditProposal(proposalId: string, reviewNotes: string): Promise<boolean>;
-export declare function detectConflicts(memoryId: string, proposedContent: string): Promise<string[]>;
-export declare function getEditProposals(memoryId?: string, status?: 'pending' | 'approved' | 'rejected'): Promise<EditProposal[]>;
-//# sourceMappingURL=edit-workflow.d.ts.map

package/dist/core/memory/edit-workflow.js

@@ -1,120 +0,0 @@
-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';
-export async function createEditProposal(memoryId, currentContent, proposedContent, reason, userId) {
-    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) {
-    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, reviewNotes) {
-    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, proposedContent) {
-    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 = [];
-    // 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, status) {
-    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;
-}
-//# sourceMappingURL=edit-workflow.js.map

package/dist/core/memory/entity-extractor.d.ts

@@ -1,37 +0,0 @@
-/**
- * Entity Extractor
- * Extracts named entities from memory content
- * Supports people, files, functions, dates, locations, concepts, tools, and patterns
- */
-export type EntityType = 'person' | 'file' | 'function' | 'class' | 'concept' | 'tool' | 'date' | 'location' | 'pattern' | 'technique' | 'other';
-export interface ExtractedEntity {
-    name: string;
-    type: EntityType;
-    confidence: number;
-    startIndex: number;
-    endIndex: number;
-    context: string;
-    normalized?: string;
-}
-/**
- * Extract unique entity names for auto-linking
- */
-export declare function extractEntityNames(content: string): string[];
-/**
- * Extract entities from content
- */
-export declare function extractEntities(content: string): Promise<ExtractedEntity[]>;
-/**
- * Link extracted entities to memory records
- * Creates entity records in the knowledge graph
- */
-export declare function linkEntitiesToMemories(memoryId: string, entities: ExtractedEntity[]): Promise<void>;
-/**
- * Get entities extracted from a memory based on properties
- */
-export declare function getMemoryEntities(memoryId: string): Promise<ExtractedEntity[]>;
-/**
- * Get all entities for a project
- */
-export declare function getProjectEntities(projectId: string, type?: EntityType): Promise<any[]>;
-//# sourceMappingURL=entity-extractor.d.ts.map