squish-memory 1.2.0 → 1.2.1

package/dist/core/scheduler/cron-scheduler.js

@@ -1,493 +0,0 @@
-/** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
-import cron from 'node-cron';
-import { selfIterationHandler } from '../session/self-iteration-job.js';
-import { runLifecycleMaintenance } from '../lifecycle.js';
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { getDb } from '../../db/index.js';
-import { maintenanceJobs, maintenanceJobHistory } from '../../db/drizzle/schema-sqlite.js';
-import { eq } from 'drizzle-orm';
-const jobHandlers = new Map();
-const activeTasks = new Map(); // node-cron ScheduledTask type
-// Job interval by type (in ms) - used for catch-up detection
-const JOB_INTERVALS = {
-    hourly: 60 * 60 * 1000, // 1 hour
-    daily: 24 * 60 * 60 * 1000, // 24 hours
-    nightly: 24 * 60 * 60 * 1000, // 24 hours (same as daily)
-    weekly: 7 * 24 * 60 * 60 * 1000, // 7 days
-};
-export function registerJobHandler(jobName, handler) {
-    jobHandlers.set(jobName, handler);
-    logger.info(`[Scheduler] Registered handler for job: ${jobName}`);
-}
-// Register self-iteration job handler
-registerJobHandler('self_iteration', selfIterationHandler);
-// Decay job handler - runs lifecycle maintenance (decay, tier updates, eviction)
-const decayHandler = async (context) => {
-    const stats = await runLifecycleMaintenance();
-    return {
-        recordsProcessed: stats.decayed + stats.expired + stats.evicted,
-        summary: {
-            decayed: stats.decayed,
-            expired: stats.expired,
-            evicted: stats.evicted,
-            tierChanges: stats.tierChanges,
-        },
-    };
-};
-registerJobHandler('decay_maintenance', decayHandler);
-// Belief decay handler - applies confidence decay to beliefs
-const beliefDecayHandler = async (context) => {
-    const { applyBeliefDecay } = await import('../beliefs/decay.js');
-    const stats = await applyBeliefDecay();
-    return {
-        recordsProcessed: stats.decayed + stats.sourceCountUpdated,
-        summary: {
-            beliefDecayed: stats.decayed,
-            sourceCountUpdated: stats.sourceCountUpdated,
-            errors: stats.errors,
-        },
-    };
-};
-registerJobHandler('belief_decay', beliefDecayHandler);
-// Auto-clean handler - deletes stale memories automatically
-const autoCleanHandler = async (context) => {
-    const { getStaleMemories, deleteMemoryPermanently } = await import('../memory/stale-cleaner.js');
-    const { getAllProjects } = await import('../projects.js');
-    const jobConfig = context.config;
-    if (jobConfig.enabled === false) {
-        return { recordsProcessed: 0, summary: { skipped: true, reason: 'auto-clean disabled' } };
-    }
-    const olderThanDays = jobConfig.olderThanDays || 30;
-    const confidenceLevels = jobConfig.confidenceLevel || ['outdated', 'speculative'];
-    const minImportance = jobConfig.minImportance || 40;
-    const dryRun = jobConfig.dryRun !== undefined ? jobConfig.dryRun : false; // Default to actual delete for safety
-    const projects = await getAllProjects();
-    let totalStale = 0;
-    let totalDeleted = 0;
-    for (const project of projects) {
-        const stale = await getStaleMemories({
-            olderThanDays,
-            confidenceLevels,
-            minImportance,
-            projectId: project.id,
-        });
-        totalStale += stale.length;
-        if (dryRun) {
-            logger.info(`[AutoClean] Would delete ${stale.length} stale memories in ${project.path}`);
-        }
-        else {
-            for (const memory of stale) {
-                if (!memory.isPinned) {
-                    await deleteMemoryPermanently(memory.id);
-                    totalDeleted++;
-                }
-            }
-            logger.info(`[AutoClean] Deleted ${stale.length} stale memories in ${project.path}`);
-        }
-    }
-    return {
-        recordsProcessed: dryRun ? totalStale : totalDeleted,
-        summary: {
-            mode: dryRun ? 'dry-run' : 'deleted',
-            projectsScanned: projects.length,
-            memoriesAffected: dryRun ? totalStale : totalDeleted,
-            criteria: { olderThanDays, confidenceLevels, minImportance },
-        },
-    };
-};
-registerJobHandler('auto_clean', autoCleanHandler);
-export async function initializeScheduler() {
-    if (!config.cronEnabled) {
-        logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
-        return;
-    }
-    const db = await getDb();
-    if (!db) {
-        logger.warn('[Scheduler] Database not available, scheduler disabled');
-        return;
-    }
-    try {
-        await ensureDefaultJobs(db);
-        // Check for missed jobs (catch-up after machine wake from sleep)
-        await checkMissedJobs();
-        const sqliteDb = db;
-        const jobs = await sqliteDb
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.enabled, true));
-        for (const job of jobs) {
-            await scheduleJob(job);
-        }
-        logger.info(`[Scheduler] Initialized with ${jobs.length} scheduled jobs`);
-    }
-    catch (error) {
-        logger.error('[Scheduler] Failed to initialize:', error);
-    }
-}
-/**
- * Check for missed jobs and execute catch-up if needed
- * Called on scheduler initialization (including after machine wake from sleep)
- */
-async function checkMissedJobs() {
-    try {
-        const db = await getDb();
-        if (!db)
-            return;
-        const sqliteDb = db;
-        const jobs = await sqliteDb
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.enabled, true));
-        const now = Date.now();
-        for (const job of jobs) {
-            const intervalMs = JOB_INTERVALS[job.jobType];
-            if (!intervalMs)
-                continue;
-            const lastRun = job.lastRunAt ? new Date(job.lastRunAt).getTime() : 0;
-            const elapsed = lastRun > 0 ? now - lastRun : intervalMs * 2; // If never run, treat as overdue
-            const gracePeriod = intervalMs * 1.5; // 1.5x interval grace
-            if (elapsed > gracePeriod) {
-                logger.info(`[Scheduler] Catch-up needed for ${job.jobName}, elapsed ${Math.round(elapsed / (60 * 60 * 1000))}h (grace: ${Math.round(gracePeriod / (60 * 60 * 1000))}h)`);
-                // Execute catch-up
-                const handler = jobHandlers.get(job.jobName);
-                if (handler) {
-                    try {
-                        const startedAt = new Date();
-                        const context = {
-                            jobId: job.id,
-                            jobName: job.jobName,
-                            jobType: job.jobType,
-                            config: typeof job.jobConfig === 'string'
-                                ? JSON.parse(job.jobConfig)
-                                : job.jobConfig ?? {},
-                            startedAt,
-                        };
-                        await handler(context);
-                        // Record successful catch-up run
-                        const completedAt = new Date();
-                        await sqliteDb
-                            .update(maintenanceJobs)
-                            .set({
-                            lastRunAt: completedAt,
-                            lastRunStatus: 'success',
-                            lastRunDuration: completedAt.getTime() - startedAt.getTime(),
-                        })
-                            .where(eq(maintenanceJobs.id, job.id));
-                        logger.info(`[Scheduler] Catch-up completed for ${job.jobName}`);
-                    }
-                    catch (catchError) {
-                        const msg = catchError instanceof Error ? catchError.message : String(catchError);
-                        logger.error(`[Scheduler] Catch-up failed for ${job.jobName}:`, msg);
-                        await sqliteDb
-                            .update(maintenanceJobs)
-                            .set({
-                            lastRunAt: new Date(),
-                            lastRunStatus: 'failed',
-                            lastRunError: msg,
-                        })
-                            .where(eq(maintenanceJobs.id, job.id));
-                    }
-                }
-            }
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logger.error('[Scheduler] Error checking missed jobs:', msg);
-    }
-}
-async function ensureDefaultJobs(db) {
-    const defaultJobs = [
-        {
-            jobName: 'decay_maintenance',
-            jobType: 'hourly',
-            cronExpression: '0 * * * *', // Run every hour at :00
-            enabled: true,
-            jobConfig: { applyDecay: true, updateTiers: true, evictOld: true },
-        },
-        {
-            jobName: 'belief_decay',
-            jobType: 'daily',
-            cronExpression: '0 4 * * *', // Run daily at 4 AM
-            enabled: true,
-            jobConfig: { applyBeliefDecay: true },
-        },
-        {
-            jobName: 'nightly_maintenance',
-            jobType: 'nightly',
-            cronExpression: '0 2 * * *',
-            enabled: true,
-            jobConfig: { mergeDuplicates: true, boostAccessed: true, decayScores: true },
-        },
-        {
-            jobName: 'weekly_maintenance',
-            jobType: 'weekly',
-            cronExpression: '0 3 * * 0',
-            enabled: true,
-            jobConfig: { regenerateSummaries: true, archiveStale: true, cleanupOrphaned: true },
-        },
-        {
-            jobName: 'self_iteration',
-            jobType: 'hourly',
-            cronExpression: '30 * * * *', // Run every hour at :30
-            enabled: true,
-            jobConfig: { minMessageCount: 5, maxMessagesToProcess: 50 },
-        },
-        {
-            jobName: 'auto_clean',
-            jobType: 'daily',
-            cronExpression: '0 3 * * *', // Run daily at 3 AM
-            enabled: true,
-            jobConfig: {
-                enabled: true,
-                olderThanDays: 30,
-                confidenceLevel: ['outdated', 'speculative'],
-                minImportance: 40,
-                dryRun: true, // Start with dry-run for safety
-            },
-        },
-    ];
-    for (const job of defaultJobs) {
-        let existing;
-        try {
-            existing = await db
-                .select()
-                .from(maintenanceJobs)
-                .where(eq(maintenanceJobs.jobName, job.jobName))
-                .limit(1);
-        }
-        catch (queryError) {
-            logger.error(`[Scheduler] Query failed for job ${job.jobName}:`, queryError.message);
-            // Try raw SQL fallback
-            try {
-                const rawDb = db.$client;
-                if (rawDb && typeof rawDb.prepare === 'function') {
-                    existing = rawDb.prepare('SELECT * FROM maintenance_jobs WHERE job_name = ?').all(job.jobName);
-                }
-            }
-            catch (fallbackError) {
-                logger.error(`[Scheduler] Fallback query also failed:`, fallbackError.message);
-                throw queryError;
-            }
-        }
-        if (existing.length === 0) {
-            try {
-                await db.insert(maintenanceJobs).values({
-                    jobName: job.jobName,
-                    jobType: job.jobType,
-                    cronExpression: job.cronExpression,
-                    enabled: job.enabled,
-                    jobConfig: job.jobConfig,
-                    totalRuns: 0,
-                    successCount: 0,
-                    failureCount: 0,
-                    lastRunAt: null,
-                    nextRunAt: null,
-                    lastRunDuration: null,
-                    lastRunStatus: null,
-                    lastRunError: null,
-                });
-            }
-            catch (insertError) {
-                // Fallback to raw SQL if drizzle insert fails
-                logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
-                const rawDb = db.$client;
-                if (rawDb && typeof rawDb.prepare === 'function') {
-                    const stmt = rawDb.prepare(`
-            INSERT INTO maintenance_jobs 
-            (id, job_name, job_type, cron_expression, enabled, job_config, 
-             total_runs, success_count, failure_count, last_run_at, next_run_at, 
-             last_run_duration, last_run_status, last_run_error)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `);
-                    stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
-                }
-            }
-            logger.info(`[Scheduler] Created default job: ${job.jobName}`);
-            // Register self-iteration handler
-            if (job.jobName === 'self_iteration') {
-                registerJobHandler('self_iteration', selfIterationHandler);
-            }
-        }
-    }
-}
-export async function scheduleJob(job) {
-    const existingTask = activeTasks.get(job.jobName);
-    if (existingTask) {
-        existingTask.stop();
-        activeTasks.delete(job.jobName);
-    }
-    if (!job.enabled || !job.cronExpression) {
-        logger.debug(`[Scheduler] Job ${job.jobName} is disabled or has no cron expression`);
-        return;
-    }
-    if (!cron.validate(job.cronExpression)) {
-        logger.error(`[Scheduler] Invalid cron expression for ${job.jobName}: ${job.cronExpression}`);
-        return;
-    }
-    const task = cron.schedule(job.cronExpression, async () => {
-        await executeJob(job);
-    }, {
-        timezone: 'UTC',
-    });
-    activeTasks.set(job.jobName, task);
-    const nextRun = getNextRunTime(job.cronExpression);
-    const db = await getDb();
-    if (db) {
-        const sqliteDb = db;
-        await sqliteDb
-            .update(maintenanceJobs)
-            .set({ nextRunAt: nextRun })
-            .where(eq(maintenanceJobs.id, job.id));
-    }
-    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}${nextRun ? `, next run: ${nextRun.toISOString()}` : ''}`);
-}
-export async function executeJob(job) {
-    const db = await getDb();
-    const handler = jobHandlers.get(job.jobName);
-    if (!handler) {
-        logger.warn(`[Scheduler] No handler registered for job: ${job.jobName}`);
-        return;
-    }
-    const startedAt = new Date();
-    let status = 'success';
-    let error = null;
-    let recordsProcessed = 0;
-    let summary = {};
-    try {
-        logger.info(`[Scheduler] Executing job: ${job.jobName}`);
-        const result = await handler({
-            jobId: job.id,
-            jobName: job.jobName,
-            jobType: job.jobType,
-            config: job.jobConfig || {},
-            startedAt,
-        });
-        recordsProcessed = result.recordsProcessed;
-        summary = result.summary;
-        logger.info(`[Scheduler] Job ${job.jobName} completed: ${recordsProcessed} records processed`);
-    }
-    catch (err) {
-        status = 'failed';
-        error = err instanceof Error ? err.message : String(err);
-        logger.error(`[Scheduler] Job ${job.jobName} failed:`, error);
-    }
-    const completedAt = new Date();
-    if (db) {
-        const sqliteDb = db;
-        const [currentJob] = await sqliteDb
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.id, job.id));
-        await sqliteDb
-            .update(maintenanceJobs)
-            .set({
-            lastRunAt: startedAt,
-            lastRunStatus: status,
-            lastRunError: error,
-            lastRunDuration: completedAt.getTime() - startedAt.getTime(),
-            totalRuns: (currentJob?.totalRuns ?? 0) + 1,
-            successCount: status === 'success' ? (currentJob?.successCount ?? 0) + 1 : currentJob?.successCount,
-            failureCount: status === 'failed' ? (currentJob?.failureCount ?? 0) + 1 : currentJob?.failureCount,
-            nextRunAt: job.cronExpression ? getNextRunTime(job.cronExpression) : null,
-        })
-            .where(eq(maintenanceJobs.id, job.id));
-        await sqliteDb.insert(maintenanceJobHistory).values({
-            jobId: job.id,
-            startedAt,
-            completedAt,
-            duration: completedAt.getTime() - startedAt.getTime(),
-            status,
-            error,
-            recordsProcessed,
-            resultSummary: summary,
-        });
-    }
-}
-function getNextRunTime(cronExpression) {
-    try {
-        const now = new Date();
-        const parts = cronExpression.split(' ');
-        // Daily jobs: MM HH * * *
-        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*' && parts[1] !== '*') {
-            const next = new Date(now);
-            next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
-            if (next <= now)
-                next.setDate(next.getDate() + 1);
-            return next;
-        }
-        // Hourly jobs: MM * * * *
-        if (parts[1] === '*' && parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
-            const next = new Date(now);
-            next.setMinutes(parseInt(parts[0]), 0, 0);
-            if (next <= now)
-                next.setHours(next.getHours() + 1);
-            return next;
-        }
-        // Weekly jobs: MM HH * * D
-        if (parts[4] !== '*') {
-            const dayOfWeek = parseInt(parts[4]);
-            const next = new Date(now);
-            next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
-            const daysUntil = (dayOfWeek - next.getDay() + 7) % 7;
-            next.setDate(next.getDate() + (daysUntil === 0 && next > now ? 7 : daysUntil));
-            return next;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function getScheduledJobs() {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const sqliteDb = db;
-    const jobs = await sqliteDb.select().from(maintenanceJobs);
-    return jobs.map((job) => ({
-        id: job.id,
-        jobName: job.jobName,
-        jobType: job.jobType,
-        cronExpression: job.cronExpression || '',
-        enabled: job.enabled ?? true,
-        lastRunAt: job.lastRunAt ? new Date(job.lastRunAt) : null,
-        nextRunAt: job.nextRunAt ? new Date(job.nextRunAt) : null,
-        jobConfig: job.jobConfig || {},
-    }));
-}
-export async function getOverdueJobs() {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const now = new Date();
-    const sqliteDb = db;
-    const jobs = await sqliteDb.select().from(maintenanceJobs);
-    return jobs
-        .filter((job) => {
-        if (!job.enabled)
-            return false;
-        if (!job.nextRunAt)
-            return true;
-        return new Date(job.nextRunAt) < now;
-    })
-        .map((job) => ({
-        id: job.id,
-        jobName: job.jobName,
-        jobType: job.jobType,
-        cronExpression: job.cronExpression || '',
-        enabled: job.enabled ?? true,
-        lastRunAt: job.lastRunAt ? new Date(job.lastRunAt) : null,
-        nextRunAt: job.nextRunAt ? new Date(job.nextRunAt) : null,
-        jobConfig: job.jobConfig || {},
-    }));
-}
-export function stopAllJobs() {
-    for (const [name, task] of activeTasks) {
-        task.stop();
-        logger.info(`[Scheduler] Stopped job: ${name}`);
-    }
-    activeTasks.clear();
-}
-//# sourceMappingURL=cron-scheduler.js.map

package/dist/core/scheduler/heartbeat.d.ts

@@ -1,11 +0,0 @@
-/** Heartbeat - Fallback job execution via heartbeat checking */
-export declare function heartbeat(): Promise<{
-    checked: boolean;
-    overdueCount: number;
-    executedJobs: string[];
-}>;
-export declare function startHeartbeatChecking(): void;
-export declare function stopHeartbeatChecking(): void;
-export declare function getLastHeartbeat(): Date | null;
-export declare function isHeartbeatDue(): boolean;
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/core/scheduler/heartbeat.js

@@ -1,73 +0,0 @@
-/** Heartbeat - Fallback job execution via heartbeat checking */
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { getOverdueJobs, executeJob } from './cron-scheduler.js';
-let lastHeartbeat = null;
-let heartbeatInterval = null;
-export async function heartbeat() {
-    const result = {
-        checked: false,
-        overdueCount: 0,
-        executedJobs: [],
-    };
-    if (config.schedulerMode === 'cron' && config.cronEnabled) {
-        logger.debug('[Heartbeat] Cron mode active, skipping heartbeat check');
-        return result;
-    }
-    lastHeartbeat = new Date();
-    result.checked = true;
-    try {
-        const overdueJobs = await getOverdueJobs();
-        result.overdueCount = overdueJobs.length;
-        if (overdueJobs.length === 0) {
-            logger.debug('[Heartbeat] No overdue jobs');
-            return result;
-        }
-        logger.info(`[Heartbeat] Found ${overdueJobs.length} overdue jobs, executing...`);
-        for (const job of overdueJobs) {
-            try {
-                await executeJob(job);
-                result.executedJobs.push(job.jobName);
-                logger.info(`[Heartbeat] Executed overdue job: ${job.jobName}`);
-            }
-            catch (error) {
-                logger.error(`[Heartbeat] Failed to execute job ${job.jobName}:`, error);
-            }
-        }
-        return result;
-    }
-    catch (error) {
-        logger.error('[Heartbeat] Failed to check overdue jobs:', error);
-        return result;
-    }
-}
-export function startHeartbeatChecking() {
-    if (config.schedulerMode === 'cron' && config.cronEnabled) {
-        logger.info('[Heartbeat] Cron mode active, heartbeat checking disabled');
-        return;
-    }
-    stopHeartbeatChecking();
-    heartbeatInterval = setInterval(async () => {
-        await heartbeat();
-    }, config.heartbeatInterval);
-    logger.info(`[Heartbeat] Started periodic checking (interval: ${config.heartbeatInterval}ms)`);
-    heartbeat().catch(err => {
-        logger.error('[Heartbeat] Initial heartbeat failed:', err);
-    });
-}
-export function stopHeartbeatChecking() {
-    if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-        logger.info('[Heartbeat] Stopped periodic checking');
-    }
-}
-export function getLastHeartbeat() {
-    return lastHeartbeat;
-}
-export function isHeartbeatDue() {
-    if (!lastHeartbeat)
-        return true;
-    return Date.now() - lastHeartbeat.getTime() > config.heartbeatInterval;
-}
-//# sourceMappingURL=heartbeat.js.map

package/dist/core/scheduler/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Scheduler Module
- * Cron-based job scheduling with heartbeat fallback
- */
-export * from './cron-scheduler.js';
-export * from './heartbeat.js';
-export * from './job-runner.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/scheduler/index.js

@@ -1,8 +0,0 @@
-/**
- * Scheduler Module
- * Cron-based job scheduling with heartbeat fallback
- */
-export * from './cron-scheduler.js';
-export * from './heartbeat.js';
-export * from './job-runner.js';
-//# sourceMappingURL=index.js.map

package/dist/core/scheduler/job-runner.d.ts

@@ -1,11 +0,0 @@
-/** Job Runner - Maintenance job implementations */
-import { type JobExecutionContext } from './cron-scheduler.js';
-export declare function runNightlyJob(context: JobExecutionContext): Promise<{
-    recordsProcessed: number;
-    summary: Record<string, unknown>;
-}>;
-export declare function runWeeklyJob(context: JobExecutionContext): Promise<{
-    recordsProcessed: number;
-    summary: Record<string, unknown>;
-}>;
-//# sourceMappingURL=job-runner.d.ts.map