squish-memory 1.1.5 → 1.2.1

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

@@ -1,94 +0,0 @@
-/**
- * QMD Memory Synchronization
- * Syncs Squish memories to QMD collections for hybrid search
- */
-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

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

@@ -1,201 +0,0 @@
-/**
- * QMD Memory Synchronization
- * Syncs Squish memories to QMD collections for hybrid search
- */
-import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { getQMDClient } from '../embeddings/qmd-client.js';
-import { config } from '../../config.js';
-import { logger } from '../logger.js';
-/**
- * QMD Memory Sync class
- *
- * Manages synchronization of Squish memories to QMD collections.
- */
-export class QMDMemorySync {
-    collectionsPath;
-    client;
-    initialized = false;
-    constructor() {
-        this.collectionsPath = config.qmdCollectionsPath;
-    }
-    /**
-     * Initialize the sync layer
-     *
-     * Creates collection directories and verifies QMD connection.
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        this.initialized = true;
-        try {
-            // Ensure collections directory exists
-            await mkdir(this.collectionsPath, { recursive: true });
-            // Initialize QMD client (but don't fail if QMD isn't installed)
-            try {
-                this.client = await getQMDClient();
-                const available = await this.client.isAvailable();
-                if (available) {
-                    logger.info('QMD sync initialized with available QMD server');
-                }
-                else {
-                    logger.info('QMD sync initialized (QMD server not available)');
-                }
-            }
-            catch (error) {
-                logger.debug('QMD client unavailable, sync will be deferred');
-            }
-            // Create collection directories for each memory type
-            for (const [memoryType, collectionName] of Object.entries(config.qmdCollectionMapping)) {
-                await this.createCollection(String(collectionName));
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to initialize QMD sync: ${error}`);
-        }
-    }
-    /**
-     * 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
-     */
-    async syncMemory(memory) {
-        // Lazy initialization
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        // Check if QMD is available
-        if (this.client && !(await this.client.isAvailable())) {
-            logger.debug('QMD unavailable, skipping sync');
-            return;
-        }
-        const collection = this.getCollectionForMemory(memory);
-        const filename = this.getFilenameForMemory(memory);
-        const content = this.formatMemoryAsMarkdown(memory);
-        const filepath = join(this.collectionsPath, collection, filename);
-        try {
-            await mkdir(join(this.collectionsPath, collection), { recursive: true });
-            await writeFile(filepath, content, 'utf-8');
-            logger.debug(`Synced memory ${memory.id} to QMD collection ${collection}`);
-        }
-        catch (error) {
-            logger.error(`Failed to sync memory to QMD: ${error}`);
-        }
-    }
-    /**
-     * Batch sync multiple memories
-     *
-     * @param memories - Array of memory records to sync
-     */
-    async syncMemories(memories) {
-        for (const memory of memories) {
-            await this.syncMemory(memory);
-        }
-    }
-    /**
-     * 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.
-     */
-    async reindex() {
-        if (!this.client || !(await this.client.isAvailable())) {
-            logger.debug('QMD unavailable, skipping reindex');
-            return;
-        }
-        // In a full implementation, this would spawn a qmd process
-        // to update the index. For now, we rely on QMD's background indexing.
-        logger.info('QMD collections updated, ready for indexing');
-    }
-    /**
-     * Get collection name for a memory
-     *
-     * @param memory - Memory record
-     * @returns QMD collection name
-     */
-    getCollectionForMemory(memory) {
-        const mapping = config.qmdCollectionMapping || {};
-        return mapping[memory.type] || 'squish-default';
-    }
-    /**
-     * Generate filename for memory
-     *
-     * Uses a docid-like format (6-char hash) for consistent naming.
-     *
-     * @param memory - Memory record
-     * @returns Filename for the memory
-     */
-    getFilenameForMemory(memory) {
-        // Create a short hash from the memory ID (like QMD's docid)
-        const hash = Buffer.from(memory.id.replace(/-/g, '')).toString('base64')
-            .replace(/[+/=]/g, '')
-            .substring(0, 6);
-        // Format: type-hash.md
-        return `${memory.type}-${hash}.md`;
-    }
-    /**
-     * Format memory as markdown for QMD indexing
-     *
-     * Uses frontmatter for metadata and standard markdown for content.
-     *
-     * @param memory - Memory record
-     * @returns Markdown formatted string
-     */
-    formatMemoryAsMarkdown(memory) {
-        const frontmatter = [
-            '---',
-            `id: ${memory.id}`,
-            `type: ${memory.type}`,
-            memory.tags && memory.tags.length > 0 ? `tags: ${memory.tags.join(', ')}` : '',
-            memory.createdAt ? `created: ${memory.createdAt}` : '',
-            memory.metadata ? `metadata: ${JSON.stringify(memory.metadata)}` : '',
-            '---',
-            '',
-            `# ${this.capitalize(memory.type)}`,
-            ''
-        ].filter(line => line !== '').join('\n');
-        return frontmatter + memory.content;
-    }
-    /**
-     * Capitalize first letter of a string
-     */
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-    /**
-     * Create a QMD collection directory
-     *
-     * @param name - Collection name
-     */
-    async createCollection(name) {
-        const collectionPath = join(this.collectionsPath, name);
-        await mkdir(collectionPath, { recursive: true });
-        logger.debug(`QMD collection prepared: ${name}`);
-    }
-}
-// Singleton instance
-let syncInstance = null;
-/**
- * Get the singleton QMD memory sync instance
- *
- * @returns QMDMemorySync instance
- */
-export async function getQMDMemorySync() {
-    if (!syncInstance) {
-        syncInstance = new QMDMemorySync();
-        await syncInstance.initialize();
-    }
-    return syncInstance;
-}
-/**
- * Reset the singleton sync instance
- * Useful for testing or when configuration changes.
- */
-export function resetQMDMemorySync() {
-    syncInstance = null;
-}
-//# sourceMappingURL=qmd-sync.js.map

package/dist/core/temporal-facts.d.ts

@@ -1,54 +0,0 @@
-/**
- * Temporal Facts System
- * Manages versioned facts with validity windows
- */
-/**
- * Store a new fact with temporal validity
- */
-export declare function storeFact(content: string, options?: {
-    validFrom?: Date;
-    validTo?: Date;
-    confidence?: number;
-    tags?: string[];
-    projectId?: string;
-}): Promise<string>;
-/**
- * Update a fact by creating a new version
- */
-export declare function updateFact(previousFactId: string, newContent: string, reason: string): Promise<string>;
-/**
- * Query facts valid at a specific point in time
- */
-export declare function queryFactsAtTime(timestamp?: Date, options?: {
-    minConfidence?: number;
-    tags?: string[];
-    projectId?: string;
-    limit?: number;
-}): Promise<any[]>;
-/**
- * Get the complete version history of a fact
- */
-export declare function getFactHistory(factId: string): Promise<any[]>;
-/**
- * Apply confidence decay based on temporal distance
- */
-export declare function applyConfidenceDecay(factId: string, ageDays: number): Promise<void>;
-/**
- * Invalidate a fact (mark as no longer valid)
- */
-export declare function invalidateFact(factId: string, reason: string): Promise<void>;
-/**
- * Check if a fact is currently valid
- */
-export declare function isFactValid(factId: string, atTime?: Date): Promise<boolean>;
-/**
- * Get statistics about facts
- */
-export declare function getFactStats(projectId?: string): Promise<{
-    totalFacts: number;
-    activeFacts: number;
-    expiredFacts: number;
-    avgConfidence: number;
-    avgAge: number;
-}>;
-//# sourceMappingURL=temporal-facts.d.ts.map

package/dist/core/temporal-facts.js

@@ -1,193 +0,0 @@
-/**
- * Temporal Facts System
- * Manages versioned facts with validity windows
- */
-import { and, eq, gte, desc } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { traverseSupersededChain } from './utils/history-traversal.js';
-import { createNewFactVersion } from './utils/version-management.js';
-import { buildFactAtTimeQuery } from './utils/temporal-queries.js';
-import { logger } from './logger.js';
-/**
- * Store a new fact with temporal validity
- */
-export async function storeFact(content, options = {}) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const factId = randomUUID();
-        await db.insert(schema.memories).values({
-            id: factId,
-            type: 'fact',
-            sector: 'semantic',
-            content,
-            confidence: options.confidence || 100,
-            validFrom: options.validFrom || new Date(),
-            validTo: options.validTo || null,
-            version: 1,
-            tags: options.tags || [],
-            projectId: options.projectId || null,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        });
-        return factId;
-    }
-    catch (error) {
-        logger.error('Error storing fact', error);
-        throw error;
-    }
-}
-/**
- * Update a fact by creating a new version
- */
-export async function updateFact(previousFactId, newContent, reason) {
-    return createNewFactVersion(previousFactId, newContent, {}, reason);
-}
-/**
- * Query facts valid at a specific point in time
- */
-export async function queryFactsAtTime(timestamp = new Date(), options = {}) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const minConfidence = options.minConfidence || 0;
-        const limit = options.limit || 100;
-        const additionalFilters = [gte(schema.memories.confidence, minConfidence)];
-        if (options.projectId) {
-            additionalFilters.push(eq(schema.memories.projectId, options.projectId));
-        }
-        const where = buildFactAtTimeQuery(schema, timestamp, additionalFilters);
-        const results = await db
-            .select()
-            .from(schema.memories)
-            .where(where)
-            .orderBy(desc(schema.memories.confidence))
-            .limit(limit);
-        return results;
-    }
-    catch (error) {
-        logger.error('Error querying facts at time', error);
-        return [];
-    }
-}
-/**
- * Get the complete version history of a fact
- */
-export async function getFactHistory(factId) {
-    return traverseSupersededChain(factId);
-}
-/**
- * Apply confidence decay based on temporal distance
- */
-export async function applyConfidenceDecay(factId, ageDays) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Confidence decays exponentially: newConfidence = originalConfidence * e^(-lambda * ageDays)
-        // Using lambda = 0.01 for moderate decay
-        const decayFactor = Math.exp(-0.01 * ageDays);
-        const fact = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, factId))
-            .limit(1);
-        if (fact.length === 0)
-            return;
-        const newConfidence = Math.max(0, Math.floor(fact[0].confidence * decayFactor));
-        await db
-            .update(schema.memories)
-            .set({ confidence: newConfidence })
-            .where(eq(schema.memories.id, factId));
-    }
-    catch (error) {
-        logger.error('Error applying confidence decay', error);
-    }
-}
-/**
- * Invalidate a fact (mark as no longer valid)
- */
-export async function invalidateFact(factId, reason) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        await db
-            .update(schema.memories)
-            .set({
-            validTo: new Date(),
-            metadata: { invalidationReason: reason, invalidatedAt: new Date().toISOString() },
-        })
-            .where(eq(schema.memories.id, factId));
-    }
-    catch (error) {
-        logger.error('Error invalidating fact', error);
-    }
-}
-/**
- * Check if a fact is currently valid
- */
-export async function isFactValid(factId, atTime = new Date()) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const additionalFilters = [eq(schema.memories.id, factId)];
-        const where = buildFactAtTimeQuery(schema, atTime, additionalFilters);
-        const fact = await db
-            .select()
-            .from(schema.memories)
-            .where(where)
-            .limit(1);
-        return fact.length > 0;
-    }
-    catch (error) {
-        logger.error('Error checking fact validity', error);
-        return false;
-    }
-}
-/**
- * Get statistics about facts
- */
-export async function getFactStats(projectId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        const where = projectId
-            ? and(eq(schema.memories.type, 'fact'), eq(schema.memories.projectId, projectId))
-            : eq(schema.memories.type, 'fact');
-        const facts = await db.select().from(schema.memories).where(where);
-        let active = 0;
-        let expired = 0;
-        let totalConfidence = 0;
-        let totalAge = 0;
-        for (const fact of facts) {
-            totalConfidence += fact.confidence || 0;
-            if (fact.validTo && new Date(fact.validTo) < now) {
-                expired++;
-            }
-            else if (!fact.validTo || new Date(fact.validTo) >= now) {
-                active++;
-            }
-            totalAge += (now.getTime() - new Date(fact.createdAt).getTime()) / (1000 * 60 * 60 * 24);
-        }
-        return {
-            totalFacts: facts.length,
-            activeFacts: active,
-            expiredFacts: expired,
-            avgConfidence: facts.length > 0 ? totalConfidence / facts.length : 0,
-            avgAge: facts.length > 0 ? totalAge / facts.length : 0,
-        };
-    }
-    catch (error) {
-        logger.error('Error getting fact stats', error);
-        return {
-            totalFacts: 0,
-            activeFacts: 0,
-            expiredFacts: 0,
-            avgConfidence: 0,
-            avgAge: 0,
-        };
-    }
-}
-//# sourceMappingURL=temporal-facts.js.map

package/dist/core/toon.d.ts

@@ -1,43 +0,0 @@
-/**
- * TOON Compression - Token-efficient memory format
- *
- * Compact format for memory context using abbreviated notation.
- * Achieves efficient token usage for context injection.
- *
- * Format:
- * {
- *   m:[type],      // memory type (1-2 chars)
- *   c:"...",       // content (truncated)
- *   t:[],          // tags (array)
- *   d:123          // days ago
- * }
- */
-/**
- * Compress a memory to TOON format
- */
-export declare function compressForContext(content: string): string;
-/**
- * Decompress TOON back to readable format
- */
-export declare function decompressFromContext(toonString: string): string;
-/**
- * Estimate compression ratio
- */
-export declare function estimateCompressionRatio(content: string): number;
-/**
- * Check if content is JSON
- */
-export declare function isJson(content: string): boolean;
-/**
- * Check if content is TOON format
- */
-export declare function isToon(content: string): boolean;
-/**
- * Count tokens (rough estimate)
- */
-export declare function estimateTokens(text: string): number;
-/**
- * Truncate to token budget
- */
-export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
-//# sourceMappingURL=toon.d.ts.map