squish-memory 1.0.1 → 1.1.5

package/dist/{algorithms → core/algorithms}/detection/two-stage-detector.js

@@ -4,18 +4,15 @@
  * Stage 1: Hash-based prefiltering (SimHash + MinHash)
  * Stage 2: Semantic ranking using embeddings
  */
-import { getEmbedding, getBatchEmbeddings } from '../../core/embeddings.js';
+import { getEmbedding, getBatchEmbeddings } from '../../../core/embeddings.js';
 import { SimHashFilter, MinHashFilter, findCandidatePairs } from './hash-filters.js';
 import { rankCandidates, analyzePair } from './semantic-ranker.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
 import { eq, and } from 'drizzle-orm';
 import * as crypto from 'crypto';
+import { getDbClient } from '../../../core/lib/db-client.js';
 export async function detectDuplicates(options) {
     const startTime = Date.now();
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     let query = db.select().from(schema.memories);
     if (options.projectId) {
         query = query.where(eq(schema.memories.projectId, options.projectId));
@@ -239,8 +236,7 @@ export async function detectDuplicates(options) {
     };
 }
 export async function analyzeMergePair(memoryId1, memoryId2) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const [memory1] = await db
         .select()
         .from(schema.memories)
@@ -271,6 +267,8 @@ function countByType(memories) {
         decision: 0,
         context: 0,
         preference: 0,
+        reflection: 0,
+        note: 0,
     };
     for (const memory of memories) {
         const type = memory.type;
@@ -281,8 +279,7 @@ function countByType(memories) {
     return counts;
 }
 export async function getDetectionStats(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const memories = await db
         .select()
         .from(schema.memories)

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

@@ -2,13 +2,13 @@
  * Executes the approved merge in a single atomic transaction.
  */
 import { randomUUID } from 'crypto';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq, inArray } from 'drizzle-orm';
 import { mergeMemories } from '../strategies/merge-strategies.js';
 import { estimateTokensSaved } from '../analytics/token-estimator.js';
-import { getEmbedding } from '../../core/embeddings.js';
+import { getEmbedding } from '../../../core/embeddings.js';
 export async function handleApproveMerge(input) {
     try {
         const { proposalId, reviewNotes } = input;

package/dist/{algorithms → core/algorithms}/handlers/detect-duplicates.js

@@ -9,9 +9,9 @@ import { detectDuplicates } from '../detection/two-stage-detector.js';
 import { runSafetyChecks } from '../safety/safety-checks.js';
 import { mergeMemories } from '../strategies/merge-strategies.js';
 import { estimateTokensSaved } from '../analytics/token-estimator.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { buildSuccessResponse, buildErrorResponse } from '../utils/response-builder.js';
 /**
  * Handle detect_duplicate_memories tool call

package/dist/{algorithms → core/algorithms}/handlers/get-stats.js

@@ -3,9 +3,9 @@
  *
  * Returns statistics about memory merges for a project
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 import { calculateProjectTokenSavings, formatTokenCount } from '../analytics/token-estimator.js';
 /**

package/dist/{algorithms → core/algorithms}/handlers/list-proposals.js

@@ -3,9 +3,9 @@
  *
  * Lists pending merge proposals for user review
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq, desc } from 'drizzle-orm';
 /**
  * Handle list_merge_proposals tool call

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

@@ -1,9 +1,9 @@
 /**
  * Shows a preview of the merged result without executing the merge.
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 import { estimateMergeSavingsPreview } from '../analytics/token-estimator.js';
 import { mergeMemories } from '../strategies/merge-strategies.js';

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

@@ -3,9 +3,9 @@
  *
  * Rejects a merge proposal without executing it
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 /**
  * Handle reject_merge tool call

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

@@ -1,9 +1,9 @@
 /**
  * Reverses/undoes a completed merge and restores original memories.
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 export async function handleReverseMerge(input) {
     try {

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

@@ -0,0 +1,21 @@
+/**
+ * Memory Merging Feature - Barrel Exports
+ *
+ * Provides a clean public API for memory merging functionality
+ */
+export * from './types.js';
+export { detectDuplicates, analyzeMergePair, getDetectionStats } from './detection/two-stage-detector.js';
+export { SimHashFilter, MinHashFilter, findCandidatePairs } from './detection/hash-filters.js';
+export { rankCandidates, analyzePair } from './detection/semantic-ranker.js';
+export { getMergeStrategy, mergeMemories, MERGE_STRATEGIES } from './strategies/merge-strategies.js';
+export type { MergeStrategy, MergedMemory } from './strategies/merge-strategies.js';
+export { runSafetyChecks, checkBlockers, formatSafetyResults, describeSafetyChecks } from './safety/safety-checks.js';
+export { estimateTokensSaved, calculateProjectTokenSavings, estimateMergeSavingsPreview, getTokenStatistics, formatTokenCount, formatSavingsReport, } from './analytics/token-estimator.js';
+export { handleDetectDuplicates } from './handlers/detect-duplicates.js';
+export { handleListProposals } from './handlers/list-proposals.js';
+export { handlePreviewMerge } from './handlers/preview-merge.js';
+export { handleApproveMerge } from './handlers/approve-merge.js';
+export { handleRejectMerge } from './handlers/reject-merge.js';
+export { handleReverseMerge } from './handlers/reverse-merge.js';
+export { handleGetMergeStats } from './handlers/get-stats.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/algorithms/index.js

@@ -0,0 +1,26 @@
+/**
+ * Memory Merging Feature - Barrel Exports
+ *
+ * Provides a clean public API for memory merging functionality
+ */
+// Types
+export * from './types.js';
+// Detection
+export { detectDuplicates, analyzeMergePair, getDetectionStats } from './detection/two-stage-detector.js';
+export { SimHashFilter, MinHashFilter, findCandidatePairs } from './detection/hash-filters.js';
+export { rankCandidates, analyzePair } from './detection/semantic-ranker.js';
+// Merge Strategies
+export { getMergeStrategy, mergeMemories, MERGE_STRATEGIES } from './strategies/merge-strategies.js';
+// Safety
+export { runSafetyChecks, checkBlockers, formatSafetyResults, describeSafetyChecks } from './safety/safety-checks.js';
+// Analytics & Tokens
+export { estimateTokensSaved, calculateProjectTokenSavings, estimateMergeSavingsPreview, getTokenStatistics, formatTokenCount, formatSavingsReport, } from './analytics/token-estimator.js';
+// Handlers (MCP Tools)
+export { handleDetectDuplicates } from './handlers/detect-duplicates.js';
+export { handleListProposals } from './handlers/list-proposals.js';
+export { handlePreviewMerge } from './handlers/preview-merge.js';
+export { handleApproveMerge } from './handlers/approve-merge.js';
+export { handleRejectMerge } from './handlers/reject-merge.js';
+export { handleReverseMerge } from './handlers/reverse-merge.js';
+export { handleGetMergeStats } from './handlers/get-stats.js';
+//# sourceMappingURL=index.js.map

package/dist/core/algorithms/operations/cache-maintenance.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hash cache maintenance - SimHash/MinHash signatures for duplicate detection
+ */
+export declare function updateCache(memoryId: string): Promise<boolean>;
+export declare function rebuildCache(projectId: string): Promise<{
+    processed: number;
+    succeeded: number;
+    failed: number;
+}>;
+export declare function isStale(memoryId: string): Promise<boolean>;
+export declare function cleanupOrphaned(projectId: string): Promise<number>;
+//# sourceMappingURL=cache-maintenance.d.ts.map

package/dist/core/algorithms/operations/cache-maintenance.js

@@ -0,0 +1,157 @@
+/**
+ * Hash cache maintenance - SimHash/MinHash signatures for duplicate detection
+ */
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
+import { eq } from 'drizzle-orm';
+import { SimHashFilter, MinHashFilter } from '../detection/hash-filters.js';
+import crypto from 'crypto';
+import { logger } from '../../../core/logger.js';
+function hashContent(content) {
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+export async function updateCache(memoryId) {
+    try {
+        const db = createDatabaseClient(await getDb());
+        const schema = await getSchema();
+        // Load the memory
+        const [memory] = await db
+            .select()
+            .from(schema.memories)
+            .where(eq(schema.memories.id, memoryId));
+        if (!memory) {
+            return false;
+        }
+        // Generate hashes
+        const simhashFilter = new SimHashFilter();
+        const minhashFilter = new MinHashFilter();
+        const simhash = simhashFilter.generateHash(memory.content);
+        const minhash = minhashFilter.generateSignature(memory.content);
+        const contentHash = hashContent(memory.content);
+        // Upsert cache entry
+        const now = new Date();
+        // Check if entry exists
+        const [existing] = await db
+            .select()
+            .from(schema.memoryHashCache)
+            .where(eq(schema.memoryHashCache.memoryId, memoryId));
+        if (existing) {
+            // Update existing
+            await db
+                .update(schema.memoryHashCache)
+                .set({
+                simhash,
+                minhash: minhash,
+                contentHash,
+                lastUpdated: now,
+            })
+                .where(eq(schema.memoryHashCache.memoryId, memoryId));
+        }
+        else {
+            // Create new
+            await db.insert(schema.memoryHashCache).values({
+                memoryId,
+                projectId: memory.projectId,
+                simhash,
+                minhash: minhash,
+                contentHash,
+                lastUpdated: now,
+            });
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error(`Failed to update hash cache for ${memoryId}`, error);
+        return false;
+    }
+}
+export async function rebuildCache(projectId) {
+    try {
+        const db = createDatabaseClient(await getDb());
+        const schema = await getSchema();
+        // Get all memories in project
+        const memories = await db
+            .select()
+            .from(schema.memories)
+            .where(eq(schema.memories.projectId, projectId));
+        let succeeded = 0;
+        let failed = 0;
+        for (const memory of memories) {
+            const ok = await updateCache(memory.id);
+            if (ok) {
+                succeeded++;
+            }
+            else {
+                failed++;
+            }
+        }
+        return {
+            processed: memories.length,
+            succeeded,
+            failed,
+        };
+    }
+    catch (error) {
+        logger.error(`Failed to rebuild hash cache for project ${projectId}`, error);
+        return { processed: 0, succeeded: 0, failed: 0 };
+    }
+}
+export async function isStale(memoryId) {
+    try {
+        const db = createDatabaseClient(await getDb());
+        const schema = await getSchema();
+        const [memory] = await db
+            .select()
+            .from(schema.memories)
+            .where(eq(schema.memories.id, memoryId));
+        if (!memory) {
+            return true;
+        }
+        const [cacheEntry] = await db
+            .select()
+            .from(schema.memoryHashCache)
+            .where(eq(schema.memoryHashCache.memoryId, memoryId));
+        if (!cacheEntry) {
+            return true; // No cache entry = stale
+        }
+        const currentContentHash = hashContent(memory.content);
+        return currentContentHash !== cacheEntry.contentHash;
+    }
+    catch (error) {
+        logger.error('Failed to check hash cache staleness', error);
+        return true; // Assume stale on error
+    }
+}
+export async function cleanupOrphaned(projectId) {
+    try {
+        const db = createDatabaseClient(await getDb());
+        const schema = await getSchema();
+        // Get all cache entries for project
+        const cacheEntries = await db
+            .select()
+            .from(schema.memoryHashCache)
+            .where(eq(schema.memoryHashCache.projectId, projectId));
+        let deleted = 0;
+        for (const entry of cacheEntries) {
+            // Check if memory exists
+            const [memory] = await db
+                .select()
+                .from(schema.memories)
+                .where(eq(schema.memories.id, entry.memoryId));
+            if (!memory) {
+                // Memory doesn't exist, delete cache entry
+                await db
+                    .delete(schema.memoryHashCache)
+                    .where(eq(schema.memoryHashCache.memoryId, entry.memoryId));
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    catch (error) {
+        logger.error('Failed to cleanup orphaned hash cache', error);
+        return 0;
+    }
+}
+//# sourceMappingURL=cache-maintenance.js.map

package/dist/{algorithms → core/algorithms}/safety/safety-checks.d.ts

@@ -2,7 +2,7 @@
  * Safety checks to prevent bad merges.
  * Checks run before creating merge proposals and are categorized as BLOCKER or WARNING.
  */
-import type { Memory } from '../../drizzle/schema.js';
+import type { Memory } from '../../../db/drizzle/schema.js';
 export interface SafetyCheckResult {
     passed: boolean;
     warnings: string[];

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

@@ -2,7 +2,7 @@
  * Type-specific merge strategies for different memory types.
  * Each type has different merge semantics to preserve meaning and prevent data loss.
  */
-import type { Memory, MemoryType } from '../../drizzle/schema.js';
+import type { Memory, MemoryType } from '../../../db/drizzle/schema.js';
 export interface MergeStrategy {
     type: MemoryType;
     /**
@@ -26,6 +26,24 @@ export interface MergedMemory {
     mergeReason: string;
     conflictWarnings: string[];
 }
+/**
+ * Base implementation of MergeStrategy with common functionality.
+ * Reduces code duplication across specific merge strategies.
+ */
+export declare abstract class BaseMergeStrategy implements MergeStrategy {
+    abstract type: MemoryType;
+    canMerge(sources: Memory[]): {
+        ok: boolean;
+        reason?: string;
+    };
+    protected validateSources(sources: Memory[]): boolean;
+    protected handleEmptySources(): MergedMemory;
+    protected mergeTags(sources: Memory[]): string[];
+    protected buildBaseMetadata(sources: Memory[], extra?: Record<string, unknown>): Record<string, unknown>;
+    protected sortByDate(sources: Memory[], order?: 'asc' | 'desc'): Memory[];
+    protected sortChronologically(sources: Memory[]): Memory[];
+    abstract merge(sources: Memory[]): MergedMemory;
+}
 export declare const MERGE_STRATEGIES: Record<MemoryType, MergeStrategy>;
 export declare function getMergeStrategy(type: MemoryType): MergeStrategy;
 export declare function mergeMemories(sources: Memory[]): MergedMemory;