squish-memory 1.2.0 → 1.2.1

package/dist/core/context/context-paging.js

@@ -1,328 +0,0 @@
-/**
- * Context Paging Service - Agent-controlled memory loading
- * Allows agents to load/evict memories from working set
- */
-import { eq, and } from 'drizzle-orm';
-import { sql } from 'drizzle-orm';
-import { getMemory } from '../memory/memories.js';
-import { getDbClient } from '../lib/db-client.js';
-/**
- * Initialize or get a context session
- * Simplified - just tracks what's loaded, not tokens (Claude manages its own context)
- */
-export async function initializeContextSession(sessionId, projectId, userId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    // Check if session exists
-    const existing = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (existing.length === 0) {
-        await db.insert(contextSessions).values({
-            sessionId,
-            projectId: projectId,
-            userId: userId || null,
-            loadedMemoryIds: JSON.stringify([]),
-            tokenBudget: 8000,
-            tokensUsed: 0,
-            coreMemoryTokens: 0,
-            loadedMemoriesTokens: 0,
-            metadata: JSON.stringify({}),
-        });
-    }
-}
-/**
- * Load a memory into working set
- */
-export async function loadMemoryToContext(sessionId, memoryId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    // Get session
-    const session = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (session.length === 0) {
-        return {
-            success: false,
-            message: `Session "${sessionId}" not found. Initialize session first.`,
-        };
-    }
-    const currentSession = session[0];
-    const loadedIds = currentSession.loadedMemoryIds || [];
-    // Check if already loaded
-    if (loadedIds.includes(memoryId)) {
-        return {
-            success: false,
-            message: `Memory "${memoryId}" is already in working set`,
-        };
-    }
-    // Get memory
-    const memory = await getMemory(memoryId);
-    if (!memory) {
-        return {
-            success: false,
-            message: `Memory "${memoryId}" not found`,
-        };
-    }
-    // Update session
-    const newLoadedIds = [...loadedIds, memoryId];
-    await db
-        .update(contextSessions)
-        .set({
-        loadedMemoryIds: newLoadedIds,
-        updatedAt: new Date(),
-    })
-        .where(eq(contextSessions.sessionId, sessionId));
-    // Also update memory's contextStatus to 'in-context'
-    await db
-        .update(schema.memories)
-        .set({
-        contextStatus: 'in-context',
-    })
-        .where(eq(schema.memories.id, memoryId));
-    return {
-        success: true,
-        memory: {
-            id: memory.id,
-            type: memory.type,
-            content: memory.content,
-            contentPreview: memory.content.substring(0, 200) + (memory.content.length > 200 ? '...' : ''),
-            loadedAt: new Date(),
-        },
-    };
-}
-/**
- * Evict a memory from working set
- */
-export async function evictMemoryFromContext(sessionId, memoryId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    // Get session
-    const session = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (session.length === 0) {
-        return {
-            success: false,
-            message: `Session "${sessionId}" not found`,
-        };
-    }
-    const currentSession = session[0];
-    const loadedIds = currentSession.loadedMemoryIds || [];
-    // Check if loaded
-    if (!loadedIds.includes(memoryId)) {
-        return {
-            success: false,
-            message: `Memory "${memoryId}" is not in working set`,
-        };
-    }
-    // Update session
-    const newLoadedIds = loadedIds.filter((id) => id !== memoryId);
-    await db
-        .update(contextSessions)
-        .set({
-        loadedMemoryIds: newLoadedIds,
-        updatedAt: new Date(),
-    })
-        .where(eq(contextSessions.sessionId, sessionId));
-    // Also update memory's contextStatus to 'out-of-context'
-    await db
-        .update(schema.memories)
-        .set({
-        contextStatus: 'out-of-context',
-    })
-        .where(eq(schema.memories.id, memoryId));
-    return {
-        success: true,
-        message: `Memory "${memoryId}" removed from working set`,
-    };
-}
-/**
- * View all memories in working set
- */
-export async function viewLoadedMemories(sessionId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    // Get session
-    const session = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (session.length === 0) {
-        return {
-            success: false,
-            memories: [],
-            count: 0,
-        };
-    }
-    const currentSession = session[0];
-    const loadedIds = currentSession.loadedMemoryIds || [];
-    if (loadedIds.length === 0) {
-        return {
-            success: true,
-            memories: [],
-            count: 0,
-        };
-    }
-    // Get all loaded memories
-    const memories = [];
-    for (const id of loadedIds) {
-        const memory = await getMemory(id);
-        if (memory) {
-            memories.push({
-                id: memory.id,
-                type: memory.type,
-                content: memory.content,
-                contentPreview: memory.content.substring(0, 200) + (memory.content.length > 200 ? '...' : ''),
-                loadedAt: currentSession.updatedAt,
-            });
-        }
-    }
-    return {
-        success: true,
-        memories,
-        count: memories.length,
-    };
-}
-/**
- * Get context status - what's in your working set and what's available
- */
-export async function getContextStatus(sessionId, projectId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions, memories, learnings } = schema;
-    // Get session
-    const session = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (session.length === 0) {
-        return {
-            success: false,
-            coreMemory: { sizeBytes: 0, maxBytes: 2048, usagePercent: 0 },
-            workingSet: { loadedCount: 0, loadedMemories: [] },
-            available: { totalMemories: 0, totalObservations: 0 },
-            note: "Session not found. Initialize session first.",
-        };
-    }
-    const currentSession = session[0];
-    // Get core memory stats
-    const { getCoreMemoryStats } = await import('../ingestion/core-memory.js');
-    const coreStats = await getCoreMemoryStats(projectId);
-    // Get loaded memories
-    const loadedIds = currentSession.loadedMemoryIds || [];
-    const loadedMemories = [];
-    for (const id of loadedIds) {
-        const memory = await getMemory(id);
-        if (memory) {
-            loadedMemories.push({
-                id: memory.id,
-                type: memory.type,
-                contentLength: memory.content.length,
-            });
-        }
-    }
-    // Get external context stats (counts)
-    const totalMemories = await db
-        .select()
-        .from(memories)
-        .where(eq(memories.projectId, projectId));
-    const totalObservations = await db
-        .select()
-        .from(learnings)
-        .where(eq(learnings.projectId, projectId));
-    return {
-        success: true,
-        coreMemory: {
-            sizeBytes: coreStats.totalBytes,
-            maxBytes: coreStats.maxBytes,
-            usagePercent: coreStats.usagePercent,
-        },
-        workingSet: {
-            loadedCount: loadedMemories.length,
-            loadedMemories,
-        },
-        available: {
-            totalMemories: totalMemories.length,
-            totalObservations: totalObservations.length,
-        },
-        note: "Claude manages its own context and token limits. This shows what memories you've loaded into your working set.",
-    };
-}
-/**
- * Clear all loaded memories from working set
- */
-export async function clearLoadedMemories(sessionId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    await db
-        .update(contextSessions)
-        .set({
-        loadedMemoryIds: [],
-        updatedAt: new Date(),
-    })
-        .where(eq(contextSessions.sessionId, sessionId));
-    return {
-        success: true,
-        message: 'All memories cleared from working set',
-    };
-}
-/**
- * Get all memories currently marked as in-context for a session
- */
-export async function getInContextMemories(sessionId) {
-    const { db, schema } = await getDbClient();
-    const { contextSessions } = schema;
-    // Get session to find project
-    const session = await db
-        .select()
-        .from(contextSessions)
-        .where(eq(contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (session.length === 0) {
-        return [];
-    }
-    const { memories } = schema;
-    const projectId = session[0].projectId;
-    // Get all in-context memories
-    const inContextMemories = await db
-        .select()
-        .from(memories)
-        .where(and(eq(memories.projectId, projectId), eq(memories.contextStatus, 'in-context')));
-    return inContextMemories.map((mem) => ({
-        id: mem.id,
-        type: mem.type,
-        content: mem.content,
-        contentPreview: mem.content.substring(0, 200) + (mem.content.length > 200 ? '...' : ''),
-        loadedAt: mem.updatedAt,
-    }));
-}
-/**
- * Get out-of-context (archived) memories for a project
- */
-export async function getOutOfContextMemories(projectId, limit = 10) {
-    const { db, schema } = await getDbClient();
-    const { memories } = schema;
-    // Get out-of-context memories, ordered by last accessed
-    const outOfContextMemories = await db
-        .select()
-        .from(memories)
-        .where(and(eq(memories.projectId, projectId), eq(memories.contextStatus, 'out-of-context')))
-        .orderBy(sql `COALESCE(${memories.lastAccessedAt}, ${memories.createdAt}) DESC`)
-        .limit(limit);
-    return outOfContextMemories.map((mem) => ({
-        id: mem.id,
-        type: mem.type,
-        content: mem.content,
-        contentPreview: mem.content.substring(0, 200) + (mem.content.length > 200 ? '...' : ''),
-        loadedAt: mem.lastAccessedAt || mem.createdAt,
-    }));
-}
-//# sourceMappingURL=context-paging.js.map

package/dist/core/context/context-window.d.ts

@@ -1,40 +0,0 @@
-export interface ContextWindowConfig {
-    maxTokens: number;
-    warningThreshold: number;
-    criticalThreshold: number;
-}
-export declare const DEFAULT_CONTEXT_CONFIG: ContextWindowConfig;
-export interface TokenUsageStats {
-    coreMemoryTokens: number;
-    memoriesTokens: number;
-    totalTokens: number;
-    maxTokens: number;
-    usagePercent: number;
-    status: 'ok' | 'warning' | 'critical';
-    remainingTokens: number;
-}
-export interface OptimizationSuggestion {
-    type: 'drop' | 'summarize' | 'consolidate';
-    memoryId: string;
-    memoryType: string;
-    contentPreview: string;
-    tokens: number;
-    reason: string;
-    priority: number;
-}
-export declare function estimateTokens(content: string): number;
-export declare function getTokenUsage(projectPath: string): Promise<TokenUsageStats>;
-export declare function checkContextLimit(projectPath: string, additionalTokens: number): Promise<{
-    ok: boolean;
-    warning?: string;
-    stats: TokenUsageStats;
-}>;
-export declare function getOptimizationSuggestions(projectPath: string): Promise<OptimizationSuggestion[]>;
-export declare function getContextWindowStatus(projectPath: string): Promise<{
-    config: ContextWindowConfig;
-    usage: TokenUsageStats;
-    suggestions: OptimizationSuggestion[];
-    memoryCount: number;
-    coreMemorySections: number;
-}>;
-//# sourceMappingURL=context-window.d.ts.map

package/dist/core/context/context-window.js

@@ -1,177 +0,0 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-import { requireProject } from '../projects.js';
-export const DEFAULT_CONTEXT_CONFIG = {
-    maxTokens: 128000,
-    warningThreshold: 0.80,
-    criticalThreshold: 0.95,
-};
-export function estimateTokens(content) {
-    if (!content)
-        return 0;
-    return Math.ceil(content.length / 4);
-}
-export async function getTokenUsage(projectPath) {
-    const project = await requireProject(projectPath);
-    const projectId = project.id;
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const memories = schema.memories;
-    const coreMemory = schema.coreMemory;
-    const coreMemoryRows = await db
-        .select()
-        .from(coreMemory)
-        .where(eq(coreMemory.projectId, projectId));
-    let coreMemoryTokens = 0;
-    for (const row of coreMemoryRows) {
-        coreMemoryTokens += row.tokensEstimate || estimateTokens(row.content || '');
-    }
-    const memoryRows = await db
-        .select({
-        tokens: memories.tokensEstimate,
-        content: memories.content,
-    })
-        .from(memories)
-        .where(eq(memories.projectId, projectId));
-    let memoriesTokens = 0;
-    for (const row of memoryRows) {
-        memoriesTokens += row.tokens || estimateTokens(row.content || '');
-    }
-    const totalTokens = coreMemoryTokens + memoriesTokens;
-    const config = DEFAULT_CONTEXT_CONFIG;
-    const usagePercent = (totalTokens / config.maxTokens) * 100;
-    const remainingTokens = Math.max(0, config.maxTokens - totalTokens);
-    let status = 'ok';
-    if (usagePercent >= config.criticalThreshold * 100) {
-        status = 'critical';
-    }
-    else if (usagePercent >= config.warningThreshold * 100) {
-        status = 'warning';
-    }
-    return {
-        coreMemoryTokens,
-        memoriesTokens,
-        totalTokens,
-        maxTokens: config.maxTokens,
-        usagePercent,
-        status,
-        remainingTokens,
-    };
-}
-export async function checkContextLimit(projectPath, additionalTokens) {
-    const stats = await getTokenUsage(projectPath);
-    const projectedTotal = stats.totalTokens + additionalTokens;
-    const projectedPercent = (projectedTotal / stats.maxTokens) * 100;
-    if (projectedPercent >= DEFAULT_CONTEXT_CONFIG.criticalThreshold * 100) {
-        return {
-            ok: false,
-            warning: `CRITICAL: Adding ${additionalTokens} tokens would exceed ${(DEFAULT_CONTEXT_CONFIG.criticalThreshold * 100).toFixed(0)}% of context limit (${projectedPercent.toFixed(1)}% projected). Consider optimizing first.`,
-            stats,
-        };
-    }
-    if (projectedPercent >= DEFAULT_CONTEXT_CONFIG.warningThreshold * 100) {
-        return {
-            ok: true,
-            warning: `WARNING: Adding ${additionalTokens} tokens would reach ${(projectedPercent.toFixed(1))}% of context limit. Consider optimizing soon.`,
-            stats,
-        };
-    }
-    return { ok: true, stats };
-}
-export async function getOptimizationSuggestions(projectPath) {
-    const project = await requireProject(projectPath);
-    const projectId = project.id;
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const memories = schema.memories;
-    const candidates = await db
-        .select({
-        id: memories.id,
-        type: memories.type,
-        content: memories.content,
-        tokens: memories.tokensEstimate,
-        importanceScore: memories.importanceScore,
-        accessCount: memories.accessCount,
-        createdAt: memories.createdAt,
-        isPinned: memories.isPinned,
-        isProtected: memories.isProtected,
-    })
-        .from(memories)
-        .where(eq(memories.projectId, projectId))
-        .orderBy(sql `(importance_score * 0.4 + (100 - COALESCE(access_count, 0)) * 0.3 + (strftime('%s', 'now') - created_at / 1000) / 86400 * 0.3) ASC`)
-        .limit(20);
-    const suggestions = [];
-    for (const mem of candidates) {
-        const tokens = mem.tokens || estimateTokens(mem.content || '');
-        const contentPreview = mem.content?.substring(0, 100) + '...';
-        const isPinned = mem.isPinned === 1 || mem.isPinned === true;
-        const isProtected = mem.isProtected === 1 || mem.isProtected === true;
-        const accessCount = mem.accessCount || 0;
-        const importanceScore = mem.importanceScore || 50;
-        if (isPinned || isProtected) {
-            continue;
-        }
-        if (importanceScore < 30 && accessCount < 3) {
-            suggestions.push({
-                type: 'drop',
-                memoryId: mem.id,
-                memoryType: mem.type,
-                contentPreview,
-                tokens,
-                reason: `Low importance (${importanceScore}) and rarely accessed (${accessCount} times)`,
-                priority: 1,
-            });
-        }
-        else if (importanceScore < 50 && tokens > 500) {
-            suggestions.push({
-                type: 'summarize',
-                memoryId: mem.id,
-                memoryType: mem.type,
-                contentPreview,
-                tokens,
-                reason: `Large memory (${tokens} tokens) with moderate importance`,
-                priority: 2,
-            });
-        }
-        else if (tokens > 1000) {
-            suggestions.push({
-                type: 'consolidate',
-                memoryId: mem.id,
-                memoryType: mem.type,
-                contentPreview,
-                tokens,
-                reason: `Very large memory (${tokens} tokens) - candidate for consolidation`,
-                priority: 3,
-            });
-        }
-    }
-    return suggestions.sort((a, b) => a.priority - b.priority).slice(0, 10);
-}
-export async function getContextWindowStatus(projectPath) {
-    const project = await requireProject(projectPath);
-    const projectId = project.id;
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const [usage, suggestions] = await Promise.all([
-        getTokenUsage(projectPath),
-        getOptimizationSuggestions(projectPath),
-    ]);
-    const memoryCount = await db
-        .select({ count: sql `COUNT(*)` })
-        .from(schema.memories)
-        .where(eq(schema.memories.projectId, projectId));
-    const coreMemorySections = await db
-        .select({ count: sql `COUNT(*)` })
-        .from(schema.coreMemory)
-        .where(eq(schema.coreMemory.projectId, projectId));
-    return {
-        config: DEFAULT_CONTEXT_CONFIG,
-        usage,
-        suggestions,
-        memoryCount: memoryCount[0]?.count || 0,
-        coreMemorySections: coreMemorySections[0]?.count || 0,
-    };
-}
-//# sourceMappingURL=context-window.js.map

package/dist/core/context/context.d.ts

@@ -1,7 +0,0 @@
-export interface ContextInput {
-    project: string;
-    include?: Array<'memories' | 'observations' | 'entities'>;
-    limit?: number;
-}
-export declare function getProjectContext(input: ContextInput): Promise<Record<string, unknown>>;
-//# sourceMappingURL=context.d.ts.map

package/dist/core/context/context.js

@@ -1,22 +0,0 @@
-import { requireProject } from '../projects.js';
-import { getRecent } from '../memory/memories.js';
-import { getObservations } from '../ingestion/learnings.js';
-import { getEntitiesForProject } from '../search/entities.js';
-import { validateLimit } from '../lib/validation.js';
-export async function getProjectContext(input) {
-    const project = await requireProject(input.project);
-    const include = input.include ?? ['memories', 'observations'];
-    const limit = validateLimit(input.limit, 10, 1, 100);
-    const result = { project };
-    if (include.includes('memories')) {
-        result.memories = await getRecent(project.path, limit);
-    }
-    if (include.includes('observations')) {
-        result.observations = await getObservations(project.path, limit);
-    }
-    if (include.includes('entities')) {
-        result.entities = await getEntitiesForProject(project.path, limit);
-    }
-    return result;
-}
-//# sourceMappingURL=context.js.map

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

@@ -1,29 +0,0 @@
-import { MultimodalInput } from './google-multimodal.js';
-export type EmbeddingProvider = 'local' | 'openai' | 'ollama' | 'lmstudio' | 'transformers' | 'google' | 'none' | 'auto';
-export declare function getEmbedding(input: string | MultimodalInput): Promise<number[] | null>;
-/**
- * Get embeddings for multiple inputs in parallel batches
- * Processes inputs in batches to respect rate limits while parallelizing
- */
-export declare function getBatchEmbeddings(inputs: string[], batchSize?: number): Promise<Array<number[] | null>>;
-/**
- * Clear the embedding cache
- */
-export declare function clearEmbeddingCache(): void;
-/**
- * Get embedding cache statistics
- */
-export declare function getEmbeddingCacheStats(): {
-    size: number;
-    maxSize: number;
-};
-/**
- * Check health of all configured embedding providers
- * Returns availability and latency for each provider
- */
-export declare function checkEmbeddingProviderHealth(): Promise<Map<string, {
-    available: boolean;
-    latencyMs?: number;
-    error?: string;
-}>>;
-//# sourceMappingURL=embeddings.d.ts.map