squish-memory 1.2.0 → 1.2.1

package/dist/core/commands/remember.js

@@ -1,144 +0,0 @@
-/**
- * Remember Command - Unified memory write
- *
- * Single implementation for both CLI and MCP.
- */
-import { rememberMemory, findSimilarMemories } from '../memory/memories.js';
-import { createLearning } from '../ingestion/learnings.js';
-import { pinMemory, unpinMemory } from '../security/governance.js';
-import { detectMemorySignals } from '../memory/trigger-detector.js';
-export async function executeRemember(options) {
-    const { content, project, tags, tier, type, learningType, source, route, pin, unpin } = options;
-    const signals = detectMemorySignals(content);
-    let routing = "memory";
-    let inferredType = type || signals.suggestedType;
-    let routingReason = "";
-    // Check for learning patterns if auto mode
-    if (route === "auto" || !route) {
-        const hasLessonPattern = /(\bfailed\s+because\b|\blesson\s+learned\b|\bnext\s+time\b|\broot\s+cause\b|\bsuccess\b.*\bbecause\b|\bi\s+learned\b|\binsight\b)/i.test(content);
-        const hasLearningType = /(\bsuccess\b|\bfailure\b|\bfix\b|\binsight\b)/i.test(content);
-        const hasHackPattern = /(\bHACK\b|\bworkaround\b|\btemporary\s+fix\b)/i.test(content);
-        const hasFixmePattern = /(\bFIXME\b|\bXXX\b|\bbug\b.*\bfix\b)/i.test(content);
-        if (hasLessonPattern || hasLearningType || hasHackPattern || hasFixmePattern) {
-            routing = "learning";
-            if (hasHackPattern || hasFixmePattern) {
-                routingReason = "Detected code pattern (HACK/FIXME)";
-            }
-            else {
-                routingReason = "Detected learning pattern in content";
-            }
-        }
-        else if (signals.suggestedType === 'task') {
-            routing = "memory";
-            routingReason = "Detected TODO pattern";
-        }
-        else if (signals.suggestedType === 'observation' && /\b(note|note\s+that|log|remember)\b/i.test(content)) {
-            routing = "note";
-            routingReason = "Detected note pattern";
-        }
-        else {
-            routing = "memory";
-            routingReason = `Detected as ${inferredType}`;
-        }
-    }
-    else if (route === "learning") {
-        routing = "learning";
-        routingReason = "Override: forced to learning";
-    }
-    else if (route === "note") {
-        routing = "note";
-        routingReason = "Override: forced to note";
-    }
-    else {
-        routing = "memory";
-        routingReason = "Override: forced to memory";
-    }
-    let result;
-    const parsedTags = tags ? tags.split(',').map((t) => t.trim()) : [];
-    const parsedTier = tier === "cold" ? "cold" : "hot";
-    if (routing === "learning") {
-        let parsedLearningType = "insight";
-        if (learningType) {
-            parsedLearningType = learningType;
-        }
-        else {
-            if (/(\bsuccess\b|\bworked\b|\bfinished\b)/i.test(content))
-                parsedLearningType = "success";
-            else if (/(\bfailed\b|\berror\b|\bbroke\b)/i.test(content))
-                parsedLearningType = "failure";
-            else if (/(\bfix\b|\b workaround\b|\bsolved\b)/i.test(content))
-                parsedLearningType = "fix";
-        }
-        const learning = await createLearning({
-            type: parsedLearningType,
-            content,
-            project,
-            autoLink: true
-        });
-        result = { id: learning.id, type: "learning", learningType: parsedLearningType, content };
-    }
-    else {
-        // Check for similar memories to avoid duplicates (deduplication)
-        const similarMemories = await findSimilarMemories(content, 0.85, 3);
-        const memory = await rememberMemory({
-            content,
-            type: inferredType,
-            tags: parsedTags,
-            project,
-            tier: parsedTier,
-            source: source || 'cli'
-        });
-        // If found similar memories, create association instead of duplicate
-        if (similarMemories.length > 0) {
-            const { createAssociation } = await import('../associations.js');
-            for (const similar of similarMemories) {
-                await createAssociation(memory.id, similar.id, 'duplicate', similar.similarity ?? 0.85);
-            }
-            memory.similarTo = similarMemories.map(s => s.id);
-        }
-        if (pin) {
-            await pinMemory(memory.id);
-        }
-        else if (unpin) {
-            await unpinMemory(memory.id);
-        }
-        result = { id: memory.id, type: "memory", memoryType: inferredType, tier: parsedTier, content, pinned: pin };
-        // Auto-update knowledge graph (fire-and-forget, don't fail remember on graph error)
-        const { addMemoryToGraph } = await import('../graph/graph-builder.js');
-        const graphResult = await addMemoryToGraph(memory.id).catch((e) => {
-            console.warn('[Graph] Auto-update failed:', e.message);
-            return null;
-        });
-        if (graphResult) {
-            result.graph = { entities: graphResult.entitiesCreated, relations: graphResult.relationsCreated };
-        }
-        // Auto-assign to place (fire-and-forget)
-        const { autoAssignMemory } = await import('../places/memory-places.js');
-        const projectId = memory.projectId || project;
-        const placeResult = await autoAssignMemory({
-            memoryId: memory.id,
-            projectId: projectId,
-            content: content,
-            tags: parsedTags,
-            memoryType: inferredType
-        }).catch((e) => {
-            console.warn('[Places] Auto-assign failed:', e.message);
-            return null;
-        });
-        if (placeResult?.assigned && placeResult.placeId) {
-            result.place = { id: placeResult.placeId, type: placeResult.placeType ?? 'inbox' };
-        }
-    }
-    return {
-        ok: true,
-        id: result.id,
-        routing,
-        type: routing === "learning" ? result.learningType : result.memoryType,
-        tier: routing === "memory" ? parsedTier : 'N/A',
-        priority: signals.priority,
-        confidence: signals.confidence,
-        pinned: result.pinned,
-        reason: routingReason
-    };
-}
-//# sourceMappingURL=remember.js.map

package/dist/core/compression.d.ts

@@ -1,45 +0,0 @@
-/**
- * TOON Compression - Token-efficient memory format
- *
- * Compact format for memory context using abbreviated notation.
- * Achieves efficient token usage for context injection.
- *
- * Format:
- * {
- *   m:[type],      // memory type (1-2 chars)
- *   c:"...",       // content (truncated)
- *   t:[],          // tags (array)
- *   d:123          // days ago
- * }
- */
-/**
- * Compress a memory to TOON format
- */
-export declare function compressForContext(content: string): string;
-/**
- * Decompress TOON back to readable format
- */
-export declare function decompressFromContext(toonString: string): string;
-/**
- * Estimate compression ratio
- */
-export declare function estimateCompressionRatio(content: string): number;
-/**
- * Check if content is JSON
- */
-export declare function isJson(content: string): boolean;
-/**
- * Check if content is compressed format
- */
-export declare function isCompressed(content: string): boolean;
-/**
- * Count tokens (rough estimate)
- * Import from context-window.ts - single source of truth
- */
-import { estimateTokens } from './context/context-window.js';
-export { estimateTokens };
-/**
- * Truncate to token budget
- */
-export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
-//# sourceMappingURL=compression.d.ts.map

package/dist/core/compression.js

@@ -1,160 +0,0 @@
-/**
- * TOON Compression - Token-efficient memory format
- *
- * Compact format for memory context using abbreviated notation.
- * Achieves efficient token usage for context injection.
- *
- * Format:
- * {
- *   m:[type],      // memory type (1-2 chars)
- *   c:"...",       // content (truncated)
- *   t:[],          // tags (array)
- *   d:123          // days ago
- * }
- */
-const MAX_CONTENT_LENGTH = 80; // Max chars per content
-const MAX_TAGS = 3; // Max tags to include
-/**
- * Compress a memory to TOON format
- */
-export function compressForContext(content) {
-    // If not JSON or already short, just return
-    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
-        return content;
-    }
-    try {
-        const parsed = JSON.parse(content);
-        // Build compact TOON object
-        const toon = {
-            m: parsed.type?.substring(0, 2) || 'ob', // observation -> ob
-        };
-        // Truncate content
-        if (parsed.content) {
-            const truncated = parsed.content.substring(0, MAX_CONTENT_LENGTH);
-            toon.c = truncated.length < parsed.content.length ? truncated + '..' : truncated;
-        }
-        // Add tags (limited)
-        if (parsed.tags && Array.isArray(parsed.tags)) {
-            toon.t = parsed.tags.slice(0, MAX_TAGS);
-        }
-        // Add days ago if there's a date
-        if (parsed.createdAt) {
-            const days = Math.floor((Date.now() - new Date(parsed.createdAt).getTime()) / (1000 * 60 * 60 * 24));
-            if (days > 0) {
-                toon.d = days;
-            }
-        }
-        return JSON.stringify(toon);
-    }
-    catch {
-        // Not parseable JSON, return truncated content
-        return content.substring(0, MAX_CONTENT_LENGTH);
-    }
-}
-/**
- * Decompress TOON back to readable format
- */
-export function decompressFromContext(toonString) {
-    // Check if it's TOON format
-    if (!isCompressed(toonString)) {
-        return toonString;
-    }
-    try {
-        const parsed = JSON.parse(toonString);
-        // If it has TOON markers, expand it
-        if (parsed.m || parsed.c || parsed.t) {
-            const typeMap = {
-                ob: 'observation',
-                su: 'success',
-                f: 'failure',
-                fx: 'fix',
-                i: 'insight',
-            };
-            const type = typeMap[parsed.m] || 'observation';
-            const parts = [`[${type}]`];
-            if (parsed.c) {
-                parts.push(parsed.c);
-            }
-            if (parsed.t && parsed.t.length > 0) {
-                parts.push(`#${parsed.t.join(' #')}`);
-            }
-            if (parsed.d) {
-                parts.push(`(${parsed.d}d ago)`);
-            }
-            return parts.join(' ');
-        }
-        return toonString;
-    }
-    catch {
-        // Not valid TOON, return as-is
-        return toonString;
-    }
-}
-/**
- * Estimate compression ratio
- */
-export function estimateCompressionRatio(content) {
-    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
-        return 1.0;
-    }
-    const compressed = compressForContext(content);
-    return compressed.length / content.length;
-}
-/**
- * Check if content is JSON
- */
-export function isJson(content) {
-    try {
-        JSON.parse(content);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if content is compressed format
- */
-export function isCompressed(content) {
-    if (!content.startsWith('{') || !content.endsWith('}')) {
-        return false;
-    }
-    try {
-        const parsed = JSON.parse(content);
-        // Has compressed markers
-        return parsed.m !== undefined || parsed.c !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Count tokens (rough estimate)
- * Import from context-window.ts - single source of truth
- */
-import { estimateTokens } from './context/context-window.js';
-export { estimateTokens };
-/**
- * Truncate to token budget
- */
-export function truncateToTokenBudget(content, maxTokens) {
-    const tokens = estimateTokens(content);
-    if (tokens <= maxTokens) {
-        return content;
-    }
-    // Binary search for the right length
-    let low = 0;
-    let high = content.length;
-    while (low < high) {
-        const mid = Math.floor((low + high) / 2);
-        const estimated = estimateTokens(content.substring(0, mid));
-        if (estimated <= maxTokens) {
-            low = mid + 1;
-        }
-        else {
-            high = mid;
-        }
-    }
-    return content.substring(0, low) + '...';
-}
-//# sourceMappingURL=compression.js.map

package/dist/core/consolidation.d.ts

@@ -1,37 +0,0 @@
-export interface ConsolidationStats {
-    clustered: number;
-    merged: number;
-    tokensRecovered: number;
-    deduped: number;
-    consolidated: number;
-}
-export interface DeduplicationResult {
-    duplicatesFound: number;
-    mergedCount: number;
-    tokensRecovered: number;
-    groups: DuplicateGroup[];
-}
-export interface DuplicateGroup {
-    canonicalId: string;
-    duplicateIds: string[];
-    similarity: number;
-    reason: string;
-}
-/**
- * Run automated deduplication job
- * Finds and marks duplicates for review or auto-merges high-confidence duplicates
- */
-export declare function runDeduplicationJob(projectId?: string): Promise<DeduplicationResult>;
-/**
- * Run full consolidation job (dedup + memory consolidation)
- */
-export declare function runFullConsolidationJob(projectId?: string): Promise<ConsolidationStats>;
-/**
- * Get deduplication statistics
- */
-export declare function getDeduplicationStats(projectId?: string): Promise<{
-    totalMemories: number;
-    mergedMemories: number;
-    pendingDuplicates: number;
-}>;
-//# sourceMappingURL=consolidation.d.ts.map

package/dist/core/consolidation.js

@@ -1,248 +0,0 @@
-// Memory Consolidation & Deduplication
-import { eq, inArray, and } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { createAssociation } from './associations.js';
-import { logger } from './logger.js';
-import { consolidateMemories } from './memory/consolidation.js';
-/**
- * Run automated deduplication job
- * Finds and marks duplicates for review or auto-merges high-confidence duplicates
- */
-export async function runDeduplicationJob(projectId) {
-    const result = {
-        duplicatesFound: 0,
-        mergedCount: 0,
-        tokensRecovered: 0,
-        groups: [],
-    };
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get active memories for deduplication check
-        const whereClause = projectId
-            ? and(eq(schema.memories.projectId, projectId), eq(schema.memories.status, 'active'))
-            : eq(schema.memories.status, 'active');
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(whereClause)
-            .limit(500);
-        if (memories.length < 2) {
-            return result;
-        }
-        // Find duplicate groups using SimHash
-        const duplicateGroups = await findDuplicatesBySimHash(memories);
-        result.duplicatesFound = duplicateGroups.reduce((sum, g) => sum + g.duplicateIds.length, 0);
-        // Auto-merge high-confidence duplicates (>0.95 similarity)
-        for (const group of duplicateGroups) {
-            if (group.similarity >= 0.95) {
-                const tokensSaved = await autoMergeDuplicates(group.canonicalId, group.duplicateIds);
-                result.mergedCount += group.duplicateIds.length;
-                result.tokensRecovered += tokensSaved;
-            }
-            else {
-                // Lower confidence - just create association for review
-                for (const dupId of group.duplicateIds) {
-                    await createAssociation(group.canonicalId, dupId, 'duplicate', group.similarity);
-                }
-            }
-            result.groups.push(group);
-        }
-        logger.info('Deduplication job completed', {
-            duplicatesFound: result.duplicatesFound,
-            mergedCount: result.mergedCount,
-            tokensRecovered: result.tokensRecovered,
-        });
-    }
-    catch (error) {
-        logger.error('Deduplication job error', error);
-    }
-    return result;
-}
-/**
- * Find duplicates using SimHash (efficient near-duplicate detection)
- */
-async function findDuplicatesBySimHash(memories) {
-    const groups = [];
-    const processed = new Set();
-    // Compute SimHash for each memory
-    const hashes = memories.map(m => ({
-        id: m.id,
-        hash: computeSimHash(m.content),
-        content: m.content,
-        createdAt: m.createdAt,
-    }));
-    // Compare hashes to find similar content
-    for (let i = 0; i < hashes.length; i++) {
-        if (processed.has(hashes[i].id))
-            continue;
-        const duplicates = [];
-        let maxSimilarity = 0;
-        for (let j = i + 1; j < hashes.length; j++) {
-            if (processed.has(hashes[j].id))
-                continue;
-            const hammingDistance = computeHammingDistance(hashes[i].hash, hashes[j].hash);
-            const similarity = 1 - (hammingDistance / 64); // 64-bit hash
-            if (similarity >= 0.85) {
-                duplicates.push(hashes[j].id);
-                maxSimilarity = Math.max(maxSimilarity, similarity);
-                processed.add(hashes[j].id);
-            }
-        }
-        if (duplicates.length > 0) {
-            processed.add(hashes[i].id);
-            groups.push({
-                canonicalId: hashes[i].id, // Keep oldest as canonical
-                duplicateIds: duplicates,
-                similarity: maxSimilarity,
-                reason: 'content-similarity',
-            });
-        }
-    }
-    return groups;
-}
-/**
- * Compute SimHash for text (64-bit fingerprint)
- */
-function computeSimHash(text) {
-    const tokens = text.toLowerCase().split(/\s+/).filter(t => t.length > 2);
-    const weights = new Array(64).fill(0);
-    for (const token of tokens) {
-        const hash = simpleHash(token);
-        for (let i = 0; i < 64; i++) {
-            if ((hash >> BigInt(i)) & 1n) {
-                weights[i] += 1;
-            }
-            else {
-                weights[i] -= 1;
-            }
-        }
-    }
-    let simHash = 0n;
-    for (let i = 0; i < 64; i++) {
-        if (weights[i] > 0) {
-            simHash |= (1n << BigInt(i));
-        }
-    }
-    return simHash;
-}
-/**
- * Simple hash function for strings
- */
-function simpleHash(str) {
-    let hash = 0n;
-    for (let i = 0; i < str.length; i++) {
-        const char = BigInt(str.charCodeAt(i));
-        hash = ((hash << 5n) - hash) + char;
-        hash = hash & hash; // Convert to 64bit integer
-    }
-    return hash;
-}
-/**
- * Compute Hamming distance between two hashes
- */
-function computeHammingDistance(a, b) {
-    let xor = a ^ b;
-    let distance = 0;
-    while (xor !== 0n) {
-        distance += Number(xor & 1n);
-        xor >>= 1n;
-    }
-    return distance;
-}
-/**
- * Auto-merge duplicates into canonical memory
- */
-async function autoMergeDuplicates(canonicalId, duplicateIds) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Calculate tokens recovered
-        const duplicates = await db
-            .select()
-            .from(schema.memories)
-            .where(inArray(schema.memories.id, duplicateIds));
-        let tokensRecovered = 0;
-        for (const dup of duplicates) {
-            tokensRecovered += Math.ceil((dup.content?.length || 0) / 4);
-        }
-        // Mark duplicates as merged
-        await db
-            .update(schema.memories)
-            .set({
-            status: 'merged',
-            mergedInto: canonicalId,
-            mergedAt: now,
-            updatedAt: now,
-        })
-            .where(inArray(schema.memories.id, duplicateIds));
-        // Create associations for traceability
-        for (const dupId of duplicateIds) {
-            await createAssociation(canonicalId, dupId, 'merged', 0.95);
-        }
-        return tokensRecovered;
-    }
-    catch (error) {
-        logger.error('Error auto-merging duplicates', error);
-        return 0;
-    }
-}
-/**
- * Run full consolidation job (dedup + memory consolidation)
- */
-export async function runFullConsolidationJob(projectId) {
-    const stats = {
-        clustered: 0,
-        merged: 0,
-        tokensRecovered: 0,
-        deduped: 0,
-        consolidated: 0,
-    };
-    // Run deduplication first
-    const dedupResult = await runDeduplicationJob(projectId);
-    stats.deduped = dedupResult.duplicatesFound;
-    stats.merged = dedupResult.mergedCount;
-    stats.tokensRecovered += dedupResult.tokensRecovered;
-    // Run memory consolidation for each project
-    if (projectId) {
-        const consolidationResults = await consolidateMemories({
-            projectId,
-            minAge: 60,
-            maxImportance: 25,
-            minClusterSize: 3,
-            limit: 100,
-        });
-        stats.consolidated = consolidationResults.length;
-        stats.clustered = consolidationResults.reduce((sum, r) => sum + r.clusterSize, 0);
-    }
-    logger.info('Full consolidation job completed', stats);
-    return stats;
-}
-/**
- * Get deduplication statistics
- */
-export async function getDeduplicationStats(projectId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const whereClause = projectId
-            ? eq(schema.memories.projectId, projectId)
-            : undefined;
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(whereClause);
-        return {
-            totalMemories: memories.length,
-            mergedMemories: memories.filter((m) => m.status === 'merged').length,
-            pendingDuplicates: 0, // Would need to query associations
-        };
-    }
-    catch (error) {
-        logger.error('Error getting deduplication stats', error);
-        return { totalMemories: 0, mergedMemories: 0, pendingDuplicates: 0 };
-    }
-}
-//# sourceMappingURL=consolidation.js.map