squish-memory 1.0.2 → 1.2.0

package/dist/core/search/qmd-search.js

@@ -1,178 +0,0 @@
-/**
- * QMD Hybrid Search Integration
- *
- * Integrates QMD's BM25+vector+rerank pipeline with Squish memories.
- * Provides enhanced search capabilities when QMD is available.
- *
- * QMD Search Pipeline:
- * 1. Query Expansion (LLM generates alternative queries)
- * 2. Parallel BM25 (FTS5) + Vector Search
- * 3. RRF Fusion (Reciprocal Rank Fusion)
- * 4. LLM Re-ranking (yes/no with logprobs)
- * 5. Position-Aware Blending
- *
- * Installation: bun install -g qmd
- * GitHub: https://github.com/tobi/qmd
- */
-import { getQMDClient } from '../embeddings/qmd-client.js';
-import { searchMemories } from '../memory/memories.js';
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-/**
- * Search memories using QMD's hybrid search
- *
- * @param options - Search options including query, type, limit, etc.
- * @returns QMD-enhanced search results
- */
-export async function searchWithQMD(options) {
-    const client = await getQMDClient();
-    if (!(await client.isAvailable())) {
-        logger.warn('QMD unavailable, falling back to Squish search');
-        // Fallback to Squish search
-        const squishResults = await searchMemories(options);
-        return squishResults.map((r) => ({
-            ...r,
-            source: 'squish'
-        }));
-    }
-    // Determine collection based on memory type mapping
-    const collection = options.collection || getCollectionForType(options.type);
-    try {
-        let qmdResults = [];
-        if (options.useHybrid !== false) {
-            // Use qmd_query (hybrid with reranking) - best quality
-            qmdResults = await client.query({
-                query: options.query,
-                collection,
-                limit: options.limit || 10,
-                minScore: 0.2
-            });
-        }
-        else {
-            // Use qmd_vsearch (semantic only) - faster
-            qmdResults = await client.vsearch({
-                query: options.query,
-                collection,
-                limit: options.limit || 10,
-                minScore: 0.2
-            });
-        }
-        // Map QMD results to Squish format
-        return qmdResults.map((result) => ({
-            id: result.docid || result.path,
-            content: result.snippet || result.title,
-            type: options.type || 'observation',
-            tags: [],
-            projectId: options.project ? options.project : null,
-            similarity: result.score,
-            qmdScore: result.score,
-            source: 'qmd',
-            createdAt: new Date().toISOString() // QMD doesn't provide timestamps
-        }));
-    }
-    catch (error) {
-        logger.error(`QMD search failed: ${error}`);
-        // Fallback to Squish search
-        const squishResults = await searchMemories(options);
-        return squishResults.map((r) => ({
-            ...r,
-            source: 'squish'
-        }));
-    }
-}
-/**
- * Fused search: combine Squish and QMD results
- *
- * Runs both searches in parallel and merges results with deduplication.
- *
- * @param options - Search options
- * @returns Fused search results from both sources
- */
-export async function fusedSearch(options) {
-    const client = await getQMDClient();
-    const qmdAvailable = await client.isAvailable();
-    // Run searches in parallel
-    const results = await Promise.allSettled([
-        searchMemories(options),
-        qmdAvailable ? searchWithQMD({ ...options, includeSquishResults: false }) : []
-    ]);
-    const squishResults = results[0].status === 'fulfilled'
-        ? results[0].value.map((r) => ({ ...r, source: 'squish' }))
-        : [];
-    const qmdResults = results[1].status === 'fulfilled'
-        ? results[1].value
-        : [];
-    // Deduplicate by content similarity
-    const seenContent = new Set();
-    const merged = [];
-    for (const result of [...squishResults, ...qmdResults]) {
-        // Create a content key for deduplication (first 100 chars)
-        const contentKey = result.content.substring(0, 100);
-        if (!seenContent.has(contentKey)) {
-            seenContent.add(contentKey);
-            merged.push(result);
-        }
-    }
-    // Re-rank by combined score
-    merged.sort((a, b) => {
-        const scoreA = (a.similarity || 0) + (a.qmdScore || 0) / 2;
-        const scoreB = (b.similarity || 0) + (b.qmdScore || 0) / 2;
-        return scoreB - scoreA;
-    });
-    return merged.slice(0, options.limit || 10);
-}
-/**
- * Get QMD collection name for a memory type
- *
- * Uses the configured collection mapping from config.
- *
- * @param type - Memory type (observation, fact, decision, context, preference)
- * @returns QMD collection name
- */
-function getCollectionForType(type) {
-    if (!type) {
-        return 'squish-all';
-    }
-    const mapping = config.qmdCollectionMapping || {};
-    return mapping[type] || `squish-${type}`;
-}
-/**
- * Check if QMD is available and configured
- *
- * @returns true if QMD is enabled and available
- */
-export async function isQMDAvailable() {
-    if (!config.qmdEnabled) {
-        return false;
-    }
-    try {
-        const client = await getQMDClient();
-        return await client.isAvailable();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get QMD status and collection info
- *
- * @returns QMD status or null if unavailable
- */
-export async function getQMDStatus() {
-    try {
-        const client = await getQMDClient();
-        const available = await client.isAvailable();
-        if (!available) {
-            return { available: false, collections: [] };
-        }
-        const status = await client.status();
-        return {
-            available: true,
-            collections: status?.collections || []
-        };
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=qmd-search.js.map

package/dist/core/snapshots.d.ts

@@ -1,29 +0,0 @@
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
-export declare function createBeforeSnapshot(memoryId: string): Promise<string>;
-export declare function createAfterSnapshot(memoryId: string, beforeSnapshotId: string): Promise<{
-    snapshotId: string;
-    diff: MemoryDiff;
-}>;
-export declare function createPeriodicSnapshot(memoryId: string): Promise<string>;
-export declare function getMemoryHistory(memoryId: string, limit?: number): Promise<any[]>;
-export declare function getMemorySnapshot(snapshotId: string): Promise<any>;
-export declare function deleteOldSnapshots(olderThanDays?: number): Promise<number>;
-export declare function compareSnapshots(snapshotId1: string, snapshotId2: string): Promise<{
-    diff: MemoryDiff;
-    contextBefore: string;
-    contextAfter: string;
-}>;
-export declare function getSnapshotStats(memoryId?: string): Promise<{
-    totalSnapshots: number;
-    byType: Record<string, number>;
-    oldestSnapshot: Date | null;
-    newestSnapshot: Date | null;
-}>;
-//# sourceMappingURL=snapshots.d.ts.map

package/dist/core/snapshots.js

@@ -1,220 +0,0 @@
-// Memory Snapshots for Auditability & Diffs
-import { eq, desc } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { cleanupOldMemorySnapshots } from './utils/cleanup-operations.js';
-import { logger } from './logger.js';
-export async function createBeforeSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found: ' + memoryId);
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'before_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating before snapshot', error);
-        throw error;
-    }
-}
-export async function createAfterSnapshot(memoryId, beforeSnapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const before = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, beforeSnapshotId))
-            .limit(1);
-        if (before.length === 0) {
-            throw new Error('Before snapshot not found');
-        }
-        const diff = calculateDiff(before[0].content, memory[0].content);
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'after_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            diff,
-            createdAt: new Date(),
-        });
-        return { snapshotId, diff };
-    }
-    catch (error) {
-        logger.error('Error creating after snapshot', error);
-        throw error;
-    }
-}
-export async function createPeriodicSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'periodic',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating periodic snapshot', error);
-        throw error;
-    }
-}
-export async function getMemoryHistory(memoryId, limit = 50) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.memoryId, memoryId))
-            .orderBy(desc(schema.memorySnapshots.createdAt))
-            .limit(limit);
-    }
-    catch (error) {
-        logger.error('Error getting memory history', error);
-        return [];
-    }
-}
-export async function getMemorySnapshot(snapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const snapshot = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, snapshotId))
-            .limit(1);
-        return snapshot.length > 0 ? snapshot[0] : null;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot', error);
-        return null;
-    }
-}
-export async function deleteOldSnapshots(olderThanDays = 90) {
-    return cleanupOldMemorySnapshots(olderThanDays);
-}
-function extractMetadata(memory) {
-    return {
-        type: memory.type,
-        sector: memory.sector,
-        confidence: memory.confidence,
-        relevanceScore: memory.relevanceScore,
-        tags: memory.tags,
-        agentId: memory.agentId,
-    };
-}
-function calculateDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const beforeSet = new Set(beforeLines);
-    const afterSet = new Set(afterLines);
-    const added = afterLines.filter(line => !beforeSet.has(line));
-    const removed = beforeLines.filter(line => !afterSet.has(line));
-    return {
-        added: added.length > 0 ? added : undefined,
-        removed: removed.length > 0 ? removed : undefined,
-    };
-}
-export async function compareSnapshots(snapshotId1, snapshotId2) {
-    try {
-        const snap1 = await getMemorySnapshot(snapshotId1);
-        const snap2 = await getMemorySnapshot(snapshotId2);
-        if (!snap1 || !snap2) {
-            throw new Error('One or both snapshots not found');
-        }
-        return {
-            diff: calculateDiff(snap1.content, snap2.content),
-            contextBefore: snap1.content.substring(0, 200),
-            contextAfter: snap2.content.substring(0, 200),
-        };
-    }
-    catch (error) {
-        logger.error('Error comparing snapshots', error);
-        throw error;
-    }
-}
-export async function getSnapshotStats(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const where = memoryId ? eq(schema.memorySnapshots.memoryId, memoryId) : undefined;
-        const snapshots = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(where);
-        const stats = {
-            totalSnapshots: snapshots.length,
-            byType: {
-                before_update: 0,
-                after_update: 0,
-                periodic: 0,
-            },
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-        let oldest = null;
-        let newest = null;
-        for (const snap of snapshots) {
-            stats.byType[snap.snapshotType]++;
-            const date = new Date(snap.createdAt);
-            if (!oldest || date < oldest)
-                oldest = date;
-            if (!newest || date > newest)
-                newest = date;
-        }
-        stats.oldestSnapshot = oldest;
-        stats.newestSnapshot = newest;
-        return stats;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot stats', error);
-        return {
-            totalSnapshots: 0,
-            byType: {},
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-    }
-}
-//# sourceMappingURL=snapshots.js.map

package/dist/core/sync/qmd-sync.d.ts

@@ -1,106 +0,0 @@
-/**
- * QMD Memory Synchronization
- *
- * Syncs Squish memories to QMD collections for hybrid search.
- * Writes memories as markdown files to QMD collection directories.
- *
- * QMD automatically indexes files in collection directories, so we just
- * need to write files to the right location.
- *
- * Collection Structure:
- * - qmd-collections/squish-observations/ - Observation memories
- * - qmd-collections/squish-facts/ - Fact memories
- * - qmd-collections/squish-decisions/ - Decision memories
- * - qmd-collections/squish-context/ - Context memories
- * - qmd-collections/squish-preferences/ - Preference memories
- */
-import type { MemoryRecord } from '../memory/memories.js';
-export interface CollectionMapping {
-    [memoryType: string]: string;
-}
-/**
- * QMD Memory Sync class
- *
- * Manages synchronization of Squish memories to QMD collections.
- */
-export declare class QMDMemorySync {
-    private collectionsPath;
-    private client;
-    private initialized;
-    constructor();
-    /**
-     * Initialize the sync layer
-     *
-     * Creates collection directories and verifies QMD connection.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Sync a memory to QMD
-     *
-     * Writes memory as markdown to the appropriate collection directory.
-     * QMD will automatically index the file on its next update cycle.
-     *
-     * @param memory - Memory record to sync
-     */
-    syncMemory(memory: MemoryRecord): Promise<void>;
-    /**
-     * Batch sync multiple memories
-     *
-     * @param memories - Array of memory records to sync
-     */
-    syncMemories(memories: MemoryRecord[]): Promise<void>;
-    /**
-     * Trigger QMD re-index
-     *
-     * Note: This would typically call `qmd update` or `qmd embed`.
-     * For now, we just log that documents are ready for indexing.
-     */
-    reindex(): Promise<void>;
-    /**
-     * Get collection name for a memory
-     *
-     * @param memory - Memory record
-     * @returns QMD collection name
-     */
-    private getCollectionForMemory;
-    /**
-     * Generate filename for memory
-     *
-     * Uses a docid-like format (6-char hash) for consistent naming.
-     *
-     * @param memory - Memory record
-     * @returns Filename for the memory
-     */
-    private getFilenameForMemory;
-    /**
-     * Format memory as markdown for QMD indexing
-     *
-     * Uses frontmatter for metadata and standard markdown for content.
-     *
-     * @param memory - Memory record
-     * @returns Markdown formatted string
-     */
-    private formatMemoryAsMarkdown;
-    /**
-     * Capitalize first letter of a string
-     */
-    private capitalize;
-    /**
-     * Create a QMD collection directory
-     *
-     * @param name - Collection name
-     */
-    private createCollection;
-}
-/**
- * Get the singleton QMD memory sync instance
- *
- * @returns QMDMemorySync instance
- */
-export declare function getQMDMemorySync(): Promise<QMDMemorySync>;
-/**
- * Reset the singleton sync instance
- * Useful for testing or when configuration changes.
- */
-export declare function resetQMDMemorySync(): void;
-//# sourceMappingURL=qmd-sync.d.ts.map