squish-memory 1.1.5 → 1.2.1

package/dist/core/lifecycle.js

@@ -1,302 +0,0 @@
-/**
- * Memory Lifecycle Management
- * Implements sector-based decay, tier classification, and eviction policies
- *
- * Decay Formula: newScore = importanceScore * (1 - decayRate/100)^days
- * - decayRate: per-memory integer (e.g., 30 = 30% decay per decay cycle)
- * - days: days since lastDecayAt
- * - Tier demotion occurs when score drops below decayThreshold
- * - Cold memories below threshold get status = 'expired'
- */
-import { and, eq, lt, inArray } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { config } from '../config.js';
-import { logger } from './logger.js';
-import { triggerTierChange, triggerDecayApplied } from './memory/hooks.js';
-/**
- * Default decay intervals by sector (days until decay check)
- * These determine how often memories in each sector are evaluated for decay
- */
-const SECTOR_DECAY_INTERVAL_DAYS = {
-    episodic: 30,
-    semantic: 90,
-    procedural: 180,
-    autobiographical: 365,
-    working: 7,
-};
-/**
- * Default decay rates by memory type (percentage per decay cycle)
- * Used as fallback when memory.decayRate is not set
- */
-const DEFAULT_DECAY_RATES = {
-    observation: 5,
-    fact: 3,
-    decision: 2,
-    context: 4,
-    preference: 3,
-    note: 5,
-    reflection: 2,
-};
-const TIER_THRESHOLDS = {
-    hot: { recency: 7, coactivation: 10, salience: 70 },
-    warm: { recency: 30, coactivation: 5, salience: 50 },
-    cold: { recency: Infinity, coactivation: 0, salience: 0 },
-};
-/**
- * Run full lifecycle maintenance on all memories
- */
-export async function runLifecycleMaintenance(projectId) {
-    if (!config.lifecycleEnabled) {
-        return { decayed: 0, evicted: 0, promoted: 0, tierChanges: { hot: 0, warm: 0, cold: 0 }, expired: 0 };
-    }
-    const stats = {
-        decayed: 0,
-        evicted: 0,
-        promoted: 0,
-        tierChanges: { hot: 0, warm: 0, cold: 0 },
-        expired: 0,
-    };
-    try {
-        await applyDecay(projectId, stats);
-        await updateTiers(projectId, stats);
-        await evictOldMemories(projectId, stats);
-    }
-    catch (error) {
-        logger.error('Lifecycle maintenance error', error);
-    }
-    return stats;
-}
-/**
- * Apply decay to memories using per-memory decay rate formula
- *
- * Formula: newScore = importanceScore * (1 - decayRate/100)^days
- * - Uses per-memory decayRate (stored as integer percentage, e.g., 30 = 30%)
- * - Calculates days since lastDecayAt
- * - Demotes tier when score drops below decayThreshold
- * - Sets status = 'expired' for cold memories below threshold
- */
-async function applyDecay(projectId, stats) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        const decayThreshold = config.decayThreshold || 0.1;
-        // Fetch memories that need decay processing (not protected, not expired)
-        let whereClause;
-        const conditions = [
-            eq(schema.memories.isProtected, false),
-            eq(schema.memories.status, 'active'),
-        ];
-        if (projectId) {
-            conditions.push(eq(schema.memories.projectId, projectId));
-        }
-        whereClause = and(...conditions);
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(whereClause)
-            .limit(10000);
-        let decayed = 0;
-        let expired = 0;
-        const expiredIds = [];
-        for (const memory of memories) {
-            // Get decay rate for this memory (fallback to type-based default)
-            const decayRate = memory.decayRate || DEFAULT_DECAY_RATES[memory.type] || 5;
-            // Calculate days since last decay
-            const lastDecayAt = memory.lastDecayAt ? new Date(memory.lastDecayAt) : new Date(memory.createdAt);
-            const daysSinceDecay = Math.max(0, (now.getTime() - lastDecayAt.getTime()) / (24 * 60 * 60 * 1000));
-            // Skip if not enough time has passed for this sector
-            const sectorInterval = SECTOR_DECAY_INTERVAL_DAYS[memory.sector] || 30;
-            if (daysSinceDecay < sectorInterval) {
-                continue;
-            }
-            // Apply decay formula: newScore = oldScore * (1 - decayRate/100)^days
-            const currentScore = memory.importanceScore || memory.relevanceScore || 50;
-            const decayMultiplier = Math.pow(1 - decayRate / 100, daysSinceDecay / sectorInterval);
-            const newScore = Math.max(0, Math.round(currentScore * decayMultiplier));
-            // Check if memory should expire (cold tier + below threshold)
-            const shouldExpire = memory.tier === 'cold' && newScore < (decayThreshold * 100);
-            if (shouldExpire) {
-                expiredIds.push(memory.id);
-                expired++;
-                logger.debug('Memory expiring', { id: memory.id, score: newScore, tier: memory.tier });
-            }
-            else if (newScore !== currentScore) {
-                // Only update if score changed
-                await db
-                    .update(schema.memories)
-                    .set({
-                    importanceScore: newScore,
-                    relevanceScore: newScore,
-                    lastDecayAt: now,
-                    updatedAt: now,
-                })
-                    .where(eq(schema.memories.id, memory.id));
-                decayed++;
-                // Trigger decay applied hook
-                try {
-                    await triggerDecayApplied({
-                        memoryId: memory.id,
-                        content: memory.content,
-                        type: memory.type,
-                        tags: typeof memory.tags === 'string' ? memory.tags.split(',') : [],
-                        project: memory.projectId || undefined,
-                        source: memory.source || undefined,
-                        tier: memory.tier,
-                        importance: newScore,
-                        oldScore: currentScore,
-                        newScore: newScore,
-                    });
-                }
-                catch (hookError) {
-                    logger.error('Error triggering decayApplied hook', hookError);
-                }
-            }
-        }
-        // Batch expire memories
-        if (expiredIds.length > 0) {
-            await db
-                .update(schema.memories)
-                .set({
-                status: 'expired',
-                updatedAt: now,
-            })
-                .where(inArray(schema.memories.id, expiredIds));
-        }
-        stats.decayed += decayed;
-        stats.expired += expired;
-        logger.info('Decay applied', { decayed, expired, total: memories.length });
-    }
-    catch (error) {
-        logger.error('Error applying decay', error);
-    }
-}
-/**
- * Update memory tiers based on recency, coactivation, and salience
- */
-async function updateTiers(projectId, stats) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Fetch all memories to classify
-        const where = projectId ? eq(schema.memories.projectId, projectId) : undefined;
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(where)
-            .limit(10000); // Process larger batches now
-        // Calculate tiers in memory
-        const tierAssignments = new Map();
-        const tierCounts = { hot: 0, warm: 0, cold: 0 };
-        for (const memory of memories) {
-            const recencyDays = (now.getTime() - new Date(memory.createdAt).getTime()) / (24 * 60 * 60 * 1000);
-            const coactivation = memory.coactivationScore || 0;
-            const salience = memory.relevanceScore || 50;
-            let newTier = 'cold';
-            if (recencyDays <= TIER_THRESHOLDS.hot.recency &&
-                coactivation >= TIER_THRESHOLDS.hot.coactivation &&
-                salience >= TIER_THRESHOLDS.hot.salience) {
-                newTier = 'hot';
-            }
-            else if (recencyDays <= TIER_THRESHOLDS.warm.recency &&
-                coactivation >= TIER_THRESHOLDS.warm.coactivation &&
-                salience >= TIER_THRESHOLDS.warm.salience) {
-                newTier = 'warm';
-            }
-            if (newTier !== memory.tier) {
-                tierAssignments.set(memory.id, newTier);
-                tierCounts[newTier]++;
-            }
-        }
-        if (tierAssignments.size === 0)
-            return;
-        // Group by tier for efficient batched updates
-        const hotIds = Array.from(tierAssignments.entries())
-            .filter(([_, tier]) => tier === 'hot')
-            .map(([id]) => id);
-        const warmIds = Array.from(tierAssignments.entries())
-            .filter(([_, tier]) => tier === 'warm')
-            .map(([id]) => id);
-        const coldIds = Array.from(tierAssignments.entries())
-            .filter(([_, tier]) => tier === 'cold')
-            .map(([id]) => id);
-        // Execute batched updates instead of individual queries
-        if (hotIds.length > 0) {
-            await db
-                .update(schema.memories)
-                .set({ tier: 'hot', updatedAt: now })
-                .where(inArray(schema.memories.id, hotIds));
-        }
-        if (warmIds.length > 0) {
-            await db
-                .update(schema.memories)
-                .set({ tier: 'warm', updatedAt: now })
-                .where(inArray(schema.memories.id, warmIds));
-        }
-        if (coldIds.length > 0) {
-            await db
-                .update(schema.memories)
-                .set({ tier: 'cold', updatedAt: now })
-                .where(inArray(schema.memories.id, coldIds));
-        }
-        // Trigger tier change hooks for each memory that changed tier
-        if (tierAssignments.size > 0) {
-            for (const memory of memories) {
-                const newTier = tierAssignments.get(memory.id);
-                if (newTier && newTier !== memory.tier) {
-                    try {
-                        await triggerTierChange({
-                            memoryId: memory.id,
-                            content: memory.content,
-                            type: memory.type,
-                            tags: typeof memory.tags === 'string' ? memory.tags.split(',') : [],
-                            project: memory.projectId || undefined,
-                            source: memory.source || undefined,
-                            tier: newTier,
-                            importance: memory.importanceScore || memory.relevanceScore || 50,
-                            oldTier: memory.tier,
-                            newTier: newTier,
-                        });
-                    }
-                    catch (hookError) {
-                        logger.error('Error triggering tierChange hook', hookError);
-                    }
-                }
-            }
-        }
-        // Update stats
-        stats.tierChanges.hot = tierCounts.hot;
-        stats.tierChanges.warm = tierCounts.warm;
-        stats.tierChanges.cold = tierCounts.cold;
-        logger.debug('Tier updates complete', {
-            hot: tierCounts.hot,
-            warm: tierCounts.warm,
-            cold: tierCounts.cold,
-        });
-    }
-    catch (error) {
-        logger.error('Error updating tiers', error);
-    }
-}
-/**
- * Evict old, cold memories with low relevance
- */
-async function evictOldMemories(projectId, stats) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const evictionThreshold = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000); // 180 days
-        const where = projectId
-            ? and(eq(schema.memories.projectId, projectId), lt(schema.memories.createdAt, evictionThreshold), eq(schema.memories.isProtected, false), eq(schema.memories.isPinned, false), eq(schema.memories.tier, 'cold'), lt(schema.memories.relevanceScore, 20) // Very low relevance
-            )
-            : and(lt(schema.memories.createdAt, evictionThreshold), eq(schema.memories.isProtected, false), eq(schema.memories.isPinned, false), eq(schema.memories.tier, 'cold'), lt(schema.memories.relevanceScore, 20));
-        const result = await db.delete(schema.memories).where(where);
-        stats.evicted = result?.rowCount || 0;
-    }
-    catch (error) {
-        logger.error('Error evicting memories', error);
-    }
-}
-//# sourceMappingURL=lifecycle.js.map

package/dist/core/local-embeddings.d.ts

@@ -1,11 +0,0 @@
-/**
- * Utility functions for local embeddings
- * Note: Actual embedding generation is in core/embeddings.ts
- */
-import { cosineSimilarity as vectorCosineSimilarity } from './utils/vector-operations.js';
-/**
- * @deprecated Use cosineSimilarity from core/utils/vector-operations.ts directly.
- *   This re-export is for backward compatibility and will be removed in v1.2.0.
- */
-export declare const cosineSimilarity: typeof vectorCosineSimilarity;
-//# sourceMappingURL=local-embeddings.d.ts.map

package/dist/core/logger.d.ts

@@ -1,16 +0,0 @@
-interface LogContext {
-    [key: string]: any;
-}
-declare class Logger {
-    private prefix;
-    private debugEnabled;
-    constructor(prefix?: string);
-    private format;
-    info(message: string, context?: LogContext): void;
-    warn(message: string, context?: LogContext): void;
-    error(message: string, error?: Error | any, context?: LogContext): void;
-    debug(message: string, context?: LogContext): void;
-}
-export declare const logger: Logger;
-export {};
-//# sourceMappingURL=logger.d.ts.map

package/dist/core/logger.js

@@ -1,40 +0,0 @@
-function isQuietMode() {
-    return process.env.SQUISH_QUIET !== 'false' &&
-        process.env.DEBUG !== 'true' &&
-        process.env.DEBUG !== '1';
-}
-class Logger {
-    prefix;
-    debugEnabled;
-    constructor(prefix = 'squish') {
-        this.prefix = prefix;
-        this.debugEnabled = process.env.DEBUG === 'true' || process.env.DEBUG === '1';
-    }
-    format(level, message, context) {
-        const timestamp = new Date().toISOString();
-        const ctx = context ? ` ${JSON.stringify(context)}` : '';
-        return `[${this.prefix}:${level}] ${message}${ctx}`;
-    }
-    info(message, context) {
-        if (!isQuietMode())
-            console.error(this.format('info', message, context));
-    }
-    warn(message, context) {
-        console.error(this.format('warn', message, context));
-    }
-    error(message, error, context) {
-        const errorMsg = error instanceof Error ? error.message : error;
-        const ctx = { ...context, error: errorMsg };
-        console.error(this.format('error', message, ctx));
-        if (error instanceof Error && error.stack) {
-            console.error(error.stack);
-        }
-    }
-    debug(message, context) {
-        if (this.debugEnabled) {
-            console.error(this.format('debug', message, context));
-        }
-    }
-}
-export const logger = new Logger();
-//# sourceMappingURL=logger.js.map

package/dist/core/mcp/client.d.ts

@@ -1,17 +0,0 @@
-import { MCPToolResult, MCPInitializeResponse } from './types.js';
-export declare class MCPClient {
-    private baseUrl;
-    private connected;
-    private serverInfo;
-    constructor(baseUrl?: string);
-    initialize(): Promise<MCPInitializeResponse>;
-    listTools(): Promise<any[]>;
-    callTool(name: string, args?: Record<string, any>): Promise<MCPToolResult>;
-    healthCheck(): Promise<boolean>;
-    isConnected(): boolean;
-    getServerInfo(): {
-        name: string;
-        version: string;
-    } | null;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/core/mcp/client.js

@@ -1,101 +0,0 @@
-import { logger } from '../logger.js';
-export class MCPClient {
-    baseUrl;
-    connected = false;
-    serverInfo = null;
-    constructor(baseUrl = 'http://localhost:8766') {
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-    }
-    async initialize() {
-        const request = {
-            protocolVersion: '2024-11-05',
-            capabilities: {
-                tools: {},
-            },
-            clientInfo: {
-                name: 'squish-mcp-client',
-                version: '0.9.0',
-            },
-        };
-        try {
-            const response = await fetch(`${this.baseUrl}/initialize`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(request),
-            });
-            if (!response.ok) {
-                throw new Error(`Initialize failed: ${response.statusText}`);
-            }
-            const result = await response.json();
-            this.serverInfo = result.serverInfo;
-            this.connected = true;
-            logger.info(`Connected to MCP server: ${result.serverInfo.name} v${result.serverInfo.version}`);
-            return result;
-        }
-        catch (error) {
-            logger.error('Failed to initialize MCP connection:', error);
-            throw error;
-        }
-    }
-    async listTools() {
-        try {
-            const response = await fetch(`${this.baseUrl}/tools/list`);
-            if (!response.ok) {
-                throw new Error(`List tools failed: ${response.statusText}`);
-            }
-            const data = await response.json();
-            return data.tools || [];
-        }
-        catch (error) {
-            logger.error('Failed to list tools:', error);
-            return [];
-        }
-    }
-    async callTool(name, args = {}) {
-        if (!this.connected) {
-            await this.initialize();
-        }
-        const toolCall = { name, arguments: args };
-        try {
-            const response = await fetch(`${this.baseUrl}/tools/call`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(toolCall),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`Tool call failed: ${response.statusText} - ${errorText}`);
-            }
-            const result = await response.json();
-            return result;
-        }
-        catch (error) {
-            logger.error(`Tool call error (${name}):`, error);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async healthCheck() {
-        try {
-            const response = await fetch(`${this.baseUrl}/health`, {
-                method: 'GET',
-            });
-            return response.ok;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    isConnected() {
-        return this.connected;
-    }
-    getServerInfo() {
-        return this.serverInfo;
-    }
-}
-//# sourceMappingURL=client.js.map

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

@@ -1,6 +0,0 @@
-export { MCPServer } from './server.js';
-export { MCPClient } from './client.js';
-export { SquishMCPServer, startMCPServer, stopMCPServer, getSquishMCPServer } from './standalone-server.js';
-export * from './types.js';
-export * from './tools.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/mcp/index.js

@@ -1,6 +0,0 @@
-export { MCPServer } from './server.js';
-export { MCPClient } from './client.js';
-export { SquishMCPServer, startMCPServer, stopMCPServer, getSquishMCPServer } from './standalone-server.js';
-export * from './types.js';
-export * from './tools.js';
-//# sourceMappingURL=index.js.map

package/dist/core/mcp/server.d.ts

@@ -1,18 +0,0 @@
-import { MCPToolDefinition } from './types.js';
-export declare class MCPServer {
-    private app;
-    private httpServer;
-    private tools;
-    private port;
-    private serverName;
-    private serverVersion;
-    constructor(port?: number, serverName?: string, serverVersion?: string);
-    private setupMiddleware;
-    private setupRoutes;
-    registerTool(definition: MCPToolDefinition): void;
-    registerTools(definitions: MCPToolDefinition[]): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getToolCount(): number;
-}
-//# sourceMappingURL=server.d.ts.map

package/dist/core/mcp/server.js

@@ -1,157 +0,0 @@
-import express from 'express';
-import cors from 'cors';
-import rateLimit from 'express-rate-limit';
-import { logger } from '../logger.js';
-export class MCPServer {
-    app = express();
-    httpServer = null;
-    tools = new Map();
-    port;
-    serverName;
-    serverVersion;
-    constructor(port = 8767, serverName = 'squish-mcp', serverVersion = '0.9.0') {
-        this.port = port;
-        this.serverName = serverName;
-        this.serverVersion = serverVersion;
-        this.setupMiddleware();
-        this.setupRoutes();
-    }
-    setupMiddleware() {
-        const allowedOrigins = process.env.SQUISH_CORS_ORIGINS?.split(',').map(s => s.trim()) || ['http://localhost:*', 'http://127.0.0.1:*'];
-        const appCors = cors({
-            origin: (origin, callback) => {
-                if (!origin || allowedOrigins.some(allowed => {
-                    if (allowed.endsWith(':*')) {
-                        const prefix = allowed.slice(0, -1);
-                        return origin.startsWith(prefix);
-                    }
-                    return origin === allowed;
-                })) {
-                    callback(null, true);
-                }
-                else {
-                    callback(new Error('Not allowed by CORS'));
-                }
-            }
-        });
-        const limiter = rateLimit({
-            windowMs: 15 * 60 * 1000,
-            max: 100,
-            message: { error: 'Too many requests, please try again later.' },
-            standardHeaders: true,
-            legacyHeaders: false,
-        });
-        this.app.use(appCors);
-        this.app.use(limiter);
-        this.app.use(express.json());
-    }
-    setupRoutes() {
-        this.app.get('/sse', (req, res) => {
-            res.setHeader('Content-Type', 'text/event-stream');
-            res.setHeader('Cache-Control', 'no-cache');
-            res.setHeader('Connection', 'keep-alive');
-            res.flushHeaders();
-            res.write('data: {"type":"connected"}\n\n');
-            req.on('close', () => {
-                logger.info('SSE client disconnected');
-            });
-        });
-        this.app.post('/initialize', async (req, res) => {
-            try {
-                const request = req.body;
-                const response = {
-                    protocolVersion: '2024-11-05',
-                    capabilities: {
-                        tools: {
-                            listChanged: true,
-                        },
-                    },
-                    serverInfo: {
-                        name: this.serverName,
-                        version: this.serverVersion,
-                    },
-                };
-                res.json(response);
-            }
-            catch (error) {
-                logger.error('Initialize error:', error);
-                res.status(400).json({ error: 'Invalid initialize request' });
-            }
-        });
-        this.app.get('/tools/list', (req, res) => {
-            const tools = Array.from(this.tools.values()).map(def => def.tool);
-            res.json({ tools });
-        });
-        this.app.post('/tools/call', async (req, res) => {
-            try {
-                const { name, arguments: args } = req.body;
-                if (!name || typeof name !== 'string') {
-                    return res.status(400).json({ error: 'Tool name required' });
-                }
-                const toolDef = this.tools.get(name);
-                if (!toolDef) {
-                    return res.status(404).json({ error: `Tool not found: ${name}` });
-                }
-                const result = await toolDef.handler(args || {});
-                res.json(result);
-            }
-            catch (error) {
-                logger.error('Tool call error:', error);
-                res.status(500).json({
-                    error: error instanceof Error ? error.message : 'Tool execution failed'
-                });
-            }
-        });
-        this.app.get('/health', (req, res) => {
-            res.json({
-                status: 'ok',
-                server: this.serverName,
-                version: this.serverVersion,
-                tools: this.tools.size
-            });
-        });
-    }
-    registerTool(definition) {
-        this.tools.set(definition.tool.name, definition);
-        logger.info(`Registered MCP tool: ${definition.tool.name}`);
-    }
-    registerTools(definitions) {
-        definitions.forEach(def => this.registerTool(def));
-    }
-    async start() {
-        return new Promise((resolve, reject) => {
-            this.httpServer = this.app.listen(this.port, () => {
-                logger.info(`MCP server listening on port ${this.port}`);
-                logger.info(`SSE endpoint: http://localhost:${this.port}/sse`);
-                logger.info(`Tools available: ${this.tools.size}`);
-                resolve();
-            });
-            this.httpServer.on('error', (error) => {
-                logger.error('MCP server error:', error);
-                reject(error);
-            });
-        });
-    }
-    async stop() {
-        return new Promise((resolve, reject) => {
-            if (!this.httpServer) {
-                resolve();
-                return;
-            }
-            this.httpServer.close((error) => {
-                if (error) {
-                    logger.error('Error stopping MCP server:', error);
-                    reject(error);
-                }
-                else {
-                    logger.info('MCP server stopped');
-                    resolve();
-                }
-            });
-        });
-    }
-    getToolCount() {
-        return this.tools.size;
-    }
-}
-//# sourceMappingURL=server.js.map