squish-memory 1.0.2 → 1.2.0

package/dist/core/hooks/capture-filter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Capture Filter - Smart filtering of tool usage
+ *
+ * Don't capture everything - filter out noise.
+ * Only capture meaningful actions that warrant memory.
+ */
+/** Tool categories for capture */
+export type ToolCategory = 'reading' | 'modification' | 'command' | 'commit' | 'testing' | 'search' | 'planning' | 'other';
+/** Capture decision */
+export interface CaptureDecision {
+    shouldCapture: boolean;
+    reason?: string;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Check if a tool should be captured
+ *
+ * Rules:
+ * - Write, Edit, MultiEdit → capture (modification)
+ * - Bash with commit → capture (commit)
+ * - Bash with test → capture (testing)
+ * - Task → capture (planning)
+ * - Read, Glob, grep → skip (reading - too noisy)
+ */
+export declare function shouldCaptureTool(toolName: string): boolean;
+/**
+ * Get detailed capture decision
+ */
+export declare function getCaptureDecision(toolName: string): CaptureDecision;
+/**
+ * Check if Bash command should be captured based on content
+ */
+export declare function shouldCaptureBashCommand(command: string): {
+    capture: boolean;
+    reason: string;
+};
+/**
+ * Categorize tool for tagging
+ */
+export declare function categorizeTool(toolName: string): ToolCategory;
+//# sourceMappingURL=capture-filter.d.ts.map

package/dist/core/hooks/capture-filter.js

@@ -0,0 +1,128 @@
+/**
+ * Capture Filter - Smart filtering of tool usage
+ *
+ * Don't capture everything - filter out noise.
+ * Only capture meaningful actions that warrant memory.
+ */
+/**
+ * Check if a tool should be captured
+ *
+ * Rules:
+ * - Write, Edit, MultiEdit → capture (modification)
+ * - Bash with commit → capture (commit)
+ * - Bash with test → capture (testing)
+ * - Task → capture (planning)
+ * - Read, Glob, grep → skip (reading - too noisy)
+ */
+export function shouldCaptureTool(toolName) {
+    const decision = getCaptureDecision(toolName);
+    return decision.shouldCapture;
+}
+/**
+ * Get detailed capture decision
+ */
+export function getCaptureDecision(toolName) {
+    const tool = toolName.toLowerCase();
+    // High priority - always capture
+    if (['write', 'edit', 'multiedit'].includes(tool)) {
+        return {
+            shouldCapture: true,
+            reason: 'File modification',
+            priority: 'high',
+        };
+    }
+    // Command with specific patterns
+    if (tool === 'bash') {
+        // Let the caller check the command for commit/test patterns
+        return {
+            shouldCapture: true, // Will be filtered by content check
+            reason: 'Command execution',
+            priority: 'medium',
+        };
+    }
+    // Task operations
+    if (['task', 'todowrite'].includes(tool)) {
+        return {
+            shouldCapture: true,
+            reason: 'Task/planning activity',
+            priority: 'high',
+        };
+    }
+    // Skip noisy tools
+    if (['read', 'glob', 'grep', 'websearch', 'webfetch', 'codesearch'].includes(tool)) {
+        return {
+            shouldCapture: false,
+            reason: 'Reading/search tool - too noisy',
+            priority: 'low',
+        };
+    }
+    // Skip other common noise
+    if (['bash'].includes(tool)) {
+        return {
+            shouldCapture: false, // Too noisy without filtering
+            reason: 'General command - filtered',
+            priority: 'low',
+        };
+    }
+    // Default: don't capture unknown tools
+    return {
+        shouldCapture: false,
+        reason: 'Unknown tool',
+        priority: 'low',
+    };
+}
+/**
+ * Check if Bash command should be captured based on content
+ */
+export function shouldCaptureBashCommand(command) {
+    const cmd = command.toLowerCase();
+    // Git commits - HIGH priority
+    if (cmd.includes('git commit') || cmd.includes('git add') && cmd.includes('git commit')) {
+        return { capture: true, reason: 'Git commit' };
+    }
+    // Tests - HIGH priority
+    if (cmd.includes('test') || cmd.includes('jest') || cmd.includes('vitest') ||
+        cmd.includes('pytest') || cmd.includes('bun test')) {
+        return { capture: true, reason: 'Test execution' };
+    }
+    // Build/compile - MEDIUM priority
+    if (cmd.includes('build') || cmd.includes('compile') || cmd.includes('tsc') ||
+        cmd.includes('bun build') || cmd.includes('npm run build')) {
+        return { capture: true, reason: 'Build/compile' };
+    }
+    // Installation - LOW priority
+    if (cmd.includes('npm install') || cmd.includes('bun install') ||
+        cmd.includes('pip install') || cmd.includes('yarn add')) {
+        return { capture: false, reason: 'Package installation - too noisy' };
+    }
+    // Git operations (non-commit) - LOW priority
+    if (cmd.includes('git') && !cmd.includes('commit')) {
+        return { capture: false, reason: 'Git operations - not commits' };
+    }
+    // File operations - MEDIUM priority
+    if (cmd.includes('mkdir') || cmd.includes('touch') || cmd.includes('rm ')) {
+        return { capture: true, reason: 'File operation' };
+    }
+    // Default - don't capture
+    return { capture: false, reason: 'General command' };
+}
+/**
+ * Categorize tool for tagging
+ */
+export function categorizeTool(toolName) {
+    const tool = toolName.toLowerCase();
+    if (['write', 'edit', 'multiedit'].includes(tool)) {
+        return 'modification';
+    }
+    if (tool === 'bash') {
+        return 'command';
+    }
+    if (['read', 'glob', 'grep', 'websearch', 'webfetch'].includes(tool)) {
+        return 'reading';
+    }
+    if (['task', 'todowrite', 'todo-read'].includes(tool)) {
+        return 'planning';
+    }
+    return 'other';
+}
+//# sourceMappingURL=capture-filter.js.map

package/dist/core/hot-cache.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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
+ */
+export interface HotCacheEntry {
+    id: string;
+    content: string;
+    hash: string;
+    createdAt: number;
+    lastReferencedAt: number;
+    referenceCount: number;
+    tags?: string[];
+}
+export interface HotCache {
+    version: string;
+    projectPath: string;
+    entries: HotCacheEntry[];
+    lastUpdated: number;
+    staleEntries: string[];
+}
+/**
+ * Load hot cache from disk (or create new)
+ */
+export declare function loadHotCache(projectPath?: string): Promise<HotCache>;
+/**
+ * Save hot cache to disk
+ */
+export declare function saveHotCache(cache: HotCache): Promise<void>;
+/**
+ * Add an entry to hot cache (with deduplication)
+ */
+export declare function addToHotCache(content: string, options?: {
+    projectPath?: string;
+    tags?: string[];
+    reference?: boolean;
+}): Promise<HotCache>;
+/**
+ * Get hot cache summary for context
+ * Returns markdown-formatted summary of recent entries
+ */
+export declare function getHotCacheSummary(options?: {
+    projectPath?: string;
+    maxEntries?: number;
+}): Promise<string>;
+/**
+ * Reference an existing hot cache entry (prevents staleness)
+ */
+export declare function referenceHotCacheEntry(entryId: string, projectPath?: string): Promise<boolean>;
+/**
+ * Remove stale entries from hot cache
+ */
+export declare function cleanStaleEntries(projectPath?: string): Promise<number>;
+/**
+ * Add session context to hot cache
+ * Called from session hooks with key session information
+ */
+export declare function addSessionContextToHotCache(sessionInfo: {
+    activeFiles?: string[];
+    commands?: string[];
+    failures?: string[];
+    decisions?: string[];
+    hypotheses?: string[];
+}, projectPath?: string): Promise<HotCache>;
+/**
+ * Get all hot cache entries (for advanced use)
+ */
+export declare function getHotCacheEntries(projectPath?: string): Promise<HotCacheEntry[]>;
+/**
+ * Clear hot cache (dangerous - use with caution)
+ */
+export declare function clearHotCache(projectPath?: string): Promise<void>;
+/**
+ * Get hot cache statistics
+ */
+export declare function getHotCacheStats(projectPath?: string): Promise<{
+    entries: number;
+    staleEntries: number;
+    oldestEntry: number | null;
+    newestEntry: number | null;
+}>;
+//# sourceMappingURL=hot-cache.d.ts.map

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 './cache.js';
-export * from './context.js';
-export * from './database.js';
-export * from './embeddings.js';
-export * from './observations.js';
-export * from './privacy.js';
-export * from './projects.js';
-export * from './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 './cache.js';
-export * from './context.js';
-export * from './database.js';
-export * from './embeddings.js';
-// Note: local-embeddings exports duplicate of embeddings, import directly when needed
-// export * from './local-embeddings.js';
-export * from './observations.js';
-export * from './privacy.js';
-export * from './projects.js';
-// Note: redis exports duplicates of cache, import directly when needed
-export * from './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/{agent-memory.js → ingestion/agent-memory.js}

@@ -4,11 +4,11 @@
  */
 import { and, eq } from 'drizzle-orm';
 import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { config } from '../config.js';
-import { getEmbedding } from './embeddings.js';
-import { logger } from './logger.js';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { config } from '../../config.js';
+import { getEmbedding } from '../embeddings.js';
+import { logger } from '../logger.js';
 /**
  * Store a memory with agent context
  */
@@ -53,9 +53,7 @@ export async function storeAgentMemory(content, context, options = {}) {
         throw error;
     }
 }
-// ============================================================================
 // Helper Functions
-// ============================================================================
 function calculateReadScope(context, visibility) {
     switch (visibility) {
         case 'private':

package/dist/core/{core-memory.d.ts → 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/{core-memory.js → ingestion/core-memory.js}

@@ -5,10 +5,11 @@
  * This memory is automatically injected into every agent interaction.
  */
 import { eq, and, sql } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { createDatabaseClient } from './database.js';
-import config from '../config.js';
+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
  */