squish-memory 1.1.5 → 1.2.1

package/dist/core/memory/temporal-parser.js

@@ -1,385 +0,0 @@
-/**
- * Temporal Parser
- * Parses temporal expressions and creates time-based relationships between memories
- * Handles absolute dates, relative times, durations, and frequencies
- */
-import { createAssociation } from '../../core/associations.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { eq } from 'drizzle-orm';
-import { logger } from '../../core/logger.js';
-// Regex patterns for temporal expression detection
-const PATTERNS = {
-    // ISO dates: 2024-01-05, 2024-01-05T10:30:00Z
-    isoDate: /\b(\d{4}-\d{2}-\d{2})(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z?)?\b/g,
-    // Natural dates: January 5, Jan 5, 1/5/2024, 01-05-2024
-    naturalDate: /\b(?:January|February|March|April|May|June|July|August|September|October|November|December|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}(?:,?\s+\d{4})?\b/gi,
-    // Relative times: yesterday, today, tomorrow, last week, next month
-    relativeTime: /\b(?:yesterday|today|tomorrow|last\s+(?:week|month|year|day|hour)|next\s+(?:week|month|year|day|hour))\b/gi,
-    // Time offsets: 3 days ago, in 2 weeks, 5 minutes ago
-    timeOffset: /\b(\d+)\s+(?:days?|weeks?|months?|years?|hours?|minutes?|seconds?)\s+(?:ago|from now|in the past|in the future)\b/gi,
-    // Durations: for 2 hours, over 3 weeks, during 5 days
-    duration: /\b(?:for|during|over)\s+(\d+)\s+(?:days?|weeks?|months?|years?|hours?|minutes?|seconds?)\b/gi,
-    // Frequencies: daily, weekly, monthly, every week, once a month
-    frequency: /\b(?:daily|weekly|monthly|yearly|hourly|every\s+(?:day|week|month|year)|once\s+a\s+(?:day|week|month|year))\b/gi,
-};
-/**
- * Parse temporal expressions from content
- */
-export async function parseTemporalFacts(content, referenceDate = new Date()) {
-    const facts = [];
-    // Parse absolute dates (ISO and natural format)
-    const isoDates = Array.from(content.matchAll(PATTERNS.isoDate));
-    for (const match of isoDates) {
-        try {
-            const date = new Date(match[0]);
-            if (!isNaN(date.getTime())) {
-                facts.push({
-                    type: 'absolute',
-                    value: match[0],
-                    parsed: { start: date, end: date },
-                    confidence: 0.95,
-                    context: extractContext(content, match.index || 0),
-                });
-            }
-        }
-        catch {
-            // Invalid date format
-        }
-    }
-    const naturalDates = Array.from(content.matchAll(PATTERNS.naturalDate));
-    for (const match of naturalDates) {
-        try {
-            const date = parseNaturalDate(match[0], referenceDate);
-            if (date) {
-                facts.push({
-                    type: 'absolute',
-                    value: match[0],
-                    parsed: { start: date, end: date },
-                    confidence: 0.85,
-                    context: extractContext(content, match.index || 0),
-                });
-            }
-        }
-        catch {
-            // Invalid date format
-        }
-    }
-    // Parse relative times
-    const relativeTimes = Array.from(content.matchAll(PATTERNS.relativeTime));
-    for (const match of relativeTimes) {
-        const date = parseRelativeTime(match[0], referenceDate);
-        if (date) {
-            facts.push({
-                type: 'relative',
-                value: match[0],
-                parsed: { start: date, end: date },
-                confidence: 0.9,
-                context: extractContext(content, match.index || 0),
-            });
-        }
-    }
-    // Parse time offsets (3 days ago, in 2 weeks, etc.)
-    const timeOffsets = Array.from(content.matchAll(PATTERNS.timeOffset));
-    for (const match of timeOffsets) {
-        const amount = parseInt(match[1]);
-        const unit = match[0].split(/\s+/)[1].toLowerCase();
-        const date = calculateDateOffset(referenceDate, amount, unit, match[0]);
-        if (date) {
-            facts.push({
-                type: 'relative',
-                value: match[0],
-                parsed: { start: date, end: date },
-                confidence: 0.85,
-                context: extractContext(content, match.index || 0),
-            });
-        }
-    }
-    // Parse durations
-    const durations = Array.from(content.matchAll(PATTERNS.duration));
-    for (const match of durations) {
-        const amount = parseInt(match[1]);
-        const unit = match[0].split(/\s+/)[2].toLowerCase();
-        const durationMs = calculateDurationMs(amount, unit);
-        if (durationMs > 0) {
-            facts.push({
-                type: 'duration',
-                value: match[0],
-                parsed: { duration: durationMs },
-                confidence: 0.8,
-                context: extractContext(content, match.index || 0),
-            });
-        }
-    }
-    // Parse frequencies
-    const frequencies = Array.from(content.matchAll(PATTERNS.frequency));
-    for (const match of frequencies) {
-        facts.push({
-            type: 'frequency',
-            value: match[0],
-            parsed: { frequency: match[0].toLowerCase() },
-            confidence: 0.85,
-            context: extractContext(content, match.index || 0),
-        });
-    }
-    return facts;
-}
-/**
- * Link temporal relations between memories
- */
-export async function linkTemporalRelations(memoryId, facts) {
-    const relations = [];
-    if (facts.length === 0)
-        return relations;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get the target memory
-        const targetMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (targetMemories.length === 0)
-            return relations;
-        const targetMemory = targetMemories[0];
-        // Find related memories with temporal overlaps
-        const allMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, targetMemory.projectId));
-        for (const fact of facts) {
-            if (!fact.parsed.start)
-                continue;
-            for (const otherMemory of allMemories) {
-                if (otherMemory.id === memoryId)
-                    continue;
-                const relation = analyzeTemporalRelation(fact, targetMemory, otherMemory);
-                if (relation) {
-                    relations.push(relation);
-                    // Create association for temporal relationships
-                    if (relation.type === 'supersedes') {
-                        await createAssociation(memoryId, otherMemory.id, 'supersedes', relation.confidence);
-                    }
-                    else if (relation.type === 'contradicts') {
-                        await createAssociation(memoryId, otherMemory.id, 'contradicts', relation.confidence);
-                    }
-                }
-            }
-        }
-        // Update memory validity dates if we have absolute dates
-        const absoluteFacts = facts.filter((f) => f.type === 'absolute');
-        if (absoluteFacts.length > 0) {
-            const dates = absoluteFacts
-                .map((f) => f.parsed.start)
-                .filter((d) => d);
-            if (dates.length > 0) {
-                const minDate = new Date(Math.min(...dates.map((d) => d.getTime())));
-                const maxDate = new Date(Math.max(...dates.map((d) => d.getTime())));
-                await db
-                    .update(schema.memories)
-                    .set({
-                    validFrom: minDate,
-                    validTo: maxDate,
-                    updatedAt: new Date(),
-                })
-                    .where(eq(schema.memories.id, memoryId));
-            }
-        }
-        logger.debug('Temporal relations linked', {
-            memoryId,
-            factCount: facts.length,
-            relationCount: relations.length,
-        });
-    }
-    catch (error) {
-        logger.error('Error linking temporal relations', error);
-    }
-    return relations;
-}
-/**
- * Analyze temporal relationship between two memories
- */
-function analyzeTemporalRelation(fact, targetMemory, otherMemory) {
-    if (!fact.parsed.start || !otherMemory.validFrom)
-        return null;
-    const factDate = fact.parsed.start;
-    const otherStart = new Date(otherMemory.validFrom);
-    const otherEnd = otherMemory.validTo ? new Date(otherMemory.validTo) : otherStart;
-    // Determine temporal relationship
-    if (factDate < otherStart) {
-        return {
-            type: 'before',
-            targetMemoryId: otherMemory.id,
-            confidence: 0.9,
-        };
-    }
-    if (factDate > otherEnd) {
-        return {
-            type: 'after',
-            targetMemoryId: otherMemory.id,
-            confidence: 0.9,
-        };
-    }
-    // Check for overlaps or containment
-    if (factDate >= otherStart && factDate <= otherEnd) {
-        // Check if this memory supersedes or contradicts
-        const contentSimilarity = calculateContentSimilarity(targetMemory.content, otherMemory.content);
-        if (contentSimilarity > 0.7) {
-            // High similarity with different dates suggests supersession or contradiction
-            return {
-                type: targetMemory.createdAt > otherMemory.createdAt ? 'supersedes' : 'contradicts',
-                targetMemoryId: otherMemory.id,
-                confidence: contentSimilarity * 0.9,
-            };
-        }
-        return {
-            type: 'overlaps',
-            targetMemoryId: otherMemory.id,
-            confidence: 0.7,
-        };
-    }
-    return null;
-}
-/**
- * Parse natural date formats (e.g., "January 5", "Jan 5, 2024")
- */
-function parseNaturalDate(dateStr, referenceDate) {
-    try {
-        // Handle "Month Day, Year" or "Month Day"
-        const date = new Date(dateStr);
-        if (!isNaN(date.getTime())) {
-            // If year is missing, use reference year
-            if (!dateStr.includes(date.getFullYear().toString())) {
-                date.setFullYear(referenceDate.getFullYear());
-            }
-            return date;
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-/**
- * Parse relative time expressions
- */
-function parseRelativeTime(timeStr, referenceDate) {
-    const str = timeStr.toLowerCase();
-    const date = new Date(referenceDate);
-    if (str === 'yesterday') {
-        date.setDate(date.getDate() - 1);
-        return date;
-    }
-    if (str === 'today') {
-        return date;
-    }
-    if (str === 'tomorrow') {
-        date.setDate(date.getDate() + 1);
-        return date;
-    }
-    if (str.includes('last week')) {
-        date.setDate(date.getDate() - 7);
-        return date;
-    }
-    if (str.includes('next week')) {
-        date.setDate(date.getDate() + 7);
-        return date;
-    }
-    if (str.includes('last month')) {
-        date.setMonth(date.getMonth() - 1);
-        return date;
-    }
-    if (str.includes('next month')) {
-        date.setMonth(date.getMonth() + 1);
-        return date;
-    }
-    if (str.includes('last year')) {
-        date.setFullYear(date.getFullYear() - 1);
-        return date;
-    }
-    if (str.includes('next year')) {
-        date.setFullYear(date.getFullYear() + 1);
-        return date;
-    }
-    return null;
-}
-/**
- * Calculate date offset (e.g., "3 days ago")
- */
-function calculateDateOffset(referenceDate, amount, unit, fullText) {
-    const date = new Date(referenceDate);
-    const isNegative = fullText.includes('ago') || fullText.includes('past');
-    const multiplier = isNegative ? -1 : 1;
-    const unitLower = unit.replace(/s$/, '').toLowerCase();
-    switch (unitLower) {
-        case 'day':
-            date.setDate(date.getDate() + multiplier * amount);
-            break;
-        case 'week':
-            date.setDate(date.getDate() + multiplier * amount * 7);
-            break;
-        case 'month':
-            date.setMonth(date.getMonth() + multiplier * amount);
-            break;
-        case 'year':
-            date.setFullYear(date.getFullYear() + multiplier * amount);
-            break;
-        case 'hour':
-            date.setHours(date.getHours() + multiplier * amount);
-            break;
-        case 'minute':
-            date.setMinutes(date.getMinutes() + multiplier * amount);
-            break;
-        default:
-            return null;
-    }
-    return date;
-}
-/**
- * Calculate duration in milliseconds
- */
-function calculateDurationMs(amount, unit) {
-    const unitLower = unit.replace(/s$/, '').toLowerCase();
-    switch (unitLower) {
-        case 'day':
-            return amount * 24 * 60 * 60 * 1000;
-        case 'week':
-            return amount * 7 * 24 * 60 * 60 * 1000;
-        case 'month':
-            return amount * 30 * 24 * 60 * 60 * 1000;
-        case 'year':
-            return amount * 365 * 24 * 60 * 60 * 1000;
-        case 'hour':
-            return amount * 60 * 60 * 1000;
-        case 'minute':
-            return amount * 60 * 1000;
-        case 'second':
-            return amount * 1000;
-        default:
-            return 0;
-    }
-}
-/**
- * Extract surrounding context for temporal expression
- */
-function extractContext(content, index, contextLength = 50) {
-    const start = Math.max(0, index - contextLength);
-    const end = Math.min(content.length, index + contextLength);
-    return content.substring(start, end).trim();
-}
-/**
- * Simple content similarity calculation (token overlap)
- */
-function calculateContentSimilarity(content1, content2) {
-    const tokens1 = new Set(content1.toLowerCase().split(/\s+/));
-    const tokens2 = new Set(content2.toLowerCase().split(/\s+/));
-    let overlap = 0;
-    for (const token of tokens1) {
-        if (tokens2.has(token))
-            overlap++;
-    }
-    const totalUnique = tokens1.size + tokens2.size - overlap;
-    return totalUnique > 0 ? overlap / totalUnique : 0;
-}
-//# sourceMappingURL=temporal-parser.js.map

package/dist/core/memory/trigger-detector.d.ts

@@ -1,14 +0,0 @@
-export interface MemorySignals {
-    explicitTriggers: string[];
-    implicit: {
-        decision: boolean;
-        correction: boolean;
-        preference: boolean;
-        workflowRule: boolean;
-        lesson: boolean;
-    };
-    suggestedType: 'observation' | 'fact' | 'decision' | 'context' | 'preference';
-    priority: 'normal' | 'high';
-}
-export declare function detectMemorySignals(content: string): MemorySignals;
-//# sourceMappingURL=trigger-detector.d.ts.map

package/dist/core/memory/trigger-detector.js

@@ -1,42 +0,0 @@
-const EXPLICIT_TRIGGER_PATTERNS = [
-    { label: 'remember', regex: /\bremember\b/i },
-    { label: 'dont-forget', regex: /\b(?:don'?t\s+forget|do\s+not\s+forget)\b/i },
-    { label: 'keep-in-mind', regex: /\bkeep\s+in\s+mind\b/i },
-    { label: 'note-that', regex: /\bnote\s+that\b/i },
-    { label: 'from-now-on', regex: /\bfrom\s+now\s+on\b/i },
-    { label: 'going-forward', regex: /\bgoing\s+forward\b/i },
-    { label: 'save-this', regex: /\bsave\s+this\b/i },
-    { label: 'log-this', regex: /\blog\s+this\b/i },
-    { label: 'important', regex: /\bimportant\s*:/i },
-];
-export function detectMemorySignals(content) {
-    const text = content.trim();
-    const explicitTriggers = EXPLICIT_TRIGGER_PATTERNS.filter((p) => p.regex.test(text)).map((p) => p.label);
-    const implicit = {
-        decision: /\b(?:decided|choose|chose|going with|picked|selected|final decision)\b/i.test(text) ||
-            /\b(?:x over y|option\s+[a-z0-9]+\s+over)\b/i.test(text),
-        correction: /\b(?:no,?\s+i\s+meant|actually,?\s+that'?s\s+not|correction:|i\s+meant)\b/i.test(text),
-        preference: /\b(?:i\s+like|i\s+don'?t\s+like|i\s+hate|my\s+preference\s+is|prefer)\b/i.test(text) ||
-            /\b(?:always|never)\b/i.test(text),
-        workflowRule: /\b(?:let'?s\s+always\s+do\s+it\s+this\s+way|standard\s+workflow|runbook)\b/i.test(text),
-        lesson: /\b(?:failed\s+because|lesson\s+learned|next\s+time|do\s+not\s+repeat|root\s+cause)\b/i.test(text),
-    };
-    let suggestedType = 'observation';
-    if (implicit.preference)
-        suggestedType = 'preference';
-    if (implicit.decision)
-        suggestedType = 'decision';
-    if (implicit.workflowRule || implicit.lesson)
-        suggestedType = 'context';
-    if (!implicit.decision && !implicit.preference && /\b(?:is|are|was|were|uses|has|have)\b/i.test(text)) {
-        suggestedType = 'fact';
-    }
-    const priority = explicitTriggers.length > 0 || implicit.correction ? 'high' : 'normal';
-    return {
-        explicitTriggers,
-        implicit,
-        suggestedType,
-        priority,
-    };
-}
-//# sourceMappingURL=trigger-detector.js.map

package/dist/core/memory/write-gate.d.ts

@@ -1,54 +0,0 @@
-/**
- * Write Gate Enforcement
- * Validates memories before writing to ensure quality, security, and consistency
- * Integrates secret detection, trigger detection, and content validation
- */
-import { MemorySignals } from './trigger-detector.js';
-export interface WriteGateResult {
-    allowed: boolean;
-    sanitized: boolean;
-    warnings: string[];
-    errors: string[];
-    metadata: {
-        secretsDetected: number;
-        signals: MemorySignals | null;
-        contradictions: {
-            found: boolean;
-            count: number;
-        };
-        temporalSupersession: {
-            count: number;
-        };
-    };
-    sanitizedContent?: string;
-}
-export interface WriteGateOptions {
-    allowSecrets?: boolean;
-    minContentLength?: number;
-    maxContentLength?: number;
-    projectId?: string;
-    skipContradictionCheck?: boolean;
-    skipTemporalSupersession?: boolean;
-}
-/**
- * Main write gate function - validates and sanitizes content before write
- */
-export declare function enforceWriteGate(content: string, type: string, options?: WriteGateOptions): Promise<WriteGateResult>;
-/**
- * Quick validation without async operations
- * Use for fast pre-check before full validation
- */
-export declare function quickValidate(content: string): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Sanitize content for storage
- * Redacts secrets and normalizes whitespace
- */
-export declare function sanitizeForStorage(content: string): string;
-/**
- * Calculate a quality score for content (0-100)
- */
-export declare function calculateContentQualityScore(content: string): number;
-//# sourceMappingURL=write-gate.d.ts.map