squish-memory 1.1.5 → 1.2.1

package/dist/core/utils/temporal-queries.js

@@ -1,27 +0,0 @@
-/**
- * Shared Temporal Query Utilities
- * Common patterns for temporal database queries
- */
-import { and, eq, lte, gte, or, isNull } from 'drizzle-orm';
-/**
- * Build temporal validity filters for queries
- */
-export function buildTemporalFilters(schema, timestamp = new Date(), additionalFilters = []) {
-    const filters = [
-        lte(schema.validFrom, timestamp),
-        or(isNull(schema.validTo), gte(schema.validTo, timestamp)),
-        ...additionalFilters
-    ];
-    return filters;
-}
-/**
- * Build temporal query for facts at a specific time
- */
-export function buildFactAtTimeQuery(schema, timestamp = new Date(), additionalFilters = []) {
-    const filters = buildTemporalFilters(schema, timestamp, [
-        eq(schema.type, 'fact'),
-        ...additionalFilters
-    ]);
-    return and(...filters);
-}
-//# sourceMappingURL=temporal-queries.js.map

package/dist/core/utils/vector-operations.d.ts

@@ -1,71 +0,0 @@
-/**
- * Vector Operations Utilities
- *
- * Provides mathematical operations for vector computations, primarily focused on
- * cosine similarity calculations for embedding comparisons.
- *
- * All functions handle edge cases gracefully and are optimized for performance.
- */
-/**
- * Calculates the cosine similarity between two vectors.
- *
- * Cosine similarity measures the cosine of the angle between two vectors,
- * providing a normalized measure of similarity that ranges from -1 (opposite)
- * to 1 (identical), with 0 indicating orthogonality (no similarity).
- *
- * The implementation uses the standard formula:
- *   cos(θ) = (A · B) / (||A|| * ||B||)
- *
- * Edge case handling:
- * - Returns 0 if either vector is null/undefined
- * - Returns 0 if vectors have different lengths
- * - Returns 0 if either vector has zero magnitude (norm = 0)
- *
- * @param a - First vector as array of numbers
- * @param b - Second vector as array of numbers
- * @returns Cosine similarity value in range [-1, 1], or 0 for invalid inputs
- *
- * @example
- * ```typescript
- * const vec1 = [1, 2, 3];
- * const vec2 = [4, 5, 6];
- * const similarity = cosineSimilarity(vec1, vec2); // ~0.974
- * ```
- *
- * @performance
- * - Time complexity: O(n) where n is vector length
- * - Space complexity: O(1) - uses only accumulator variables
- * - Optimized with single-pass computation of dot product and norms
- */
-export declare function cosineSimilarity(a: number[] | null | undefined, b: number[] | null | undefined): number;
-/**
- * Calculates the Euclidean distance between two vectors.
- *
- * @param a - First vector
- * @param b - Second vector
- * @returns Euclidean distance, or Infinity if vectors have different lengths
- */
-export declare function euclideanDistance(a: number[] | null | undefined, b: number[] | null | undefined): number;
-/**
- * Normalizes a vector to unit length (magnitude = 1).
- *
- * @param vec - Input vector
- * @returns Normalized vector, or null if input is null or zero vector
- */
-export declare function normalizeVector(vec: number[] | null | undefined): number[] | null;
-/**
- * Computes the dot product of two vectors.
- *
- * @param a - First vector
- * @param b - Second vector
- * @returns Dot product, or 0 if vectors are invalid or different lengths
- */
-export declare function dotProduct(a: number[] | null | undefined, b: number[] | null | undefined): number;
-/**
- * Calculates the magnitude (L2 norm) of a vector.
- *
- * @param vec - Input vector
- * @returns Magnitude of the vector, or 0 if input is null
- */
-export declare function magnitude(vec: number[] | null | undefined): number;
-//# sourceMappingURL=vector-operations.d.ts.map

package/dist/core/utils/version-management.d.ts

@@ -1,9 +0,0 @@
-/**
- * Shared Version Management Utilities
- * Common patterns for versioning and updating records
- */
-/**
- * Create a new version of a fact by expiring the old one
- */
-export declare function createNewFactVersion(oldFactId: string, newContent: string, additionalFields?: Record<string, any>, reason?: string): Promise<string>;
-//# sourceMappingURL=version-management.d.ts.map

package/dist/core/utils/version-management.js

@@ -1,61 +0,0 @@
-/**
- * Shared Version Management Utilities
- * Common patterns for versioning and updating records
- */
-import { eq } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Create a new version of a fact by expiring the old one
- */
-export async function createNewFactVersion(oldFactId, newContent, additionalFields = {}, reason) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get the old fact
-        const oldFacts = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, oldFactId))
-            .limit(1);
-        if (oldFacts.length === 0) {
-            throw new Error('Previous fact not found');
-        }
-        const oldFact = oldFacts[0];
-        const now = new Date();
-        const newFactId = randomUUID();
-        // Expire the old fact
-        await db
-            .update(schema.memories)
-            .set({ validTo: now, supersededBy: newFactId })
-            .where(eq(schema.memories.id, oldFactId));
-        // Create new version
-        const newFact = {
-            id: newFactId,
-            type: 'fact',
-            sector: 'semantic',
-            content: newContent,
-            confidence: oldFact.confidence,
-            validFrom: now,
-            validTo: null,
-            version: (oldFact.version || 1) + 1,
-            tags: oldFact.tags,
-            projectId: oldFact.projectId,
-            createdAt: now,
-            updatedAt: now,
-            ...additionalFields,
-        };
-        if (reason) {
-            newFact.metadata = { supersedes: oldFactId, reason };
-        }
-        await db.insert(schema.memories).values(newFact);
-        return newFactId;
-    }
-    catch (error) {
-        logger.error('Error creating new fact version', error);
-        throw error;
-    }
-}
-//# sourceMappingURL=version-management.js.map

package/dist/core/worker.d.ts

@@ -1,82 +0,0 @@
-/**
- * Background Worker
- * Handles lifecycle maintenance, summarization, and other async tasks
- */
-interface WorkerConfig {
-    lifecycleInterval: number;
-    pruningInterval: number;
-    summarizationCheckInterval: number;
-    consolidationInterval: number;
-    dedupInterval: number;
-    associationPruningThreshold: number;
-    summaryPruningAge: number;
-}
-declare class SquishWorker {
-    private lifecycleTimer?;
-    private pruningTimer?;
-    private summarizationTimer?;
-    private consolidationTimer?;
-    private dedupTimer?;
-    private config;
-    private isRunning;
-    private stats;
-    constructor(customConfig?: Partial<WorkerConfig>);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private scheduleLifecycleMaintenance;
-    private runLifecycleMaintenance;
-    private schedulePruning;
-    private runPruning;
-    private scheduleSummarizationCheck;
-    private runSummarizationCheck;
-    private scheduleConsolidation;
-    private runConsolidation;
-    private scheduleDedup;
-    private runDedup;
-    getStats(): {
-        isRunning: boolean;
-        stats: {
-            lifecycleRuns: number;
-            pruningRuns: number;
-            summarizationRuns: number;
-            consolidationRuns: number;
-            dedupRuns: number;
-            lastLifecycle: any;
-            lastAssociation: any;
-            lastSummarization: any;
-            lastConsolidation: any;
-            lastDedup: any;
-        };
-        config: WorkerConfig;
-    };
-    forceLifecycleMaintenance(projectId?: string): Promise<any>;
-    forcePruning(): Promise<any>;
-    forceConsolidation(projectId?: string): Promise<any>;
-    forceDedup(projectId?: string): Promise<any>;
-}
-export declare function getWorker(customConfig?: Partial<WorkerConfig>): SquishWorker;
-export declare function startWorker(): Promise<void>;
-export declare function stopWorker(): Promise<void>;
-export declare function getWorkerStats(): {
-    isRunning: boolean;
-    stats: {
-        lifecycleRuns: number;
-        pruningRuns: number;
-        summarizationRuns: number;
-        consolidationRuns: number;
-        dedupRuns: number;
-        lastLifecycle: any;
-        lastAssociation: any;
-        lastSummarization: any;
-        lastConsolidation: any;
-        lastDedup: any;
-    };
-    config: WorkerConfig;
-} | null;
-export declare function forceLifecycleMaintenance(projectId?: string): Promise<any>;
-export declare function forcePruning(): Promise<any>;
-export declare function forceConsolidation(projectId?: string): Promise<any>;
-export declare function forceDedup(projectId?: string): Promise<any>;
-export type { WorkerConfig };
-export { SquishWorker };
-//# sourceMappingURL=worker.d.ts.map

package/dist/core/worker.js

@@ -1,272 +0,0 @@
-/**
- * Background Worker
- * Handles lifecycle maintenance, summarization, and other async tasks
- */
-import { config } from '../config.js';
-import { runLifecycleMaintenance } from './lifecycle.js';
-import { pruneWeakAssociations, getAssociationStats } from './associations.js';
-import { pruneOldSummaries, getSummarizationStats } from './summarization.js';
-import { runFullConsolidationJob, getDeduplicationStats } from './consolidation.js';
-import { logger } from './logger.js';
-const DEFAULT_WORKER_CONFIG = {
-    lifecycleInterval: config.lifecycleInterval || 3600000,
-    pruningInterval: 7 * 24 * 60 * 60 * 1000,
-    summarizationCheckInterval: 5 * 60 * 1000,
-    consolidationInterval: 24 * 60 * 60 * 1000, // Daily
-    dedupInterval: 12 * 60 * 60 * 1000, // Twice daily
-    associationPruningThreshold: 5,
-    summaryPruningAge: 30,
-};
-class SquishWorker {
-    lifecycleTimer;
-    pruningTimer;
-    summarizationTimer;
-    consolidationTimer;
-    dedupTimer;
-    config;
-    isRunning = false;
-    stats = {
-        lifecycleRuns: 0,
-        pruningRuns: 0,
-        summarizationRuns: 0,
-        consolidationRuns: 0,
-        dedupRuns: 0,
-        lastLifecycle: null,
-        lastAssociation: null,
-        lastSummarization: null,
-        lastConsolidation: null,
-        lastDedup: null,
-    };
-    constructor(customConfig = {}) {
-        this.config = { ...DEFAULT_WORKER_CONFIG, ...customConfig };
-    }
-    async start() {
-        if (this.isRunning) {
-            logger.warn('Worker already running');
-            return;
-        }
-        this.isRunning = true;
-        logger.info('Starting background worker');
-        if (config.lifecycleEnabled) {
-            this.scheduleLifecycleMaintenance();
-        }
-        this.schedulePruning();
-        if (config.summarizationEnabled) {
-            this.scheduleSummarizationCheck();
-        }
-        // Schedule consolidation and dedup jobs
-        this.scheduleConsolidation();
-        this.scheduleDedup();
-        logger.info('Background worker started');
-    }
-    async stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        this.isRunning = false;
-        if (this.lifecycleTimer)
-            clearInterval(this.lifecycleTimer);
-        if (this.pruningTimer)
-            clearInterval(this.pruningTimer);
-        if (this.summarizationTimer)
-            clearInterval(this.summarizationTimer);
-        if (this.consolidationTimer)
-            clearInterval(this.consolidationTimer);
-        if (this.dedupTimer)
-            clearInterval(this.dedupTimer);
-        logger.info('Background worker stopped');
-    }
-    scheduleLifecycleMaintenance() {
-        this.runLifecycleMaintenance().catch((err) => {
-            logger.error('Initial lifecycle maintenance failed:', err);
-        });
-        this.lifecycleTimer = setInterval(() => {
-            this.runLifecycleMaintenance().catch((err) => {
-                logger.error('Scheduled lifecycle maintenance failed:', err);
-            });
-        }, this.config.lifecycleInterval);
-    }
-    async runLifecycleMaintenance() {
-        try {
-            const stats = await runLifecycleMaintenance();
-            this.stats.lifecycleRuns++;
-            this.stats.lastLifecycle = {
-                timestamp: new Date().toISOString(),
-                ...stats,
-            };
-            logger.info('Lifecycle maintenance completed', {
-                decayed: stats.decayed,
-                evicted: stats.evicted,
-                promoted: stats.promoted,
-            });
-        }
-        catch (error) {
-            logger.error('Lifecycle maintenance error:', error);
-        }
-    }
-    schedulePruning() {
-        this.runPruning().catch((err) => {
-            logger.error('Initial pruning failed:', err);
-        });
-        this.pruningTimer = setInterval(() => {
-            this.runPruning().catch((err) => {
-                logger.error('Scheduled pruning failed:', err);
-            });
-        }, this.config.pruningInterval);
-    }
-    async runPruning() {
-        try {
-            this.stats.pruningRuns++;
-            const prunedAssociations = await pruneWeakAssociations(this.config.associationPruningThreshold);
-            const assocStats = await getAssociationStats();
-            this.stats.lastAssociation = {
-                timestamp: new Date().toISOString(),
-                pruned: prunedAssociations,
-                ...assocStats,
-            };
-            const prunedSummaries = await pruneOldSummaries(this.config.summaryPruningAge);
-            logger.info('Pruning completed', {
-                associationsPruned: prunedAssociations,
-                summariesPruned: prunedSummaries,
-            });
-        }
-        catch (error) {
-            logger.error('Pruning error:', error);
-        }
-    }
-    scheduleSummarizationCheck() {
-        this.summarizationTimer = setInterval(() => {
-            this.runSummarizationCheck().catch((err) => {
-                logger.error('Summarization check failed:', err);
-            });
-        }, this.config.summarizationCheckInterval);
-    }
-    async runSummarizationCheck() {
-        try {
-            this.stats.summarizationRuns++;
-            const stats = await getSummarizationStats();
-            this.stats.lastSummarization = {
-                timestamp: new Date().toISOString(),
-                ...stats,
-            };
-        }
-        catch (error) {
-            logger.error('Summarization check error:', error);
-        }
-    }
-    scheduleConsolidation() {
-        // Run immediately on start
-        this.runConsolidation().catch((err) => {
-            logger.error('Initial consolidation failed:', err);
-        });
-        this.consolidationTimer = setInterval(() => {
-            this.runConsolidation().catch((err) => {
-                logger.error('Scheduled consolidation failed:', err);
-            });
-        }, this.config.consolidationInterval);
-    }
-    async runConsolidation() {
-        try {
-            this.stats.consolidationRuns++;
-            const stats = await runFullConsolidationJob();
-            this.stats.lastConsolidation = {
-                timestamp: new Date().toISOString(),
-                ...stats,
-            };
-            logger.info('Consolidation completed', {
-                clustered: stats.clustered,
-                merged: stats.merged,
-                deduped: stats.deduped,
-                consolidated: stats.consolidated,
-                tokensRecovered: stats.tokensRecovered,
-            });
-        }
-        catch (error) {
-            logger.error('Consolidation error:', error);
-        }
-    }
-    scheduleDedup() {
-        // Run immediately on start
-        this.runDedup().catch((err) => {
-            logger.error('Initial dedup failed:', err);
-        });
-        this.dedupTimer = setInterval(() => {
-            this.runDedup().catch((err) => {
-                logger.error('Scheduled dedup failed:', err);
-            });
-        }, this.config.dedupInterval);
-    }
-    async runDedup() {
-        try {
-            this.stats.dedupRuns++;
-            const dedupStats = await getDeduplicationStats();
-            this.stats.lastDedup = {
-                timestamp: new Date().toISOString(),
-                ...dedupStats,
-            };
-        }
-        catch (error) {
-            logger.error('Dedup check error:', error);
-        }
-    }
-    getStats() {
-        return {
-            isRunning: this.isRunning,
-            stats: this.stats,
-            config: this.config,
-        };
-    }
-    async forceLifecycleMaintenance(projectId) {
-        return await runLifecycleMaintenance(projectId);
-    }
-    async forcePruning() {
-        return await this.runPruning();
-    }
-    async forceConsolidation(projectId) {
-        return await runFullConsolidationJob(projectId);
-    }
-    async forceDedup(projectId) {
-        const { runDeduplicationJob } = await import('./consolidation.js');
-        return await runDeduplicationJob(projectId);
-    }
-}
-let globalWorker = null;
-export function getWorker(customConfig) {
-    if (!globalWorker) {
-        globalWorker = new SquishWorker(customConfig);
-    }
-    return globalWorker;
-}
-export async function startWorker() {
-    const worker = getWorker();
-    await worker.start();
-}
-export async function stopWorker() {
-    if (globalWorker) {
-        await globalWorker.stop();
-    }
-}
-export function getWorkerStats() {
-    if (!globalWorker) {
-        return null;
-    }
-    return globalWorker.getStats();
-}
-export async function forceLifecycleMaintenance(projectId) {
-    const worker = getWorker();
-    return await worker.forceLifecycleMaintenance(projectId);
-}
-export async function forcePruning() {
-    const worker = getWorker();
-    return await worker.forcePruning();
-}
-export async function forceConsolidation(projectId) {
-    const worker = getWorker();
-    return await worker.forceConsolidation(projectId);
-}
-export async function forceDedup(projectId) {
-    const worker = getWorker();
-    return await worker.forceDedup(projectId);
-}
-export { SquishWorker };
-//# sourceMappingURL=worker.js.map

package/dist/db/adapter.d.ts

@@ -1,7 +0,0 @@
-export declare function createDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("./drizzle/schema.js")> & {
-    $client: import("pg").Pool;
-}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("./drizzle/schema-sqlite.js")> & {
-    $client: import("better-sqlite3").Database;
-}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("./drizzle/schema-sqlite.js")>>;
-export default createDb;
-//# sourceMappingURL=adapter.d.ts.map