squish-memory 1.2.0 → 1.2.1

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

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

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

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

@@ -1,285 +0,0 @@
-/**
- * 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 +0,0 @@
-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,11 +0,0 @@
-// Shared services - Core utilities and services
-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/agent-memory.d.ts

@@ -1,22 +0,0 @@
-/**
- * Agent-Aware Memory Management
- * Provides agent isolation and visibility rules
- */
-export type VisibilityScope = 'private' | 'project' | 'team' | 'global';
-export interface AgentContext {
-    agentId: string;
-    agentRole?: string;
-    userId?: string;
-    projectId?: string;
-}
-/**
- * Store a memory with agent context
- */
-export declare function storeAgentMemory(content: string, context: AgentContext, options?: {
-    type?: string;
-    sector?: string;
-    visibilityScope?: VisibilityScope;
-    tags?: string[];
-    metadata?: Record<string, unknown>;
-}): Promise<string>;
-//# sourceMappingURL=agent-memory.d.ts.map

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

@@ -1,109 +0,0 @@
-/**
- * Agent-Aware Memory Management
- * Provides agent isolation and visibility rules
- */
-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';
-/**
- * Store a memory with agent context
- */
-export async function storeAgentMemory(content, context, options = {}) {
-    if (!config.agentIsolationEnabled) {
-        // Fall back to standard memory storage
-        return await storeStandardMemory(content, options);
-    }
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memoryId = randomUUID();
-        const embedding = await getEmbedding(content);
-        const visibilityScope = options.visibilityScope || config.defaultVisibilityScope;
-        // Determine scopes based on visibility
-        const readScope = calculateReadScope(context, visibilityScope);
-        const writeScope = [`agent:${context.agentId}`];
-        await db.insert(schema.memories).values({
-            id: memoryId,
-            content,
-            type: options.type || 'observation',
-            sector: options.sector || 'episodic',
-            agentId: context.agentId,
-            agentRole: context.agentRole || 'general',
-            userId: context.userId || null,
-            projectId: context.projectId || null,
-            visibilityScope,
-            writeScope,
-            readScope,
-            tags: options.tags || [],
-            metadata: options.metadata || null,
-            embedding: embedding || null,
-            confidence: 100,
-            relevanceScore: 50,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        });
-        return memoryId;
-    }
-    catch (error) {
-        logger.error('Error storing agent memory', error);
-        throw error;
-    }
-}
-// Helper Functions
-function calculateReadScope(context, visibility) {
-    switch (visibility) {
-        case 'private':
-            return [`agent:${context.agentId}`];
-        case 'project':
-            return [`agent:${context.agentId}`, `project:${context.projectId || '*'}`];
-        case 'team':
-            return [`agent:${context.agentId}`, 'team:*'];
-        case 'global':
-            return ['*'];
-        default:
-            return [`agent:${context.agentId}`];
-    }
-}
-async function storeStandardMemory(content, options = {}) {
-    // Fallback to standard memory storage if agent isolation is disabled
-    const db = await getDb();
-    const schema = await getSchema();
-    const memoryId = randomUUID();
-    const embedding = await getEmbedding(content);
-    await db.insert(schema.memories).values({
-        id: memoryId,
-        content,
-        type: options.type || 'observation',
-        sector: options.sector || 'episodic',
-        tags: options.tags || [],
-        metadata: options.metadata || null,
-        embedding: embedding || null,
-        confidence: 100,
-        relevanceScore: 50,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    });
-    return memoryId;
-}
-async function searchStandardMemories(query, options = {}) {
-    // Fallback to standard memory search if agent isolation is disabled
-    const db = await getDb();
-    const schema = await getSchema();
-    const limit = Math.min(options.limit || 10, 100);
-    let where = undefined;
-    if (options.type) {
-        where = eq(schema.memories.type, options.type);
-    }
-    return await db
-        .select()
-        .from(schema.memories)
-        .where(where
-        ? and(where, schema.memories.content.ilike(`%${query}%`))
-        : schema.memories.content.ilike(`%${query}%`))
-        .limit(limit);
-}
-//# sourceMappingURL=agent-memory.js.map