squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/serialization.js

@@ -1,84 +0,0 @@
-import { config } from '../../config.js';
-export function normalizeTags(tags) {
-    return (tags || []).map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-}
-export function toSqliteJson(value) {
-    if (value === undefined || value === null)
-        return null;
-    return JSON.stringify(value);
-}
-export function fromSqliteJson(value) {
-    if (!value)
-        return null;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
-}
-export function toSqliteTags(tags) {
-    if (!tags || tags.length === 0)
-        return null;
-    return JSON.stringify(tags);
-}
-export function fromSqliteTags(value) {
-    if (!value)
-        return [];
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed.map(String) : [];
-    }
-    catch {
-        return value.split(',').map((tag) => tag.trim()).filter(Boolean);
-    }
-}
-// High-level helpers that abstract away team mode vs local mode
-export function serializeTags(tags) {
-    if (config.isTeamMode) {
-        // PostgreSQL: store as array directly (or null if empty)
-        return tags && tags.length > 0 ? tags : null;
-    }
-    else {
-        // SQLite: store as JSON string (or null)
-        return toSqliteTags(tags);
-    }
-}
-export function deserializeTags(value) {
-    if (config.isTeamMode) {
-        // PostgreSQL: value is already an array or null/undefined
-        return Array.isArray(value) ? value : [];
-    }
-    else {
-        // SQLite: value is a JSON string or null/undefined
-        if (typeof value === 'string' || value === null || value === undefined) {
-            return fromSqliteTags(value);
-        }
-        // Unexpected type, return empty array
-        return [];
-    }
-}
-export function serializeMetadata(metadata) {
-    if (config.isTeamMode) {
-        // PostgreSQL: store object directly (or null if null/undefined, keep empty object as-is)
-        return metadata === undefined || metadata === null ? null : metadata;
-    }
-    else {
-        // SQLite: store as JSON string (or null)
-        return toSqliteJson(metadata);
-    }
-}
-export function deserializeMetadata(value) {
-    if (config.isTeamMode) {
-        // PostgreSQL: value is already an object or null/undefined
-        return value == null ? null : value;
-    }
-    else {
-        // SQLite: value is a JSON string or null/undefined
-        if (typeof value === 'string' || value === null) {
-            return fromSqliteJson(value);
-        }
-        return null;
-    }
-}
-//# sourceMappingURL=serialization.js.map

package/dist/core/memory/stale-cleaner.d.ts

@@ -1,26 +0,0 @@
-/**
- * Stale Memory Cleaner
- * Deletes memories that are old, low-confidence, and low-importance
- */
-export interface StaleMemory {
-    id: string;
-    content: string;
-    type: string;
-    createdAt: Date;
-    confidenceLevel: string | null;
-    importanceScore: number | null;
-    isPinned: boolean;
-}
-export interface StaleMemoryQuery {
-    olderThanDays: number;
-    confidenceLevels: string[];
-    minImportance: number;
-    projectId?: string;
-}
-export declare function getStaleMemories(query: StaleMemoryQuery): Promise<StaleMemory[]>;
-export declare function deleteMemoryPermanently(memoryId: string): Promise<void>;
-export declare function runAutoClean(options?: Partial<StaleMemoryQuery>): Promise<{
-    deleted: number;
-    summary: Record<string, unknown>;
-}>;
-//# sourceMappingURL=stale-cleaner.d.ts.map

package/dist/core/memory/stale-cleaner.js

@@ -1,97 +0,0 @@
-/**
- * Stale Memory Cleaner
- * Deletes memories that are old, low-confidence, and low-importance
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { lt, or, and, eq, lte } from 'drizzle-orm';
-export async function getStaleMemories(query) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const cutoffDate = new Date(Date.now() - query.olderThanDays * 24 * 60 * 60 * 1000);
-    // Build conditions
-    const conditions = [
-        // Not pinned
-        or(eq(schema.memories.isPinned, false), eq(schema.memories.isPinned, null)),
-        // Older than cutoff
-        lt(schema.memories.createdAt, cutoffDate),
-    ];
-    // Confidence level filter
-    if (query.confidenceLevels.length > 0) {
-        conditions.push(or(...query.confidenceLevels.map(level => eq(schema.memories.confidenceLevel, level))));
-    }
-    // Importance filter (below threshold)
-    conditions.push(lte(schema.memories.importanceScore, query.minImportance));
-    // Project filter if specified
-    if (query.projectId) {
-        conditions.push(eq(schema.memories.projectId, query.projectId));
-    }
-    try {
-        const results = await sqliteDb
-            .select({
-            id: schema.memories.id,
-            content: schema.memories.content,
-            type: schema.memories.type,
-            createdAt: schema.memories.createdAt,
-            confidenceLevel: schema.memories.confidenceLevel,
-            importanceScore: schema.memories.importanceScore,
-            isPinned: schema.memories.isPinned,
-        })
-            .from(schema.memories)
-            .where(and(...conditions.filter(Boolean)));
-        return results.map((r) => ({
-            ...r,
-            isPinned: Boolean(r.isPinned),
-        }));
-    }
-    catch (error) {
-        console.error('[StaleCleaner] Error querying stale memories:', error);
-        return [];
-    }
-}
-export async function deleteMemoryPermanently(memoryId) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    try {
-        // Delete associated records first
-        await sqliteDb.delete(schema.memoryAssociations).where(or(eq(schema.memoryAssociations.fromMemoryId, memoryId), eq(schema.memoryAssociations.toMemoryId, memoryId))).catch(() => { }); // Ignore if table doesn't exist
-        // Delete memory tags
-        await sqliteDb.delete(schema.memoryTags).where(eq(schema.memoryTags.memoryId, memoryId)).catch(() => { }); // Ignore if table doesn't exist
-        // Delete the memory itself
-        await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
-    }
-    catch (error) {
-        console.error(`[StaleCleaner] Error deleting memory ${memoryId}:`, error);
-        throw error;
-    }
-}
-export async function runAutoClean(options) {
-    const defaultOptions = {
-        olderThanDays: options?.olderThanDays || 30,
-        confidenceLevels: options?.confidenceLevels || ['outdated', 'speculative'],
-        minImportance: options?.minImportance || 40,
-    };
-    const stale = await getStaleMemories(defaultOptions);
-    let deleted = 0;
-    for (const memory of stale) {
-        if (!memory.isPinned) {
-            await deleteMemoryPermanently(memory.id);
-            deleted++;
-        }
-    }
-    return {
-        deleted,
-        summary: {
-            scanned: stale.length,
-            skippedPinned: stale.length - deleted,
-            criteria: defaultOptions,
-        },
-    };
-}
-//# sourceMappingURL=stale-cleaner.js.map

package/dist/core/memory/stats.d.ts

@@ -1,32 +0,0 @@
-/**
- * Memory Statistics Module
- * Provides memory usage statistics for CLI and MCP
- */
-export interface MemoryStats {
-    totalMemories: number;
-    byType: Record<string, number>;
-    totalNotes: number;
-    notesByCategory: Record<string, number>;
-    totalLearnings: number;
-    learningsByType: Record<string, number>;
-    totalLinks: number;
-    oldestMemory?: string;
-    newestMemory?: string;
-    projectPath: string;
-    mode: string;
-    signal?: {
-        captured: number;
-        suppressed: number;
-        sessionOnly: number;
-        durable: number;
-        durableWithRaw: number;
-        tokensSaved: number;
-        placeRouted: number;
-        graphEnriched: number;
-    };
-}
-/**
- * Get memory statistics for a project
- */
-export declare function getMemoryStats(projectPath?: string): Promise<MemoryStats>;
-//# sourceMappingURL=stats.d.ts.map

package/dist/core/memory/stats.js

@@ -1,143 +0,0 @@
-/**
- * Memory Statistics Module
- * Provides memory usage statistics for CLI and MCP
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { config } from '../../config.js';
-import { ensureProject } from '../../core/projects.js';
-import { createDatabaseClient } from '../storage/database.js';
-import { getProjectSignalStats } from '../session/working-set.js';
-/**
- * Get memory statistics for a project
- */
-export async function getMemoryStats(projectPath = process.cwd()) {
-    let db;
-    try {
-        db = createDatabaseClient(await getDb());
-    }
-    catch (error) {
-        throw new Error(`Database unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-    const schema = await getSchema();
-    const project = await ensureProject(projectPath);
-    if (!project) {
-        throw new Error(`Project not found: ${projectPath}`);
-    }
-    const stats = {
-        totalMemories: 0,
-        byType: {},
-        totalNotes: 0,
-        notesByCategory: {},
-        totalLearnings: 0,
-        learningsByType: {},
-        totalLinks: 0,
-        projectPath,
-        mode: config.isTeamMode ? 'team' : 'local',
-    };
-    try {
-        // Count total memories
-        const countResult = await db
-            .select({ count: schema.memories.id })
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id));
-        stats.totalMemories = countResult.length;
-        // Count by type
-        if (config.isTeamMode) {
-            // PostgreSQL - use raw query for GROUP BY
-            const typeCounts = await db.execute(sql `
-        SELECT type, COUNT(*) as count
-        FROM memories
-        ${sql `WHERE project_id = ${project.id}`}
-        GROUP BY type
-      `);
-            for (const row of typeCounts.rows) {
-                stats.byType[row.type] = Number(row.count);
-            }
-        }
-        else {
-            // SQLite - get all and count in memory
-            const allMemories = await db
-                .select({ type: schema.memories.type })
-                .from(schema.memories)
-                .where(eq(schema.memories.projectId, project.id));
-            for (const mem of allMemories) {
-                const type = mem.type || 'unknown';
-                stats.byType[type] = (stats.byType[type] || 0) + 1;
-            }
-        }
-        // Get oldest and newest
-        const oldest = await db
-            .select({ createdAt: schema.memories.createdAt })
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id))
-            .orderBy(asc(schema.memories.createdAt))
-            .limit(1);
-        const newest = await db
-            .select({ createdAt: schema.memories.createdAt })
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id))
-            .orderBy(desc(schema.memories.createdAt))
-            .limit(1);
-        if (oldest.length > 0 && oldest[0].createdAt) {
-            stats.oldestMemory = oldest[0].createdAt;
-        }
-        if (newest.length > 0 && newest[0].createdAt) {
-            stats.newestMemory = newest[0].createdAt;
-        }
-        // Learnings
-        const allLearnings = await db
-            .select({ category: schema.learnings.category, type: schema.learnings.type })
-            .from(schema.learnings)
-            .where(eq(schema.learnings.projectId, project.id));
-        stats.totalNotes = allLearnings.length;
-        for (const obs of allLearnings) {
-            const cat = obs.category || 'uncategorized';
-            stats.notesByCategory[cat] = (stats.notesByCategory[cat] || 0) + 1;
-        }
-        // Learnings by type
-        const learningTypes = ['success', 'failure', 'fix', 'insight'];
-        const learningRecords = allLearnings.filter((o) => {
-            const type = o.type || '';
-            return learningTypes.includes(type.toLowerCase());
-        });
-        stats.totalLearnings = learningRecords.length;
-        // Count by type
-        for (const obs of learningRecords) {
-            const type = obs.type || 'unknown';
-            stats.learningsByType[type] = (stats.learningsByType[type] || 0) + 1;
-        }
-        // Links
-        // Links are scoped via their associated memories
-        if (config.isTeamMode) {
-            // PostgreSQL - use raw query to join through memories
-            const linksCount = await db.execute(sql `
-        SELECT COUNT(*) as count FROM memory_associations ma
-        JOIN memories m1 ON ma.from_memory_id = m1.id
-        JOIN memories m2 ON ma.to_memory_id = m2.id
-        ${project ? sql `WHERE m1.project_id = ${project.id} OR m2.project_id = ${project.id}` : sql ``}
-      `);
-            stats.totalLinks = Number(linksCount.rows[0]?.count || 0);
-        }
-        else {
-            // SQLite - get all and filter in memory
-            const allLinks = await db
-                .select({
-                fromProjectId: schema.memories.projectId,
-                toProjectId: schema.memories.projectId
-            })
-                .from(schema.memoryAssociations)
-                .innerJoin(schema.memories, eq(schema.memoryAssociations.fromMemoryId, schema.memories.id))
-                .where(project ? eq(schema.memories.projectId, project.id) : undefined);
-            stats.totalLinks = allLinks.length;
-        }
-    }
-    catch (error) {
-        // Return empty stats on error
-        console.error('Error getting memory stats:', error);
-    }
-    stats.signal = await getProjectSignalStats(projectPath);
-    return stats;
-}
-import { eq, sql, asc, desc } from 'drizzle-orm';
-//# sourceMappingURL=stats.js.map

package/dist/core/memory/telemetry.d.ts

@@ -1,69 +0,0 @@
-/**
- * Retrieval Quality Telemetry
- * Tracks memory usage patterns (echo/fizzle) to improve retrieval quality
- * Echo: memory was retrieved and used
- * Fizzle: memory was retrieved but not used
- */
-export interface RetrievalEvent {
-    memoryId: string;
-    query: string;
-    position: number;
-    score: number;
-    wasUsed: boolean;
-    sessionId?: string;
-    timestamp: Date;
-}
-export interface RetrievalStats {
-    totalRetrievals: number;
-    echoes: number;
-    fizzles: number;
-    echoRate: number;
-    avgPosition: number;
-    topMemories: string[];
-    underperformingMemories: string[];
-}
-export interface MemoryTelemetry {
-    memoryId: string;
-    retrievalCount: number;
-    echoCount: number;
-    fizzleCount: number;
-    echoRate: number;
-    avgPosition: number;
-    lastRetrieved?: Date;
-    lastEchoed?: Date;
-}
-/**
- * Record a retrieval event
- */
-export declare function recordRetrieval(memoryId: string, query: string, position: number, score: number, sessionId?: string): void;
-/**
- * Mark a retrieval as "echoed" (memory was actually used)
- */
-export declare function recordEcho(memoryId: string, sessionId?: string): void;
-/**
- * Mark retrievals as "fizzled" (memory was not used)
- * Call this at the end of a session for non-echoed retrievals
- */
-export declare function recordFizzle(memoryId: string, sessionId?: string): void;
-/**
- * Flush cached retrieval events to database
- */
-export declare function flushRetrievalEvents(): Promise<void>;
-/**
- * Get telemetry for a specific memory
- */
-export declare function getMemoryTelemetry(memoryId: string): Promise<MemoryTelemetry | null>;
-/**
- * Get overall retrieval statistics
- */
-export declare function getRetrievalStats(projectId?: string): Promise<RetrievalStats>;
-/**
- * Adjust retrieval boosting based on echo/fizzle history
- * Returns a boost factor (0.5 - 2.0) for a memory
- */
-export declare function calculateTelemetryBoost(telemetry: MemoryTelemetry | null): number;
-/**
- * Periodic cleanup job for telemetry data
- */
-export declare function cleanupOldTelemetry(daysToKeep?: number): Promise<number>;
-//# sourceMappingURL=telemetry.d.ts.map