squish-memory 1.0.2 → 1.1.5

package/dist/core/external-folder/index.js

@@ -0,0 +1,294 @@
+/**
+ * External Folder Memory Manager
+ *
+ * Wraps QMD to treat an external folder as a secondary memory layer.
+ * - Writes hot memories to daily notes (YYYY-MM-DD.md) with frontmatter
+ * - Uses QMD to search both Squish DB and external folder
+ * - Auto-indexes on mount and write
+ *
+ * Usage:
+ *   squish mount /path/to/folder    # Enable external memory
+ *   squish mount status             # Show status
+ *   squish mount unmount            # Disable
+ */
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+import { logger } from '../logger.js';
+import { config } from '../../config.js';
+/**
+ * Format a memory as markdown with YAML frontmatter
+ */
+function formatMemoryAsMarkdown(memory) {
+    const frontmatter = [
+        '---',
+        `id: ${memory.id}`,
+        `type: ${memory.type}`,
+        `tags: [${memory.tags.join(', ')}]`,
+        `created: ${memory.createdAt}`,
+    ];
+    if (memory.confidence) {
+        frontmatter.push(`confidence: ${memory.confidence}`);
+    }
+    if (memory.projectId) {
+        frontmatter.push(`project: ${memory.projectId}`);
+    }
+    frontmatter.push('---', '', memory.content);
+    return frontmatter.join('\n');
+}
+/**
+ * Get the daily note filename for a given date
+ */
+function getDailyNotePath(folderPath, date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return join(folderPath, `${year}-${month}-${day}.md`);
+}
+/**
+ * Get today's date string
+ */
+function getTodayDateStr() {
+    const today = new Date();
+    const year = today.getFullYear();
+    const month = String(today.getMonth() + 1).padStart(2, '0');
+    const day = String(today.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+/**
+ * External Folder Memory Manager class
+ */
+export class ExternalFolderMemory {
+    mountedPath = null;
+    /**
+     * Check if external memory is enabled and mounted
+     */
+    isEnabled() {
+        return config.externalMemoryEnabled && !!config.externalMemoryPath;
+    }
+    /**
+     * Get the mounted path
+     */
+    getPath() {
+        return this.isEnabled() ? config.externalMemoryPath : null;
+    }
+    /**
+     * Mount external memory at a path
+     * Creates folder if needed, initializes structure
+     */
+    async mount(path) {
+        if (!path) {
+            return { success: false, error: 'Path is required' };
+        }
+        // Resolve to absolute path
+        const absolutePath = join(process.cwd(), path);
+        // Security: validate path doesn't escape cwd (prevent path traversal)
+        const resolvedPath = absolutePath.split(/[\\/]/).join('/');
+        const cwdPath = process.cwd().split(/[\\/]/).join('/');
+        if (!resolvedPath.startsWith(cwdPath + '/') && resolvedPath !== cwdPath) {
+            return { success: false, error: 'Path traversal not allowed' };
+        }
+        // Create folder if it doesn't exist
+        if (!existsSync(absolutePath)) {
+            try {
+                mkdirSync(absolutePath, { recursive: true });
+                logger.info(`[ExternalMemory] Created folder: ${absolutePath}`);
+            }
+            catch (error) {
+                return { success: false, error: `Failed to create folder: ${error}` };
+            }
+        }
+        // Initialize QMD index for this folder
+        const indexed = await this.ensureIndexed(absolutePath);
+        if (!indexed) {
+            logger.warn('[ExternalMemory] QMD not found or indexing failed. Install with: bun install -g qmd');
+        }
+        this.mountedPath = absolutePath;
+        logger.info(`[ExternalMemory] Mounted at: ${absolutePath}`);
+        return { success: true };
+    }
+    /**
+     * Unmount external memory
+     */
+    unmount() {
+        this.mountedPath = null;
+        logger.info('[ExternalMemory] Unmounted');
+        return { success: true };
+    }
+    /**
+     * Ensure QMD indexes the external folder
+     */
+    async ensureIndexed(folderPath) {
+        const targetPath = folderPath || this.getPath();
+        if (!targetPath) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            // Run qmd add to index the folder
+            const process = spawn('qmd', ['add', targetPath], {
+                stdio: 'ignore'
+            });
+            process.on('close', (code) => {
+                if (code === 0) {
+                    logger.info(`[ExternalMemory] Indexed folder: ${targetPath}`);
+                    resolve(true);
+                }
+                else {
+                    logger.warn(`[ExternalMemory] QMD add failed with code: ${code}`);
+                    resolve(false);
+                }
+            });
+            process.on('error', (error) => {
+                logger.warn(`[ExternalMemory] QMD add error: ${error}`);
+                resolve(false);
+            });
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                process.kill();
+                resolve(false);
+            }, 30000);
+        });
+    }
+    /**
+     * Write a memory to the external folder (daily note)
+     */
+    async writeMemory(memory) {
+        const folderPath = this.getPath();
+        if (!folderPath) {
+            return { success: false, error: 'External memory not enabled' };
+        }
+        try {
+            const date = memory.createdAt ? new Date(memory.createdAt) : new Date();
+            const dailyNotePath = getDailyNotePath(folderPath, date);
+            const dateStr = getTodayDateStr();
+            // Build memory block content
+            const memoryBlock = formatMemoryAsMarkdown(memory);
+            // Check if daily note exists, if not create with header
+            if (!existsSync(dailyNotePath)) {
+                const header = `# ${dateStr}\n\n## Squish Memories\n\n---\n\n`;
+                appendFileSync(dailyNotePath, header, 'utf-8');
+                logger.info(`[ExternalMemory] Created daily note: ${dailyNotePath}`);
+            }
+            // Append memory block with separator
+            appendFileSync(dailyNotePath, '\n---\n\n' + memoryBlock + '\n', 'utf-8');
+            logger.info(`[ExternalMemory] Wrote memory ${memory.id} to ${dateStr}.md`);
+            // Trigger QMD re-index (background)
+            this.triggerReindex().catch(() => { });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.error(`[ExternalMemory] Write failed: ${errorMsg}`);
+            return { success: false, error: errorMsg };
+        }
+    }
+    /**
+     * Trigger background re-index via QMD
+     */
+    async triggerReindex() {
+        const folderPath = this.getPath();
+        if (!folderPath)
+            return;
+        // Run qmd in background to re-index
+        spawn('qmd', ['add', folderPath], {
+            stdio: 'ignore',
+            detached: true
+        });
+    }
+    /**
+     * Get current status of external memory
+     */
+    async getStatus() {
+        const path = this.getPath();
+        if (!path || !existsSync(path)) {
+            return {
+                mounted: false,
+                path: null,
+                qmdIndexed: false,
+                memoryCount: 0,
+                lastIndexed: null
+            };
+        }
+        // Count .md files and memories
+        let memoryCount = 0;
+        try {
+            const { readdirSync } = await import('fs');
+            const files = readdirSync(path).filter(f => f.endsWith('.md'));
+            memoryCount = files.length;
+        }
+        catch {
+            // Ignore
+        }
+        // Check if QMD has this folder indexed (via qmd list)
+        const qmdIndexed = await this.checkQMDIndexed(path);
+        return {
+            mounted: true,
+            path,
+            qmdIndexed,
+            memoryCount,
+            lastIndexed: null
+        };
+    }
+    /**
+     * Check if folder is indexed by QMD
+     */
+    async checkQMDIndexed(folderPath) {
+        return new Promise((resolve) => {
+            const process = spawn('qmd', ['list'], {
+                stdio: 'pipe'
+            });
+            let output = '';
+            process.stdout?.on('data', (data) => {
+                output += data.toString();
+            });
+            process.on('close', () => {
+                resolve(output.includes(folderPath));
+            });
+            process.on('error', () => {
+                resolve(false);
+            });
+            setTimeout(() => {
+                process.kill();
+                resolve(false);
+            }, 5000);
+        });
+    }
+    /**
+     * Convert a MemoryRecord to MemoryAsMarkdown format
+     */
+    toMarkdownFormat(memory) {
+        return {
+            id: memory.id,
+            type: memory.type,
+            content: memory.content,
+            tags: memory.tags || [],
+            createdAt: memory.createdAt || new Date().toISOString(),
+            confidence: memory.confidenceLevel || undefined,
+            projectId: memory.projectId
+        };
+    }
+}
+// Singleton instance
+let externalMemoryInstance = null;
+/**
+ * Get the singleton ExternalFolderMemory instance
+ */
+export function getExternalMemory() {
+    if (!externalMemoryInstance) {
+        externalMemoryInstance = new ExternalFolderMemory();
+    }
+    return externalMemoryInstance;
+}
+/**
+ * Check if external memory is enabled
+ */
+export function isExternalMemoryEnabled() {
+    return getExternalMemory().isEnabled();
+}
+/**
+ * Get external memory path
+ */
+export function getExternalMemoryPath() {
+    return getExternalMemory().getPath();
+}
+//# sourceMappingURL=index.js.map

package/dist/core/hooks/agent-hooks.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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
+ */
+/**
+ * Generate a new session ID (universal across agents)
+ */
+export declare function generateSessionId(): string;
+/**
+ * Get current session ID
+ */
+export declare function getCurrentSessionId(): string | null;
+/**
+ * Set session ID (for resume/continue)
+ */
+export declare function setSessionId(sessionId: string): void;
+/**
+ * Session start hook - inject relevant context
+ */
+export declare function handleSessionStart(params: {
+    projectPath: string;
+    mode: 'startup' | 'resume' | 'compact';
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    memories: string[];
+    sessionId: string;
+    count: number;
+}>;
+/**
+ * Post-tool-use hook - record observations
+ */
+export declare function handlePostToolUse(params: {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolResult: unknown;
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    captured: boolean;
+    memoryId?: string;
+    reason?: string;
+}>;
+/**
+ * Session end hook - save snapshot and sync
+ */
+export declare function handleSessionEnd(params: {
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+    workInProgress?: string;
+}): Promise<{
+    snapshotId?: string;
+    memoriesSaved: number;
+}>;
+/**
+ * Pre-compact hook - save state for recovery
+ */
+export declare function handlePreCompact(params: {
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    stateSaved: boolean;
+    stateId?: string;
+}>;
+export { shouldCaptureTool, categorizeTool } from './capture-filter.js';
+export { inferTags } from './auto-tagger.js';
+//# sourceMappingURL=agent-hooks.d.ts.map

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

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

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