squish-memory 1.1.5 → 1.2.0

package/dist/core/hot-cache.js

@@ -0,0 +1,285 @@
+/**
+ * Hot Cache - Persistent session context (Karpathy-style)
+ *
+ * Implements the "hot.md" layer from LLM Wiki pattern:
+ * - ~500 words persistent session context
+ * - Survives restart (unlike session working set)
+ * - Auto-updates on session events
+ * - Deduplication and stale detection
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { logger } from '../logger.js';
+import { getProjectPath } from '../projects.js';
+const HOT_CACHE_VERSION = '1.0.0';
+const MAX_HOT_CACHE_SIZE = 500; // ~500 words max
+const STALE_THRESHOLD_DAYS = 7; // Flag as stale after 7 days
+const STALE_REFERENCE_COUNT = 3; // Minimum refs before considering stale
+let hotCacheInstance = null;
+/**
+ * Get the hot cache file path for a project
+ */
+function getHotCachePath(projectPath) {
+    return join(projectPath, '.squish', 'hot-cache.json');
+}
+/**
+ * Ensure .squish directory exists
+ */
+async function ensureSquishDir(projectPath) {
+    const squishDir = join(projectPath, '.squish');
+    if (!existsSync(squishDir)) {
+        mkdirSync(squishDir, { recursive: true });
+    }
+    return squishDir;
+}
+/**
+ * Create content hash for deduplication
+ */
+function hashContent(content) {
+    return createHash('sha256').update(content.trim()).digest('hex').slice(0, 12);
+}
+/**
+ * Load hot cache from disk (or create new)
+ */
+export async function loadHotCache(projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path) {
+        return createEmptyHotCache('');
+    }
+    const cachePath = getHotCachePath(path);
+    try {
+        if (existsSync(cachePath)) {
+            const content = readFileSync(cachePath, 'utf-8');
+            const cache = JSON.parse(content);
+            // Clean stale entries on load
+            cache.staleEntries = identifyStaleEntries(cache.entries);
+            // Remove very stale entries (>14 days)
+            cache.entries = cache.entries.filter(entry => {
+                const ageDays = (Date.now() - entry.lastReferencedAt) / (24 * 60 * 60 * 1000);
+                return ageDays < 14;
+            });
+            logger.info('[HotCache] Loaded', { entries: cache.entries.length, path });
+            return cache;
+        }
+    }
+    catch (error) {
+        logger.warn('[HotCache] Load failed, creating new', { error });
+    }
+    return createEmptyHotCache(path);
+}
+/**
+ * Create empty hot cache
+ */
+function createEmptyHotCache(projectPath) {
+    return {
+        version: HOT_CACHE_VERSION,
+        projectPath,
+        entries: [],
+        lastUpdated: Date.now(),
+        staleEntries: [],
+    };
+}
+/**
+ * Identify stale entries (>7 days without enough references)
+ */
+function identifyStaleEntries(entries) {
+    const stale = [];
+    const now = Date.now();
+    for (const entry of entries) {
+        const daysSinceRef = (now - entry.lastReferencedAt) / (24 * 60 * 60 * 1000);
+        if (daysSinceRef > STALE_THRESHOLD_DAYS && entry.referenceCount < STALE_REFERENCE_COUNT) {
+            stale.push(entry.id);
+        }
+    }
+    return stale;
+}
+/**
+ * Save hot cache to disk
+ */
+export async function saveHotCache(cache) {
+    const cachePath = getHotCachePath(cache.projectPath);
+    try {
+        await ensureSquishDir(cache.projectPath);
+        writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+        cache.lastUpdated = Date.now();
+    }
+    catch (error) {
+        logger.error('[HotCache] Save failed', { error });
+    }
+}
+/**
+ * Add an entry to hot cache (with deduplication)
+ */
+export async function addToHotCache(content, options) {
+    const path = options?.projectPath || await getProjectPath();
+    if (!path) {
+        return createEmptyHotCache('');
+    }
+    const cache = await loadHotCache(path);
+    const contentHash = hashContent(content);
+    // Check for duplicate by hash
+    const existingIndex = cache.entries.findIndex(e => e.hash === contentHash);
+    if (existingIndex >= 0) {
+        // Update reference info for duplicate
+        cache.entries[existingIndex].lastReferencedAt = Date.now();
+        cache.entries[existingIndex].referenceCount++;
+        await saveHotCache(cache);
+        logger.debug('[HotCache] Updated existing entry reference', { hash: contentHash });
+        return cache;
+    }
+    // Add new entry
+    const newEntry = {
+        id: `hot-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        content: content.slice(0, 500), // Limit individual entry size
+        hash: contentHash,
+        createdAt: Date.now(),
+        lastReferencedAt: Date.now(),
+        referenceCount: 1,
+        tags: options?.tags,
+    };
+    cache.entries.push(newEntry);
+    // Trim if over max size (remove oldest entries)
+    if (cache.entries.length > MAX_HOT_CACHE_SIZE) {
+        cache.entries = cache.entries
+            .sort((a, b) => b.lastReferencedAt - a.lastReferencedAt)
+            .slice(0, MAX_HOT_CACHE_SIZE);
+    }
+    await saveHotCache(cache);
+    logger.info('[HotCache] Added new entry', { entries: cache.entries.length });
+    return cache;
+}
+/**
+ * Get hot cache summary for context
+ * Returns markdown-formatted summary of recent entries
+ */
+export async function getHotCacheSummary(options) {
+    const path = options?.projectPath || await getProjectPath();
+    if (!path)
+        return '';
+    const cache = await loadHotCache(path);
+    if (cache.entries.length === 0) {
+        return '## Hot Cache\n\nNo active hot memories yet.\n';
+    }
+    const maxEntries = options?.maxEntries || 10;
+    const recentEntries = cache.entries
+        .sort((a, b) => b.lastReferencedAt - a.lastReferencedAt)
+        .slice(0, maxEntries);
+    const lines = ['## Hot Cache\n'];
+    for (const entry of recentEntries) {
+        const date = new Date(entry.lastReferencedAt).toISOString().split('T')[0];
+        const stale = cache.staleEntries.includes(entry.id) ? ' [STALE]' : '';
+        lines.push(`- ${entry.content.slice(0, 100)}${entry.content.length > 100 ? '...' : ''}${stale} (${date})`);
+    }
+    if (cache.staleEntries.length > 0) {
+        lines.push(`\n* ${cache.staleEntries.length} entries flagged as stale (consider cleaning)*`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Reference an existing hot cache entry (prevents staleness)
+ */
+export async function referenceHotCacheEntry(entryId, projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return false;
+    const cache = await loadHotCache(path);
+    const entry = cache.entries.find(e => e.id === entryId);
+    if (entry) {
+        entry.lastReferencedAt = Date.now();
+        entry.referenceCount++;
+        await saveHotCache(cache);
+        return true;
+    }
+    return false;
+}
+/**
+ * Remove stale entries from hot cache
+ */
+export async function cleanStaleEntries(projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return 0;
+    const cache = await loadHotCache(path);
+    const staleIdSet = new Set(cache.staleEntries);
+    const originalCount = cache.entries.length;
+    cache.entries = cache.entries.filter(e => !staleIdSet.has(e.id));
+    cache.staleEntries = [];
+    await saveHotCache(cache);
+    const removed = originalCount - cache.entries.length;
+    logger.info('[HotCache] Cleaned stale entries', { removed });
+    return removed;
+}
+/**
+ * Add session context to hot cache
+ * Called from session hooks with key session information
+ */
+export async function addSessionContextToHotCache(sessionInfo, projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return createEmptyHotCache('');
+    // Build context entries from session info
+    const entries = [];
+    if (sessionInfo.activeFiles?.length) {
+        entries.push(`Active files: ${sessionInfo.activeFiles.join(', ')}`);
+    }
+    if (sessionInfo.commands?.length) {
+        entries.push(`Recent commands: ${sessionInfo.commands.slice(-3).join('; ')}`);
+    }
+    if (sessionInfo.failures?.length) {
+        entries.push(`Recent failures: ${sessionInfo.failures.slice(-2).join('; ')}`);
+    }
+    if (sessionInfo.decisions?.length) {
+        entries.push(`Decisions: ${sessionInfo.decisions.join('; ')}`);
+    }
+    if (sessionInfo.hypotheses?.length) {
+        entries.push(`Hypotheses: ${sessionInfo.hypotheses.slice(-2).join('; ')}`);
+    }
+    // Add each entry to hot cache
+    let cache = await loadHotCache(path);
+    for (const entry of entries) {
+        cache = await addToHotCache(entry, { projectPath: path });
+    }
+    return cache;
+}
+/**
+ * Get all hot cache entries (for advanced use)
+ */
+export async function getHotCacheEntries(projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return [];
+    const cache = await loadHotCache(path);
+    return cache.entries;
+}
+/**
+ * Clear hot cache (dangerous - use with caution)
+ */
+export async function clearHotCache(projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return;
+    const cache = createEmptyHotCache(path);
+    await saveHotCache(cache);
+    logger.info('[HotCache] Cleared');
+}
+/**
+ * Get hot cache statistics
+ */
+export async function getHotCacheStats(projectPath) {
+    const path = projectPath || await getProjectPath();
+    if (!path)
+        return { entries: 0, staleEntries: 0, oldestEntry: null, newestEntry: null };
+    const cache = await loadHotCache(path);
+    if (cache.entries.length === 0) {
+        return { entries: 0, staleEntries: 0, oldestEntry: null, newestEntry: null };
+    }
+    const timestamps = cache.entries.map(e => e.createdAt);
+    return {
+        entries: cache.entries.length,
+        staleEntries: cache.staleEntries.length,
+        oldestEntry: Math.min(...timestamps),
+        newestEntry: Math.max(...timestamps),
+    };
+}
+//# sourceMappingURL=hot-cache.js.map

package/dist/core/index.d.ts

@@ -1,10 +1,10 @@
-export * from './storage/cache.js';
-export * from './context/context.js';
-export * from './storage/database.js';
-export * from './embeddings.js';
-export * from './ingestion/learnings.js';
-export * from './security/privacy.js';
-export * from './projects.js';
-export * from './security/secret-detector.js';
-export * from './worker.js';
+export * from './storage/cache';
+export * from './context/context';
+export * from './storage/database';
+export * from './embeddings';
+export * from './ingestion/learnings';
+export * from './security/privacy';
+export * from './projects';
+export * from './security/secret-detector';
+export * from './worker';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,14 +1,11 @@
 // Shared services - Core utilities and services
-export * from './storage/cache.js';
-export * from './context/context.js';
-export * from './storage/database.js';
-export * from './embeddings.js';
-// Note: local-embeddings exports duplicate of embeddings, import directly when needed
-// export * from './local-embeddings.js';
-export * from './ingestion/learnings.js';
-export * from './security/privacy.js';
-export * from './projects.js';
-// Note: redis exports duplicates of cache, import directly when needed
-export * from './security/secret-detector.js';
-export * from './worker.js';
+export * from './storage/cache';
+export * from './context/context';
+export * from './storage/database';
+export * from './embeddings';
+export * from './ingestion/learnings';
+export * from './security/privacy';
+export * from './projects';
+export * from './security/secret-detector';
+export * from './worker';
 //# sourceMappingURL=index.js.map

package/dist/core/ingestion/core-memory.d.ts

@@ -68,11 +68,11 @@ export declare function getCoreMemoryStats(projectId: string): Promise<{
 }>;
 /**
  * Estimate token count from text (rough approximation: 1 token ≈ 4 chars)
+ * Import from context-window.ts - single source of truth
  */
-export declare function estimateTokens(text: string): number;
+export { estimateTokens } from '../context/context-window.js';
 /**
  * Get core memory formatted for context injection
  */
 export declare function formatCoreMemoryForInjection(projectId: string): Promise<string>;
-export {};
 //# sourceMappingURL=core-memory.d.ts.map

package/dist/core/ingestion/core-memory.js

@@ -9,6 +9,7 @@ import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { createDatabaseClient } from '../storage/database.js';
 import config from '../../config.js';
+import { estimateTokens } from '../context/context-window.js';
 // Use configurable limits from environment
 const MAX_TOTAL_SIZE_BYTES = config.coreMemoryTotalBytes;
 const MAX_SECTION_SIZE_BYTES = config.coreMemorySectionBytes;
@@ -188,10 +189,9 @@ export async function getCoreMemoryStats(projectId) {
 }
 /**
  * Estimate token count from text (rough approximation: 1 token ≈ 4 chars)
+ * Import from context-window.ts - single source of truth
  */
-export function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
+export { estimateTokens } from '../context/context-window.js';
 /**
  * Get core memory formatted for context injection
  */

package/dist/core/ingestion/learnings.js

@@ -13,6 +13,7 @@ import { logger } from '../logger.js';
 import { getDbClient } from '../lib/db-client.js';
 import { createAssociation } from '../associations.js';
 import { search } from '../memory/memories.js';
+import { updateAgentPreference } from '../agent-preferences.js';
 /**
  * Create a learning and optionally auto-link to similar memories/learnings
  */
@@ -53,6 +54,8 @@ export async function createLearning(input) {
     if (autoLink) {
         await autoLinkLearning(id, input.content, project?.id ?? null);
     }
+    // Extract and store agent preferences from this learning
+    await updateAgentPreference(project?.id ?? 'default', input.content, id);
     return {
         id,
         projectId: project?.id ?? null,

package/dist/core/ingestion/signal-engine.d.ts

@@ -0,0 +1,41 @@
+export type SignalClassification = 'discard' | 'session-only' | 'durable-distilled' | 'durable-raw+distilled';
+export interface SignalEventInput {
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    toolResult?: unknown;
+    sessionId?: string | null;
+}
+export interface SignalDecision {
+    classification: SignalClassification;
+    reasons: string[];
+    storeRaw: boolean;
+    importance: 'low' | 'medium' | 'high';
+    wakeUpPriority: 'low' | 'medium' | 'high';
+    placeHint: {
+        placeType: 'inbox' | 'ref' | 'wip' | 'sandbox' | 'board' | 'sparks' | 'archive' | null;
+        confidence: number;
+    };
+    graphHint: {
+        shouldEnrich: boolean;
+        entityTerms: string[];
+        reason?: string;
+    };
+    content: string;
+    contentHash: string;
+    estimatedSavings: number;
+}
+export interface DistillInput {
+    toolName: string;
+    command?: string;
+    content: string;
+    classification: SignalClassification;
+}
+export declare function hashSignalContent(content: string): string;
+export declare function classifySignalEvent(input: SignalEventInput): SignalDecision;
+export declare function distillSignalEvent(input: DistillInput): string;
+export declare function shouldReturnRawFallback(input: {
+    query: string;
+    hasRawFallback: boolean;
+    nuanceSuppressed: boolean;
+}): boolean;
+//# sourceMappingURL=signal-engine.d.ts.map

package/dist/core/ingestion/signal-engine.js

@@ -0,0 +1,201 @@
+import { createHash } from 'crypto';
+function normalizeContent(toolResult) {
+    if (typeof toolResult === 'string')
+        return toolResult;
+    if (toolResult == null)
+        return '';
+    if (typeof toolResult === 'object') {
+        try {
+            return JSON.stringify(toolResult, null, 2);
+        }
+        catch {
+            return String(toolResult);
+        }
+    }
+    return String(toolResult);
+}
+function estimateNoiseSavings(raw, distilled) {
+    return Math.max(0, raw.length - distilled.length);
+}
+function extractEntityTerms(content) {
+    const matches = content.match(/\b([A-Z][A-Za-z0-9]+|[a-z]+(?:\.[a-z0-9_-]+)+|[A-Za-z0-9_-]+\.ts)\b/g) ?? [];
+    return [...new Set(matches.filter((term) => term.length > 2))].slice(0, 6);
+}
+function inferPlaceHint(toolName, normalized) {
+    if (['write', 'edit', 'multiedit'].includes(toolName.toLowerCase()) || /\b(fix|bug|implement|refactor|edited|wrote)\b/.test(normalized)) {
+        return { placeType: 'wip', confidence: 0.88 };
+    }
+    if (/\b(test|assertionerror|traceback|exception|experiment|verify)\b/.test(normalized)) {
+        return { placeType: 'sandbox', confidence: 0.92 };
+    }
+    if (/\b(hypothesis|plan|decided|roadmap|task|todo|investigate)\b/.test(normalized)) {
+        return { placeType: 'board', confidence: 0.74 };
+    }
+    if (/\b(research|docs|pattern|reference|api|architecture)\b/.test(normalized)) {
+        return { placeType: 'ref', confidence: 0.72 };
+    }
+    if (/\b(idea|explore|future|concept)\b/.test(normalized)) {
+        return { placeType: 'sparks', confidence: 0.68 };
+    }
+    return { placeType: null, confidence: 0 };
+}
+function inferGraphHint(normalized, content, classification) {
+    if (classification === 'discard' || classification === 'session-only') {
+        return { shouldEnrich: false, entityTerms: [], reason: 'non-durable signal' };
+    }
+    const entityTerms = extractEntityTerms(content);
+    const hasStructuredSignal = entityTerms.length > 0 || /\b(fix|decision|preference|error|graph|ranking|entity|relationship)\b/.test(normalized);
+    if (!hasStructuredSignal) {
+        return { shouldEnrich: false, entityTerms: [], reason: 'no graph-worthy entities' };
+    }
+    return {
+        shouldEnrich: true,
+        entityTerms,
+        reason: 'durable signal with identifiable entities',
+    };
+}
+export function hashSignalContent(content) {
+    return createHash('sha1').update(content).digest('hex');
+}
+export function classifySignalEvent(input) {
+    const toolName = input.toolName;
+    const command = String(input.toolInput?.command ?? input.toolInput?.cmd ?? '');
+    const content = normalizeContent(input.toolResult);
+    const normalized = `${command}\n${content}`.toLowerCase();
+    const reasons = [];
+    const noisyCommand = /\b(npm|bun|pnpm|yarn)\s+(install|add)\b/.test(normalized) ||
+        /\bdownload(ed|ing)?\b|\bfetch(ed|ing)?\b|\bprogress\b|\bresolved\b/.test(normalized);
+    if (noisyCommand) {
+        const placeHint = inferPlaceHint(toolName, normalized);
+        reasons.push('noise filtered from install/build output');
+        return {
+            classification: 'discard',
+            reasons,
+            storeRaw: false,
+            importance: 'low',
+            wakeUpPriority: 'low',
+            placeHint,
+            graphHint: inferGraphHint(normalized, content, 'discard'),
+            content,
+            contentHash: hashSignalContent(normalized),
+            estimatedSavings: content.length,
+        };
+    }
+    if (/\b(current hypothesis|hypothesis:|investigate|trying next)\b/.test(normalized)) {
+        const placeHint = inferPlaceHint(toolName, normalized);
+        reasons.push('active session hypothesis');
+        return {
+            classification: 'session-only',
+            reasons,
+            storeRaw: false,
+            importance: 'medium',
+            wakeUpPriority: 'high',
+            placeHint,
+            graphHint: inferGraphHint(normalized, content, 'session-only'),
+            content,
+            contentHash: hashSignalContent(normalized),
+            estimatedSavings: 0,
+        };
+    }
+    if (/\bcorrection:|actually\b|\binstead of\b|\bprefer(s)?\b/.test(normalized)) {
+        const placeHint = inferPlaceHint(toolName, normalized);
+        reasons.push('correction or preference worth durable retention');
+        return {
+            classification: 'durable-distilled',
+            reasons,
+            storeRaw: false,
+            importance: 'high',
+            wakeUpPriority: 'high',
+            placeHint,
+            graphHint: inferGraphHint(normalized, content, 'durable-distilled'),
+            content,
+            contentHash: hashSignalContent(normalized),
+            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
+                toolName,
+                command,
+                content,
+                classification: 'durable-distilled',
+            })),
+        };
+    }
+    if (/\b(fail|failed|failing|assertionerror|stack trace|traceback|exception)\b/.test(normalized) ||
+        /\b(test|pytest|vitest|jest|bun test)\b/.test(normalized)) {
+        const placeHint = inferPlaceHint(toolName, normalized);
+        reasons.push('test or debugging signal with nuance-sensitive output');
+        return {
+            classification: 'durable-raw+distilled',
+            reasons,
+            storeRaw: true,
+            importance: 'high',
+            wakeUpPriority: 'high',
+            placeHint,
+            graphHint: inferGraphHint(normalized, content, 'durable-raw+distilled'),
+            content,
+            contentHash: hashSignalContent(normalized),
+            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
+                toolName,
+                command,
+                content,
+                classification: 'durable-raw+distilled',
+            })),
+        };
+    }
+    if (['write', 'edit', 'multiedit'].includes(toolName.toLowerCase())) {
+        const placeHint = inferPlaceHint(toolName, normalized);
+        reasons.push('meaningful file modification');
+        return {
+            classification: 'durable-distilled',
+            reasons,
+            storeRaw: false,
+            importance: 'medium',
+            wakeUpPriority: 'medium',
+            placeHint,
+            graphHint: inferGraphHint(normalized, content, 'durable-distilled'),
+            content,
+            contentHash: hashSignalContent(normalized),
+            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
+                toolName,
+                command,
+                content,
+                classification: 'durable-distilled',
+            })),
+        };
+    }
+    reasons.push('session-scoped operational context');
+    const placeHint = inferPlaceHint(toolName, normalized);
+    return {
+        classification: 'session-only',
+        reasons,
+        storeRaw: false,
+        importance: 'low',
+        wakeUpPriority: 'low',
+        placeHint,
+        graphHint: inferGraphHint(normalized, content, 'session-only'),
+        content,
+        contentHash: hashSignalContent(normalized),
+        estimatedSavings: 0,
+    };
+}
+export function distillSignalEvent(input) {
+    const lines = input.content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const important = lines.filter((line) => /\b(fail|error|exception|traceback|assert|stack|correction|prefer|decision|fix|edited|wrote)\b/i.test(line));
+    const selected = important.length > 0 ? important : lines.slice(0, 4);
+    const cleaned = selected.filter((line) => !/\b(pass(ing)?|resolved|download(ed|ing)?|progress|packages? added)\b/i.test(line));
+    if (/assertionerror|traceback|exception|stack/i.test(input.content) && !cleaned.some((line) => /assertionerror|traceback|exception|stack/i.test(line))) {
+        const extra = lines.find((line) => /assertionerror|traceback|exception|stack/i.test(line));
+        if (extra)
+            cleaned.push(extra);
+    }
+    return cleaned.slice(0, 6).join('\n');
+}
+export function shouldReturnRawFallback(input) {
+    if (!input.hasRawFallback)
+        return false;
+    if (input.nuanceSuppressed)
+        return true;
+    return /\b(raw|original|full|stack trace|traceback|stderr|stdout|rewind)\b/i.test(input.query);
+}
+//# sourceMappingURL=signal-engine.js.map

package/dist/core/{obsidian-vault.d.ts → integrations/obsidian-vault.d.ts}

@@ -24,7 +24,8 @@ export declare function appendToObsidianVault(memory: ObsidianMemoryInput, vault
  */
 export declare function isObsidianConnected(vaultPath: string): boolean;
 /**
- * Read existing memories from Obsidian vault (for future import feature)
+ * Read existing memories from Obsidian vault (for import feature)
+ * Scans vault for .md files and extracts memory blocks
  */
 export declare function readFromVault(vaultPath: string): Promise<ObsidianMemoryInput[]>;
 //# sourceMappingURL=obsidian-vault.d.ts.map