squish-memory 1.2.0 → 1.2.1

package/dist/core/lib/validation.js

@@ -1,151 +0,0 @@
-/**
- * Input validation utilities for Squish
- * Consolidates scattered validation patterns into a unified module
- */
-import { normalizeTags } from '../memory/serialization.js';
-/**
- * Validate and normalize a limit value with bounds checking
- */
-export function validateLimit(value, defaultValue = 20, min = 1, max = 100) {
-    // Handle undefined, null, empty string
-    if (value === undefined || value === null || value === '') {
-        return defaultValue;
-    }
-    // Convert string to number, truncate decimals
-    let num;
-    if (typeof value === 'string') {
-        const parsed = parseInt(value, 10);
-        if (isNaN(parsed)) {
-            return NaN;
-        }
-        num = parsed;
-    }
-    else {
-        // Truncate decimals for numbers
-        num = Math.trunc(value);
-    }
-    // Handle NaN
-    if (isNaN(num)) {
-        return NaN;
-    }
-    // Clamp to bounds
-    return Math.min(Math.max(num, min), max);
-}
-/**
- * Parse an integer with bounds checking
- */
-export function parseIntBounded(value, defaultValue, min, max) {
-    return validateLimit(value, defaultValue, min, max);
-}
-/**
- * Validate a project path
- */
-export async function validateProjectPath(path, options) {
-    const { createIfMissing = false, require: requireProject = false } = options || {};
-    // If path is undefined, throw if required or return current directory
-    if (path === undefined || path === '') {
-        if (requireProject) {
-            throw new Error('Project path is required');
-        }
-        return process.cwd();
-    }
-    // Resolve to absolute path
-    const absolutePath = path.startsWith('/') || /^[a-zA-Z]:\\/.test(path)
-        ? path
-        : path.startsWith('~')
-            ? path.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '')
-            : path.startsWith('.')
-                ? path
-                : path;
-    // Check if project exists in database
-    const { getProjectByPath } = await import('../projects.js');
-    const existingProject = await getProjectByPath(absolutePath);
-    if (existingProject) {
-        return absolutePath;
-    }
-    // Project doesn't exist
-    if (requireProject) {
-        throw new Error(`Project not found: ${absolutePath}`);
-    }
-    if (createIfMissing) {
-        const { ensureProject } = await import('../projects.js');
-        await ensureProject(absolutePath);
-        return absolutePath;
-    }
-    // Return the path even if it doesn't exist in database (for non-db validation)
-    return absolutePath;
-}
-/**
- * Validate a UUID
- */
-export function validateUuid(id) {
-    if (typeof id !== 'string' || !id) {
-        return false;
-    }
-    // UUID v4/v5 regex pattern (8-4-4-4-12 hex digits)
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    return uuidRegex.test(id);
-}
-/**
- * Require a valid UUID, throws if invalid
- */
-export function requireUuid(id) {
-    if (!validateUuid(id)) {
-        throw new Error('Invalid UUID');
-    }
-    return id;
-}
-/**
- * Validate a date value
- *
- * @param value - The date to validate (string, Date, number, or undefined)
- * @returns Date object if valid, null otherwise
- */
-export function validateDate(value) {
-    if (!value) {
-        return null;
-    }
-    try {
-        let date;
-        if (value instanceof Date) {
-            date = value;
-        }
-        else if (typeof value === 'number') {
-            // Handle both milliseconds and seconds timestamps
-            if (value > 100000000000000) {
-                // Microseconds, convert to milliseconds
-                date = new Date(value / 1000);
-            }
-            else if (value > 1000000000000) {
-                // Milliseconds
-                date = new Date(value);
-            }
-            else if (value >= 0) {
-                // Seconds
-                date = new Date(value * 1000);
-            }
-            else {
-                return null;
-            }
-        }
-        else if (typeof value === 'string') {
-            date = new Date(value);
-        }
-        else {
-            return null;
-        }
-        // Check if date is valid
-        if (isNaN(date.getTime())) {
-            return null;
-        }
-        return date;
-    }
-    catch {
-        return null;
-    }
-}
-// Re-export normalizeTags for tag validation
-export { normalizeTags };
-// Re-export clampLimit for backward compatibility
-export { clampLimit } from './utils.js';
-//# sourceMappingURL=validation.js.map

package/dist/core/lifecycle.d.ts

@@ -1,25 +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'
- */
-export interface LifecycleStats {
-    decayed: number;
-    evicted: number;
-    promoted: number;
-    tierChanges: {
-        hot: number;
-        cold: number;
-    };
-    expired: number;
-}
-/**
- * Run full lifecycle maintenance on all memories
- */
-export declare function runLifecycleMaintenance(projectId?: string): Promise<LifecycleStats>;
-//# sourceMappingURL=lifecycle.d.ts.map

package/dist/core/lifecycle.js

@@ -1,292 +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
- * Can be configured via config.sectorDecayIntervals
- */
-const SECTOR_DECAY_INTERVAL_DAYS = {
-    episodic: config.sectorDecayIntervals?.episodic || 30,
-    semantic: config.sectorDecayIntervals?.semantic || 90,
-    procedural: config.sectorDecayIntervals?.procedural || 180,
-    autobiographical: config.sectorDecayIntervals?.autobiographical || 365,
-    working: config.sectorDecayIntervals?.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 },
-    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, cold: 0 }, expired: 0 };
-    }
-    const stats = {
-        decayed: 0,
-        evicted: 0,
-        promoted: 0,
-        tierChanges: { hot: 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 (simplified: hot or cold only)
-        const tierAssignments = new Map();
-        const tierCounts = { hot: 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';
-            }
-            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 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 (coldIds.length > 0) {
-            await db
-                .update(schema.memories)
-                .set({ tier: 'cold', updatedAt: now })
-                .where(inArray(schema.memories.id, coldIds));
-        }
-        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.cold = tierCounts.cold;
-        logger.debug('Tier updates complete', {
-            hot: tierCounts.hot,
-            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/logger.d.ts

@@ -1,17 +0,0 @@
-interface LogContext {
-    [key: string]: any;
-}
-declare class Logger {
-    private prefix;
-    private debugEnabled;
-    constructor(prefix?: string);
-    private format;
-    private isQuiet;
-    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,46 +0,0 @@
-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}`;
-    }
-    isQuiet() {
-        return process.env.SQUISH_QUIET === 'true' || process.env.SQUISH_QUIET === '1';
-    }
-    info(message, context) {
-        if (this.isQuiet()) {
-            return;
-        }
-        console.error(this.format('info', message, context));
-    }
-    warn(message, context) {
-        if (this.isQuiet()) {
-            return;
-        }
-        console.error(this.format('warn', message, context));
-    }
-    error(message, error, context) {
-        if (this.isQuiet()) {
-            return;
-        }
-        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 && !this.isQuiet()) {
-            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