squish-memory 1.1.5 → 1.2.1

package/dist/core/hooks/agent-hooks.js

@@ -1,244 +0,0 @@
-/**
- * Agent Hooks - Core Logic
- *
- * Universal hooks for auto-capturing agent activities.
- * Works with Claude Code, OpenCode, Cursor, Windsurf.
- *
- * Hook events:
- * - sessionStart: Inject relevant memories on session start
- * - postToolUse: Record observations after tool execution
- * - sessionEnd: Save snapshot and sync learnings
- * - preCompact: Save state before context compaction
- */
-import { randomUUID } from 'crypto';
-import { createLearning } from '../ingestion/learnings.js';
-import { getRecent } from '../memory/memories.js';
-import { logger } from '../logger.js';
-import { shouldCaptureTool, categorizeTool } from './capture-filter.js';
-import { inferTags } from './auto-tagger.js';
-import { ensureProject, getProjectByPath } from '../projects.js';
-import { autoAssignMemory, initializeDefaultPlaces } from '../places/index.js';
-/** Session ID for tracking across agents */
-let currentSessionId = null;
-/**
- * Generate a new session ID (universal across agents)
- */
-export function generateSessionId() {
-    currentSessionId = randomUUID();
-    return currentSessionId;
-}
-/**
- * Get current session ID
- */
-export function getCurrentSessionId() {
-    return currentSessionId;
-}
-/**
- * Set session ID (for resume/continue)
- */
-export function setSessionId(sessionId) {
-    currentSessionId = sessionId;
-}
-/**
- * Session start hook - inject relevant context
- */
-export async function handleSessionStart(params) {
-    const { projectPath, mode, agentType } = params;
-    // Ensure project exists
-    await ensureProject(projectPath);
-    // Generate or get session ID
-    if (!currentSessionId) {
-        currentSessionId = generateSessionId();
-    }
-    logger.info(`[Hooks] Session start: ${mode} (agent: ${agentType}, session: ${currentSessionId})`);
-    // Get recent memories based on mode
-    const limit = mode === 'compact' ? 3 : 5;
-    const memories = await getRecent(projectPath, limit);
-    // Get spatial memory context (places) for context injection
-    let placesContext = '';
-    try {
-        const { initializeDefaultPlaces, getProjectPlaces } = await import('../places/index.js');
-        const { getProjectByPath } = await import('../projects.js');
-        const project = await getProjectByPath(projectPath);
-        if (project) {
-            await initializeDefaultPlaces(project.id);
-            const places = await getProjectPlaces(project.id);
-            if (places.length > 0) {
-                const populatedPlaces = places.filter(p => p.memoryCount > 0).slice(0, 3);
-                if (populatedPlaces.length > 0) {
-                    placesContext = '\n\nActive places: ' + populatedPlaces.map(p => `${p.name} (${p.memoryCount})`).join(', ');
-                }
-            }
-        }
-    }
-    catch (e) {
-        // Don't fail if places not available
-        logger.debug(`[Hooks] Places context not available: ${e}`);
-    }
-    // Format for injection
-    const formatted = memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}...`).join('\n');
-    const allContent = formatted + placesContext;
-    logger.info(`[Hooks] Injected ${memories.length} memories for session start`);
-    return {
-        memories: allContent ? allContent.split('\n') : [],
-        sessionId: currentSessionId,
-        count: memories.length,
-    };
-}
-/**
- * Post-tool-use hook - record observations
- */
-export async function handlePostToolUse(params) {
-    const { toolName, toolInput, toolResult, projectPath, agentType } = params;
-    // Ensure project exists
-    await ensureProject(projectPath);
-    // Ensure session ID exists
-    if (!currentSessionId) {
-        currentSessionId = generateSessionId();
-    }
-    // Check if we should capture this tool
-    if (!shouldCaptureTool(toolName)) {
-        return { captured: false, reason: `Tool ${toolName} filtered out` };
-    }
-    // Extract relevant information
-    const category = categorizeTool(toolName);
-    const target = extractTarget(toolName, toolInput);
-    const content = extractContent(toolName, toolInput, toolResult);
-    // Infer tags from context
-    const tags = inferTags(toolName, toolInput, content);
-    // Create learning/observation
-    const learningInput = {
-        type: 'insight',
-        content: `[${category}] ${content}`,
-        action: toolName,
-        target,
-        project: projectPath,
-        autoLink: true,
-    };
-    try {
-        const learning = await createLearning(learningInput);
-        logger.info(`[Hooks] Captured ${toolName} → ${learning.id} (session: ${currentSessionId})`);
-        // Auto-assign to place (if places are initialized)
-        try {
-            const project = await getProjectByPath(projectPath);
-            if (project) {
-                // Initialize default places if they don't exist
-                await initializeDefaultPlaces(project.id);
-                // Auto-assign the memory to a place
-                await autoAssignMemory({
-                    memoryId: learning.id,
-                    projectId: project.id,
-                    toolName,
-                    content: learningInput.content,
-                    tags,
-                });
-            }
-        }
-        catch (placeError) {
-            // Don't fail the hook if place assignment fails
-            logger.warn(`[Hooks] Place assignment failed: ${placeError}`);
-        }
-        return {
-            captured: true,
-            memoryId: learning.id,
-        };
-    }
-    catch (error) {
-        logger.error(`[Hooks] Failed to capture:`, error);
-        return { captured: false, reason: 'Failed to create learning' };
-    }
-}
-/**
- * Session end hook - save snapshot and sync
- */
-export async function handleSessionEnd(params) {
-    const { projectPath, agentType, workInProgress } = params;
-    // Ensure project exists
-    await ensureProject(projectPath);
-    logger.info(`[Hooks] Session end (agent: ${agentType}, session: ${currentSessionId})`);
-    // Save session snapshot as a learning
-    if (workInProgress) {
-        const snapshot = await createLearning({
-            type: 'insight',
-            content: `[SESSION SNAPSHOT] ${workInProgress}`,
-            action: 'session-end',
-            project: projectPath,
-            autoLink: false,
-        });
-        logger.info(`[Hooks] Saved session snapshot: ${snapshot.id}`);
-        currentSessionId = null; // Clear session
-        return {
-            snapshotId: snapshot.id,
-            memoriesSaved: 1,
-        };
-    }
-    currentSessionId = null;
-    return {
-        memoriesSaved: 0,
-    };
-}
-/**
- * Pre-compact hook - save state for recovery
- */
-export async function handlePreCompact(params) {
-    const { projectPath, agentType } = params;
-    // Ensure project exists
-    await ensureProject(projectPath);
-    logger.info(`[Hooks] Pre-compact (agent: ${agentType})`);
-    // Get recent work for recovery
-    const recent = await getRecent(projectPath, 3);
-    // Save state
-    const state = await createLearning({
-        type: 'insight',
-        content: `[PRE-COMPACT] State saved for recovery. Recent: ${recent.map(r => r.content?.substring(0, 50)).join(' | ')}`,
-        action: 'pre-compact',
-        project: projectPath,
-        autoLink: false,
-    });
-    return {
-        stateSaved: true,
-        stateId: state.id,
-    };
-}
-/**
- * Extract target from tool input
- */
-function extractTarget(toolName, toolInput) {
-    switch (toolName) {
-        case 'Write':
-        case 'Edit':
-            return String(toolInput.filePath || toolInput.path || 'unknown');
-        case 'Bash':
-            return String(toolInput.command || toolInput.cmd || 'unknown');
-        case 'Task':
-            return String(toolInput.description || toolInput.name || 'unknown');
-        default:
-            return 'unknown';
-    }
-}
-/**
- * Extract content summary from tool result
- */
-function extractContent(toolName, toolInput, toolResult) {
-    switch (toolName) {
-        case 'Write':
-            return `Wrote: ${toolInput.filePath || toolInput.path}`;
-        case 'Edit':
-            return `Edited: ${toolInput.filePath || toolInput.path}`;
-        case 'Bash':
-            const cmd = String(toolInput.command || toolInput.cmd || '');
-            if (cmd.includes('commit'))
-                return `Git commit executed`;
-            if (cmd.includes('test'))
-                return `Tests run`;
-            return `Command: ${cmd.substring(0, 50)}`;
-        case 'Task':
-            return `Task: ${toolInput.description || toolInput.name || 'unknown'}`;
-        default:
-            return `Used: ${toolName}`;
-    }
-}
-// Re-export for convenience
-export { shouldCaptureTool, categorizeTool } from './capture-filter.js';
-export { inferTags } from './auto-tagger.js';
-//# sourceMappingURL=agent-hooks.js.map

package/dist/core/hooks/auto-tagger.d.ts

@@ -1,19 +0,0 @@
-/**
- * Auto-Tagger - Infer tags from context
- *
- * Analyzes tool input/output to automatically infer relevant tags.
- * Uses pattern matching to classify actions.
- */
-/**
- * Infer tags based on tool, input, and content
- */
-export declare function inferTags(toolName: string, toolInput: Record<string, unknown>, content: string): string[];
-/**
- * Extract tags from commit message
- */
-export declare function extractCommitTags(commitMessage: string): string[];
-/**
- * Extract tags from file path
- */
-export declare function extractFileTags(filePath: string): string[];
-//# sourceMappingURL=auto-tagger.d.ts.map

package/dist/core/hooks/auto-tagger.js

@@ -1,155 +0,0 @@
-/**
- * Auto-Tagger - Infer tags from context
- *
- * Analyzes tool input/output to automatically infer relevant tags.
- * Uses pattern matching to classify actions.
- */
-/**
- * Infer tags based on tool, input, and content
- */
-export function inferTags(toolName, toolInput, content) {
-    const tags = ['hook', 'autocapture']; // Always add these
-    const tool = toolName.toLowerCase();
-    const inputStr = JSON.stringify(toolInput).toLowerCase();
-    const contentLower = content.toLowerCase();
-    // File type tags
-    if (tool === 'write' || tool === 'edit') {
-        const filePath = String(toolInput.filePath || toolInput.path || '');
-        if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
-            tags.push('typescript');
-        }
-        else if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-            tags.push('javascript');
-        }
-        else if (filePath.endsWith('.json')) {
-            tags.push('config');
-        }
-        else if (filePath.endsWith('.md')) {
-            tags.push('documentation');
-        }
-        else if (filePath.endsWith('.test.ts') || filePath.endsWith('.spec.ts')) {
-            tags.push('test');
-        }
-        // Feature/fix detection
-        if (contentLower.includes('fix') || contentLower.includes('bug')) {
-            tags.push('bugfix');
-        }
-        else if (contentLower.includes('refactor')) {
-            tags.push('refactor');
-        }
-        else if (contentLower.includes('feature') || contentLower.includes('add')) {
-            tags.push('feature');
-        }
-        else if (contentLower.includes('test')) {
-            tags.push('testing');
-        }
-    }
-    // Bash command tags
-    if (tool === 'bash') {
-        const cmd = String(toolInput.command || toolInput.cmd || '');
-        if (cmd.includes('git commit')) {
-            tags.push('commit', 'version-control');
-        }
-        else if (cmd.includes('test') || cmd.includes('jest') || cmd.includes('vitest')) {
-            tags.push('testing', 'test');
-        }
-        else if (cmd.includes('build') || cmd.includes('compile')) {
-            tags.push('build');
-        }
-        else if (cmd.includes('install')) {
-            tags.push('dependencies');
-        }
-        else if (cmd.includes('lint') || cmd.includes('format')) {
-            tags.push('linting');
-        }
-    }
-    // Task tags
-    if (tool === 'task' || tool === 'todowrite') {
-        tags.push('task', 'planning');
-        if (contentLower.includes('fix') || contentLower.includes('bug')) {
-            tags.push('bugfix');
-        }
-        else if (contentLower.includes('feature')) {
-            tags.push('feature');
-        }
-        else if (contentLower.includes('refactor')) {
-            tags.push('refactor');
-        }
-    }
-    // Deduplicate
-    return [...new Set(tags)];
-}
-/**
- * Extract tags from commit message
- */
-export function extractCommitTags(commitMessage) {
-    const tags = ['commit'];
-    const msg = commitMessage.toLowerCase();
-    // Conventional commits
-    if (msg.startsWith('feat:') || msg.includes('feature')) {
-        tags.push('feature', 'conventional-commit');
-    }
-    else if (msg.startsWith('fix:') || msg.includes('bugfix')) {
-        tags.push('bugfix', 'conventional-commit');
-    }
-    else if (msg.startsWith('refactor:')) {
-        tags.push('refactor', 'conventional-commit');
-    }
-    else if (msg.startsWith('docs:')) {
-        tags.push('documentation', 'conventional-commit');
-    }
-    else if (msg.startsWith('test:')) {
-        tags.push('testing', 'conventional-commit');
-    }
-    else if (msg.startsWith('chore:')) {
-        tags.push('chore', 'conventional-commit');
-    }
-    return tags;
-}
-/**
- * Extract tags from file path
- */
-export function extractFileTags(filePath) {
-    const tags = [];
-    const path = filePath.toLowerCase();
-    // By extension
-    if (path.endsWith('.ts') || path.endsWith('.tsx')) {
-        tags.push('typescript');
-    }
-    else if (path.endsWith('.js') || path.endsWith('.jsx')) {
-        tags.push('javascript');
-    }
-    else if (path.endsWith('.py')) {
-        tags.push('python');
-    }
-    else if (path.endsWith('.go')) {
-        tags.push('golang');
-    }
-    else if (path.endsWith('.rs')) {
-        tags.push('rust');
-    }
-    else if (path.endsWith('.java')) {
-        tags.push('java');
-    }
-    else if (path.endsWith('.json')) {
-        tags.push('config');
-    }
-    else if (path.endsWith('.md')) {
-        tags.push('documentation');
-    }
-    // By directory pattern
-    if (path.includes('/test') || path.includes('/tests') || path.includes('__tests__')) {
-        tags.push('test');
-    }
-    else if (path.includes('/src/')) {
-        tags.push('source');
-    }
-    else if (path.includes('/lib/') || path.includes('/utils/')) {
-        tags.push('library');
-    }
-    else if (path.includes('/config/') || path.includes('/scripts/')) {
-        tags.push('config');
-    }
-    return tags;
-}
-//# sourceMappingURL=auto-tagger.js.map

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/index.d.ts

@@ -1,10 +0,0 @@
-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';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,14 +0,0 @@
-// 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';
-//# 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