squish-memory 1.1.5 → 1.2.1

package/dist/core/algorithms/strategies/merge-strategies.js

@@ -1,288 +0,0 @@
-/**
- * Type-specific merge strategies for different memory types.
- * Each type has different merge semantics to preserve meaning and prevent data loss.
- */
-/**
- * Base implementation of MergeStrategy with common functionality.
- * Reduces code duplication across specific merge strategies.
- */
-export class BaseMergeStrategy {
-    canMerge(sources) {
-        if (sources.length < 2) {
-            return { ok: false, reason: 'Need at least 2 memories to merge' };
-        }
-        return { ok: true };
-    }
-    validateSources(sources) {
-        return sources.length >= 2;
-    }
-    handleEmptySources() {
-        return {
-            content: '',
-            summary: null,
-            tags: [],
-            metadata: {},
-            mergeReason: 'Empty source set',
-            conflictWarnings: [],
-        };
-    }
-    mergeTags(sources) {
-        const tagSet = new Set();
-        for (const source of sources) {
-            for (const tag of source.tags || []) {
-                tagSet.add(tag);
-            }
-        }
-        return Array.from(tagSet);
-    }
-    buildBaseMetadata(sources, extra) {
-        return {
-            mergedFrom: sources.map((m) => m.id),
-            mergeCount: sources.length,
-            ...extra,
-        };
-    }
-    sortByDate(sources, order = 'desc') {
-        const sorted = [...sources].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-        return order === 'asc' ? [...sorted].reverse() : sorted;
-    }
-    sortChronologically(sources) {
-        return [...sources].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-    }
-}
-/**
- * FACT strategy: Union of information, remove exact duplicates.
- * Combines all unique facts into a unified statement with provenance tracking.
- */
-class FactMergeStrategy extends BaseMergeStrategy {
-    type = 'fact';
-    merge(sources) {
-        if (sources.length === 0) {
-            return this.handleEmptySources();
-        }
-        // Split content into sentences and deduplicate
-        const sentenceSet = new Set();
-        const timestamps = [];
-        for (const source of sources) {
-            // Extract sentences (split by period, exclamation, question)
-            const sentences = source.content
-                .split(/[.!?]\s+/)
-                .map((s) => s.trim())
-                .filter((s) => s.length > 0);
-            for (const sentence of sentences) {
-                sentenceSet.add(sentence);
-            }
-            if (source.createdAt) {
-                timestamps.push(source.createdAt);
-            }
-        }
-        // Sort sentences for consistency
-        const mergedSentences = Array.from(sentenceSet).sort();
-        const content = mergedSentences.join('. ') + (mergedSentences.length > 0 ? '.' : '');
-        // Build merged metadata with provenance
-        const metadata = this.buildBaseMetadata(sources, {
-            timestamps: timestamps.sort(),
-        });
-        return {
-            content,
-            summary: null,
-            tags: this.mergeTags(sources),
-            metadata,
-            mergeReason: `Merged ${sources.length} facts by combining all unique statements`,
-            conflictWarnings: [],
-        };
-    }
-}
-/**
- * PREFERENCE strategy: Keep latest by timestamp, track evolution history.
- * Warns if preferences conflict, indicating user changed their mind.
- */
-class PreferenceMergeStrategy extends BaseMergeStrategy {
-    type = 'preference';
-    merge(sources) {
-        if (sources.length === 0) {
-            return this.handleEmptySources();
-        }
-        // Sort by creation date (newest first)
-        const sorted = this.sortByDate(sources);
-        const latest = sorted[0];
-        const warnings = [];
-        // Check for conflicting preferences
-        const uniqueContents = new Set(sources.map((m) => m.content));
-        if (uniqueContents.size > 1) {
-            warnings.push(`Multiple preferences detected: ${Array.from(uniqueContents).join(', ')}`);
-            warnings.push(`Using latest preference from ${latest.createdAt || 'unknown date'}`);
-        }
-        // Build history timeline
-        const history = sorted.map((m) => ({
-            preference: m.content,
-            createdAt: m.createdAt,
-            confidence: m.confidence || 100,
-            source: m.source,
-        }));
-        const metadata = this.buildBaseMetadata(sources, {
-            preferenceHistory: history,
-            latestAt: latest.createdAt,
-        });
-        const summary = sources.length > 1
-            ? `Prefers: ${latest.content} (evolved from ${sources.length} preferences)`
-            : null;
-        return {
-            content: latest.content,
-            summary,
-            tags: latest.tags || [],
-            metadata,
-            mergeReason: `Merged ${sources.length} preference records, keeping latest from ${latest.createdAt}`,
-            conflictWarnings: warnings,
-        };
-    }
-}
-/**
- * DECISION strategy: Keep latest decision, link to previous ones in timeline.
- * Warns if decisions contradict, preserving rationale history.
- */
-class DecisionMergeStrategy extends BaseMergeStrategy {
-    type = 'decision';
-    merge(sources) {
-        if (sources.length === 0) {
-            return this.handleEmptySources();
-        }
-        // Sort by creation date (newest first)
-        const sorted = this.sortByDate(sources);
-        const latest = sorted[0];
-        const warnings = [];
-        // Check for conflicting decisions
-        const uniqueDecisions = new Set(sources.map((m) => m.content));
-        if (uniqueDecisions.size > 1) {
-            warnings.push(`Decision changed: was ${sorted[sorted.length - 1].content}, now ${latest.content}`);
-        }
-        // Build decision timeline
-        const timeline = sorted.map((m) => ({
-            decision: m.content,
-            createdAt: m.createdAt,
-            confidence: m.confidence || 100,
-            rationale: m.summary || 'No rationale recorded',
-        }));
-        const metadata = this.buildBaseMetadata(sources, {
-            decisionTimeline: timeline,
-            currentDecisionAt: latest.createdAt,
-            supersedes: sorted.slice(1).map((m) => m.id),
-        });
-        const summary = sources.length > 1 ? `Decided: ${latest.content} (${sources.length} decisions)` : null;
-        return {
-            content: latest.content,
-            summary,
-            tags: latest.tags || [],
-            metadata,
-            mergeReason: `Merged ${sources.length} decision records, keeping latest from ${latest.createdAt}`,
-            conflictWarnings: warnings,
-        };
-    }
-}
-/**
- * OBSERVATION strategy: Aggregate observations in chronological order.
- * Preserves temporal patterns and frequency information.
- */
-class ObservationMergeStrategy extends BaseMergeStrategy {
-    type = 'observation';
-    merge(sources) {
-        if (sources.length === 0) {
-            return this.handleEmptySources();
-        }
-        // Sort chronologically
-        const sorted = this.sortChronologically(sources);
-        // Create observation summary
-        const observations = sorted.map((m) => `• ${m.content}`).join('\n');
-        const metadata = this.buildBaseMetadata(sources, {
-            observationCount: sources.length,
-            timeSpan: {
-                start: sorted[0].createdAt,
-                end: sorted[sorted.length - 1].createdAt,
-            },
-            chronologicalOrder: sorted.map((m) => ({
-                id: m.id,
-                content: m.content,
-                createdAt: m.createdAt,
-            })),
-        });
-        return {
-            content: `Observations (${sources.length} total):\n${observations}`,
-            summary: `${sources.length} observations over time period`,
-            tags: this.mergeTags(sources),
-            metadata,
-            mergeReason: `Merged ${sources.length} observations chronologically`,
-            conflictWarnings: [],
-        };
-    }
-}
-/**
- * CONTEXT strategy: Union of unique context, remove exact duplicates.
- * Preserves all distinct context items.
- */
-class ContextMergeStrategy extends BaseMergeStrategy {
-    type = 'context';
-    merge(sources) {
-        if (sources.length === 0) {
-            return this.handleEmptySources();
-        }
-        // Deduplicate by content (exact matches)
-        const uniqueContexts = new Map();
-        for (const source of sources) {
-            if (!uniqueContexts.has(source.content)) {
-                uniqueContexts.set(source.content, source);
-            }
-        }
-        // Format as list
-        const contextList = Array.from(uniqueContexts.keys())
-            .sort()
-            .map((content) => `• ${content}`)
-            .join('\n');
-        const metadata = this.buildBaseMetadata(sources, {
-            uniqueContextCount: uniqueContexts.size,
-            totalContextCount: sources.length,
-            deduplicatedEntries: sources.length - uniqueContexts.size,
-        });
-        return {
-            content: contextList,
-            summary: `${uniqueContexts.size} context items (${sources.length} total)`,
-            tags: this.mergeTags(sources),
-            metadata,
-            mergeReason: `Merged ${sources.length} context records into ${uniqueContexts.size} unique items`,
-            conflictWarnings: [],
-        };
-    }
-}
-export const MERGE_STRATEGIES = {
-    fact: new FactMergeStrategy(),
-    preference: new PreferenceMergeStrategy(),
-    decision: new DecisionMergeStrategy(),
-    observation: new ObservationMergeStrategy(),
-    context: new ContextMergeStrategy(),
-    reflection: new ObservationMergeStrategy(),
-    note: new ObservationMergeStrategy(), // jot uses observation strategy
-};
-export function getMergeStrategy(type) {
-    const strategy = MERGE_STRATEGIES[type];
-    if (!strategy) {
-        throw new Error(`No merge strategy defined for type: ${type}`);
-    }
-    return strategy;
-}
-export function mergeMemories(sources) {
-    if (sources.length === 0) {
-        throw new Error('Cannot merge: no source memories');
-    }
-    // All sources must be same type
-    const type = sources[0].type;
-    const allSameType = sources.every((m) => m.type === type);
-    if (!allSameType) {
-        throw new Error('Cannot merge: memories must be same type');
-    }
-    const strategy = getMergeStrategy(type);
-    const canMerge = strategy.canMerge(sources);
-    if (!canMerge.ok) {
-        throw new Error(`Cannot merge: ${canMerge.reason}`);
-    }
-    return strategy.merge(sources);
-}
-//# sourceMappingURL=merge-strategies.js.map

package/dist/core/algorithms/types.d.ts

@@ -1,133 +0,0 @@
-/**
- * TypeScript types and interfaces for memory merging
- */
-import type { Memory, MemoryMergeProposal } from '../../db/drizzle/schema.js';
-/**
- * Merge proposal status
- */
-export type MergeProposalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
-/**
- * Confidence level for merge suggestions
- */
-export type ConfidenceLevel = 'high' | 'medium' | 'low';
-/**
- * Detection method used to find duplicates
- */
-export type DetectionMethod = 'simhash' | 'minhash' | 'embedding';
-/**
- * Merge strategy type per memory type
- */
-export type MergeStrategyType = 'union' | 'latest' | 'voting' | 'custom';
-/**
- * Memory pair candidate for merging
- */
-export interface MemoryMergePair {
-    memory1: Memory;
-    memory2: Memory;
-    similarityScore: number;
-    detectionMethod: DetectionMethod;
-    confidenceLevel: ConfidenceLevel;
-    mergeReason: string;
-}
-/**
- * Merge proposal with all details
- */
-export interface MergeProposalDetails {
-    proposal: MemoryMergeProposal;
-    sourceMemories: Memory[];
-    previewMerged: {
-        content: string;
-        summary: string | null;
-        tags: string[];
-        metadata: Record<string, unknown>;
-    };
-    analysis: {
-        savedTokens: number;
-        savedPercentage: number;
-        conflictWarnings: string[];
-    };
-}
-/**
- * Merge result after approval
- */
-export interface MergeResult {
-    proposalId: string;
-    canonicalMemoryId: string;
-    mergedMemoryIds: string[];
-    tokensSaved: number;
-    mergedAt: Date;
-    mergeHistoryId?: string;
-}
-/**
- * Merge reversal result
- */
-export interface MergeReversal {
-    mergeHistoryId: string;
-    canonicalMemoryId: string;
-    restoredMemoryIds: string[];
-    reversedAt: Date;
-}
-/**
- * Detection statistics
- */
-export interface DetectionStatistics {
-    totalMemories: number;
-    scannedMemories: number;
-    candidatesFound: number;
-    candidatesRanked: number;
-    estimatedTokensSaved: number;
-    timeMs: {
-        stage1: number;
-        stage2: number;
-        total: number;
-    };
-}
-/**
- * Project merge statistics
- */
-export interface ProjectMergeStatistics {
-    projectId: string;
-    totalMemories: number;
-    mergeableMemories: number;
-    mergedMemories: number;
-    canonicalMemories: number;
-    pendingProposals: number;
-    approvedMerges: number;
-    rejectedProposals: number;
-    reversedMerges: number;
-    tokensSaved: {
-        total: number;
-        formatted: string;
-        percentage: number;
-    };
-    averageMergeSize: number;
-}
-/**
- * Merge safety check result
- */
-export interface SafetyCheckResult {
-    passed: boolean;
-    warnings: string[];
-    blockers: string[];
-}
-/**
- * Hash cache entry for fast duplicate detection
- */
-export interface HashCacheEntry {
-    memoryId: string;
-    simhash: string;
-    minhash: number[];
-    contentHash: string;
-    lastUpdated: Date;
-}
-/**
- * Stage 1 candidate pair with hash distances
- */
-export interface Stage1CandidatePair {
-    memoryId1: string;
-    memoryId2: string;
-    simhashDistance: number;
-    minhashSimilarity: number;
-    matched: 'simhash' | 'minhash' | 'both';
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/core/algorithms/types.js

@@ -1,5 +0,0 @@
-/**
- * TypeScript types and interfaces for memory merging
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/core/algorithms/utils/response-builder.d.ts

@@ -1,28 +0,0 @@
-/**
- * Unified response builder for algorithm handlers
- * Provides consistent response formatting across all algorithm handlers
- */
-export interface ErrorResponse {
-    ok: false;
-    message: string;
-    error: string;
-}
-export interface SuccessResponse<T = unknown> {
-    ok: true;
-    message: string;
-    data?: T;
-}
-export type ApiResponse<T = unknown> = ErrorResponse | SuccessResponse<T>;
-/**
- * Build a success response with optional data
- */
-export declare function buildSuccessResponse<T = unknown>(message: string, data?: T): SuccessResponse<T>;
-/**
- * Build an error response
- */
-export declare function buildErrorResponse(message: string, error?: unknown): ErrorResponse;
-/**
- * Wrap async handlers with consistent error handling
- */
-export declare function withErrorHandler<T>(handler: () => Promise<T>, errorMessage: string): Promise<ApiResponse<T>>;
-//# sourceMappingURL=response-builder.d.ts.map

package/dist/core/algorithms/utils/response-builder.js

@@ -1,37 +0,0 @@
-/**
- * Unified response builder for algorithm handlers
- * Provides consistent response formatting across all algorithm handlers
- */
-/**
- * Build a success response with optional data
- */
-export function buildSuccessResponse(message, data) {
-    const response = { ok: true, message };
-    if (data !== undefined) {
-        response.data = data;
-    }
-    return response;
-}
-/**
- * Build an error response
- */
-export function buildErrorResponse(message, error) {
-    return {
-        ok: false,
-        message,
-        error: error instanceof Error ? error.message : String(error || 'Unknown error'),
-    };
-}
-/**
- * Wrap async handlers with consistent error handling
- */
-export async function withErrorHandler(handler, errorMessage) {
-    try {
-        const result = await handler();
-        return buildSuccessResponse(errorMessage, result);
-    }
-    catch (error) {
-        return buildErrorResponse(errorMessage, error);
-    }
-}
-//# sourceMappingURL=response-builder.js.map

package/dist/core/associations.d.ts

@@ -1,31 +0,0 @@
-/**
- * Memory Association Graph (Waypoint Graph)
- * Tracks co-occurrence and relationships between memories
- */
-export type AssociationType = 'co_occurred' | 'supersedes' | 'contradicts' | 'supports' | 'relates_to' | 'duplicate' | 'merged';
-/**
- * Create or update an association between two memories
- */
-export declare function createAssociation(fromMemoryId: string, toMemoryId: string, type: AssociationType, weight?: number): Promise<void>;
-/**
- * Track co-activation of multiple memories (used together)
- */
-export declare function trackCoactivation(memoryIds: string[]): Promise<void>;
-/**
- * Get related memories via the association graph
- */
-export declare function getRelatedMemories(memoryId: string, limit?: number): Promise<any[]>;
-/**
- * Prune weak associations (weight < threshold)
- */
-export declare function pruneWeakAssociations(weightThreshold?: number): Promise<number>;
-/**
- * Get association statistics
- */
-export declare function getAssociationStats(): Promise<{
-    totalAssociations: number;
-    byType: Record<string, number>;
-    avgWeight: number;
-    maxWeight: number;
-}>;
-//# sourceMappingURL=associations.d.ts.map