squish-memory 1.0.2 → 1.1.5

package/dist/{algorithms → core/algorithms}/strategies/merge-strategies.js

@@ -3,28 +3,62 @@
  * Each type has different merge semantics to preserve meaning and prevent data loss.
  */
 /**
- * FACT strategy: Union of information, remove exact duplicates.
- * Combines all unique facts into a unified statement with provenance tracking.
+ * Base implementation of MergeStrategy with common functionality.
+ * Reduces code duplication across specific merge strategies.
  */
-class FactMergeStrategy {
-    type = 'fact';
+export class BaseMergeStrategy {
     canMerge(sources) {
-        // Facts can almost always be merged
         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 {
-                content: '',
-                summary: null,
-                tags: [],
-                metadata: {},
-                mergeReason: 'Empty source set',
-                conflictWarnings: [],
-            };
+            return this.handleEmptySources();
         }
         // Split content into sentences and deduplicate
         const sentenceSet = new Set();
@@ -45,27 +79,14 @@ class FactMergeStrategy {
         // Sort sentences for consistency
         const mergedSentences = Array.from(sentenceSet).sort();
         const content = mergedSentences.join('. ') + (mergedSentences.length > 0 ? '.' : '');
-        // Merge tags (union)
-        const tagSet = new Set();
-        for (const source of sources) {
-            for (const tag of source.tags || []) {
-                tagSet.add(tag);
-            }
-        }
-        // Create merged metadata with provenance
-        const metadata = {
-            mergedFrom: sources.map((m) => ({
-                id: m.id,
-                createdAt: m.createdAt,
-                source: m.source,
-            })),
-            mergeCount: sources.length,
+        // Build merged metadata with provenance
+        const metadata = this.buildBaseMetadata(sources, {
             timestamps: timestamps.sort(),
-        };
+        });
         return {
             content,
             summary: null,
-            tags: Array.from(tagSet),
+            tags: this.mergeTags(sources),
             metadata,
             mergeReason: `Merged ${sources.length} facts by combining all unique statements`,
             conflictWarnings: [],
@@ -76,27 +97,14 @@ class FactMergeStrategy {
  * PREFERENCE strategy: Keep latest by timestamp, track evolution history.
  * Warns if preferences conflict, indicating user changed their mind.
  */
-class PreferenceMergeStrategy {
+class PreferenceMergeStrategy extends BaseMergeStrategy {
     type = 'preference';
-    canMerge(sources) {
-        if (sources.length < 2) {
-            return { ok: false, reason: 'Need at least 2 memories to merge' };
-        }
-        return { ok: true };
-    }
     merge(sources) {
         if (sources.length === 0) {
-            return {
-                content: '',
-                summary: null,
-                tags: [],
-                metadata: {},
-                mergeReason: 'Empty source set',
-                conflictWarnings: [],
-            };
+            return this.handleEmptySources();
         }
         // Sort by creation date (newest first)
-        const sorted = [...sources].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        const sorted = this.sortByDate(sources);
         const latest = sorted[0];
         const warnings = [];
         // Check for conflicting preferences
@@ -112,12 +120,10 @@ class PreferenceMergeStrategy {
             confidence: m.confidence || 100,
             source: m.source,
         }));
-        const metadata = {
-            mergedFrom: sources.map((m) => m.id),
+        const metadata = this.buildBaseMetadata(sources, {
             preferenceHistory: history,
-            mergeCount: sources.length,
             latestAt: latest.createdAt,
-        };
+        });
         const summary = sources.length > 1
             ? `Prefers: ${latest.content} (evolved from ${sources.length} preferences)`
             : null;
@@ -135,27 +141,14 @@ class PreferenceMergeStrategy {
  * DECISION strategy: Keep latest decision, link to previous ones in timeline.
  * Warns if decisions contradict, preserving rationale history.
  */
-class DecisionMergeStrategy {
+class DecisionMergeStrategy extends BaseMergeStrategy {
     type = 'decision';
-    canMerge(sources) {
-        if (sources.length < 2) {
-            return { ok: false, reason: 'Need at least 2 memories to merge' };
-        }
-        return { ok: true };
-    }
     merge(sources) {
         if (sources.length === 0) {
-            return {
-                content: '',
-                summary: null,
-                tags: [],
-                metadata: {},
-                mergeReason: 'Empty source set',
-                conflictWarnings: [],
-            };
+            return this.handleEmptySources();
         }
         // Sort by creation date (newest first)
-        const sorted = [...sources].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        const sorted = this.sortByDate(sources);
         const latest = sorted[0];
         const warnings = [];
         // Check for conflicting decisions
@@ -170,13 +163,11 @@ class DecisionMergeStrategy {
             confidence: m.confidence || 100,
             rationale: m.summary || 'No rationale recorded',
         }));
-        const metadata = {
-            mergedFrom: sources.map((m) => m.id),
+        const metadata = this.buildBaseMetadata(sources, {
             decisionTimeline: timeline,
-            mergeCount: sources.length,
             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,
@@ -192,31 +183,17 @@ class DecisionMergeStrategy {
  * OBSERVATION strategy: Aggregate observations in chronological order.
  * Preserves temporal patterns and frequency information.
  */
-class ObservationMergeStrategy {
+class ObservationMergeStrategy extends BaseMergeStrategy {
     type = 'observation';
-    canMerge(sources) {
-        if (sources.length < 2) {
-            return { ok: false, reason: 'Need at least 2 memories to merge' };
-        }
-        return { ok: true };
-    }
     merge(sources) {
         if (sources.length === 0) {
-            return {
-                content: '',
-                summary: null,
-                tags: [],
-                metadata: {},
-                mergeReason: 'Empty source set',
-                conflictWarnings: [],
-            };
+            return this.handleEmptySources();
         }
         // Sort chronologically
-        const sorted = [...sources].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        const sorted = this.sortChronologically(sources);
         // Create observation summary
         const observations = sorted.map((m) => `• ${m.content}`).join('\n');
-        const metadata = {
-            mergedFrom: sources.map((m) => m.id),
+        const metadata = this.buildBaseMetadata(sources, {
             observationCount: sources.length,
             timeSpan: {
                 start: sorted[0].createdAt,
@@ -227,18 +204,11 @@ class ObservationMergeStrategy {
                 content: m.content,
                 createdAt: m.createdAt,
             })),
-        };
-        // Merge tags
-        const tagSet = new Set();
-        for (const source of sources) {
-            for (const tag of source.tags || []) {
-                tagSet.add(tag);
-            }
-        }
+        });
         return {
             content: `Observations (${sources.length} total):\n${observations}`,
             summary: `${sources.length} observations over time period`,
-            tags: Array.from(tagSet),
+            tags: this.mergeTags(sources),
             metadata,
             mergeReason: `Merged ${sources.length} observations chronologically`,
             conflictWarnings: [],
@@ -249,24 +219,11 @@ class ObservationMergeStrategy {
  * CONTEXT strategy: Union of unique context, remove exact duplicates.
  * Preserves all distinct context items.
  */
-class ContextMergeStrategy {
+class ContextMergeStrategy extends BaseMergeStrategy {
     type = 'context';
-    canMerge(sources) {
-        if (sources.length < 2) {
-            return { ok: false, reason: 'Need at least 2 memories to merge' };
-        }
-        return { ok: true };
-    }
     merge(sources) {
         if (sources.length === 0) {
-            return {
-                content: '',
-                summary: null,
-                tags: [],
-                metadata: {},
-                mergeReason: 'Empty source set',
-                conflictWarnings: [],
-            };
+            return this.handleEmptySources();
         }
         // Deduplicate by content (exact matches)
         const uniqueContexts = new Map();
@@ -280,23 +237,15 @@ class ContextMergeStrategy {
             .sort()
             .map((content) => `• ${content}`)
             .join('\n');
-        const metadata = {
-            mergedFrom: sources.map((m) => m.id),
+        const metadata = this.buildBaseMetadata(sources, {
             uniqueContextCount: uniqueContexts.size,
             totalContextCount: sources.length,
             deduplicatedEntries: sources.length - uniqueContexts.size,
-        };
-        // Merge tags
-        const tagSet = new Set();
-        for (const source of sources) {
-            for (const tag of source.tags || []) {
-                tagSet.add(tag);
-            }
-        }
+        });
         return {
             content: contextList,
             summary: `${uniqueContexts.size} context items (${sources.length} total)`,
-            tags: Array.from(tagSet),
+            tags: this.mergeTags(sources),
             metadata,
             mergeReason: `Merged ${sources.length} context records into ${uniqueContexts.size} unique items`,
             conflictWarnings: [],
@@ -309,6 +258,8 @@ export const MERGE_STRATEGIES = {
     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];

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

@@ -0,0 +1,133 @@
+/**
+ * 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

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

package/dist/core/associations.d.ts

@@ -8,8 +8,7 @@ export type AssociationType = 'co_occurred' | 'supersedes' | 'contradicts' | 'su
  */
 export declare function createAssociation(fromMemoryId: string, toMemoryId: string, type: AssociationType, weight?: number): Promise<void>;
 /**
- * Track co-activation of multiple memories (they were used together)
- * OPTIMIZED: Uses bulk upsert instead of N² individual database operations
+ * Track co-activation of multiple memories (used together)
  */
 export declare function trackCoactivation(memoryIds: string[]): Promise<void>;
 /**

package/dist/core/associations.js

@@ -47,8 +47,7 @@ export async function createAssociation(fromMemoryId, toMemoryId, type, weight =
     }
 }
 /**
- * Track co-activation of multiple memories (they were used together)
- * OPTIMIZED: Uses bulk upsert instead of N² individual database operations
+ * Track co-activation of multiple memories (used together)
  */
 export async function trackCoactivation(memoryIds) {
     if (memoryIds.length < 2)

package/dist/core/autosave.d.ts

@@ -0,0 +1,19 @@
+export declare function getDefaultAutosaveHook(): {
+    getMessageCount: () => number;
+    updateConfig: (opts?: {
+        enabled?: boolean;
+        messageCount?: number;
+        hooks?: string[];
+    }) => void;
+    getConfig: () => {
+        enabled: boolean;
+        messageCount: number;
+        hooks: string[];
+    };
+};
+export declare function createAutosaveConfig(): {
+    enabled: boolean;
+    messageCount: number;
+    hooks: string[];
+};
+//# sourceMappingURL=autosave.d.ts.map

package/dist/core/autosave.js

@@ -0,0 +1,16 @@
+// Autosave functionality placeholder
+export function getDefaultAutosaveHook() {
+    let config = { enabled: false, messageCount: 10, hooks: [] };
+    return {
+        getMessageCount: () => 0,
+        updateConfig: (opts) => {
+            if (opts)
+                Object.assign(config, opts);
+        },
+        getConfig: () => ({ ...config })
+    };
+}
+export function createAutosaveConfig() {
+    return { enabled: false, messageCount: 10, hooks: [] };
+}
+//# sourceMappingURL=autosave.js.map

package/dist/{commands → core/commands}/managed-sync.js

@@ -1,7 +1,7 @@
-import { MCPClient } from '../core/mcp/client.js';
-import { config } from '../config.js';
-import { logger } from '../core/logger.js';
-import { searchMemories, rememberMemory } from '../core/memory/memories.js';
+import { MCPClient } from '../../core/mcp/client.js';
+import { config } from '../../config.js';
+import { logger } from '../../core/logger.js';
+import { search, rememberMemory } from '../../core/memory/memories.js';
 export class ManagedSync {
     client;
     syncEnabled;
@@ -26,7 +26,7 @@ export class ManagedSync {
         if (!this.syncEnabled)
             return;
         try {
-            const memory = await searchMemories({ query: memoryId, limit: 1 });
+            const memory = await search({ query: memoryId, limit: 1 });
             if (memory.length > 0) {
                 await this.client.callTool('managed_memory_store', {
                     memory: memory[0],