squish-memory 1.1.5 → 1.2.1

package/dist/core/external-folder/index.d.ts

@@ -1,102 +0,0 @@
-/**
- * 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 type { MemoryRecord, MemoryType } from '../memory/memories.js';
-export interface ExternalMemoryConfig {
-    enabled: boolean;
-    path: string;
-}
-export interface ExternalMemoryStatus {
-    mounted: boolean;
-    path: string | null;
-    qmdIndexed: boolean;
-    memoryCount: number;
-    lastIndexed: string | null;
-}
-export interface MemoryAsMarkdown {
-    id: string;
-    type: MemoryType;
-    content: string;
-    tags: string[];
-    createdAt: string;
-    confidence?: string;
-    projectId?: string | null;
-}
-/**
- * External Folder Memory Manager class
- */
-export declare class ExternalFolderMemory {
-    private mountedPath;
-    /**
-     * Check if external memory is enabled and mounted
-     */
-    isEnabled(): boolean;
-    /**
-     * Get the mounted path
-     */
-    getPath(): string | null;
-    /**
-     * Mount external memory at a path
-     * Creates folder if needed, initializes structure
-     */
-    mount(path: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Unmount external memory
-     */
-    unmount(): {
-        success: boolean;
-    };
-    /**
-     * Ensure QMD indexes the external folder
-     */
-    ensureIndexed(folderPath?: string): Promise<boolean>;
-    /**
-     * Write a memory to the external folder (daily note)
-     */
-    writeMemory(memory: MemoryAsMarkdown): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Trigger background re-index via QMD
-     */
-    private triggerReindex;
-    /**
-     * Get current status of external memory
-     */
-    getStatus(): Promise<ExternalMemoryStatus>;
-    /**
-     * Check if folder is indexed by QMD
-     */
-    private checkQMDIndexed;
-    /**
-     * Convert a MemoryRecord to MemoryAsMarkdown format
-     */
-    toMarkdownFormat(memory: MemoryRecord): MemoryAsMarkdown;
-}
-/**
- * Get the singleton ExternalFolderMemory instance
- */
-export declare function getExternalMemory(): ExternalFolderMemory;
-/**
- * Check if external memory is enabled
- */
-export declare function isExternalMemoryEnabled(): boolean;
-/**
- * Get external memory path
- */
-export declare function getExternalMemoryPath(): string | null;
-//# sourceMappingURL=index.d.ts.map

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

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

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