squish-memory 1.1.5 → 1.2.1

package/dist/core/memory/migrate.js

@@ -1,134 +0,0 @@
-/**
- * Memory Migration Module
- * Migrate memories between .squish directories/databases
- */
-import { randomUUID } from 'crypto';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getDbClient } from '../lib/db-client.js';
-/**
- * Migrate memories from one .squish directory to another
- */
-export async function migrateMemories(sourceDir, targetDir, options = {}) {
-    const { dryRun = false, deleteSource = false } = options;
-    const sourceDbPath = join(sourceDir, 'squish.db');
-    const targetDbPath = join(targetDir, 'squish.db');
-    if (!existsSync(sourceDbPath)) {
-        throw new Error(`Source database not found: ${sourceDbPath}`);
-    }
-    if (!existsSync(targetDbPath)) {
-        throw new Error(`Target database not found: ${targetDbPath}`);
-    }
-    // Use bun:sqlite for direct source DB access
-    // @ts-ignore - bun:sqlite module not found in types but works at runtime
-    const SqliteDatabase = (await import('bun:sqlite')).default;
-    const sourceDb = new SqliteDatabase(sourceDbPath, { readonly: true });
-    // Get target DB through the app's existing mechanism
-    const { db: targetDb, schema } = await getDbClient();
-    // Get all projects from source
-    const sourceProjects = sourceDb.query('SELECT * FROM projects').all();
-    // Map old project IDs to new project IDs
-    const projectIdMap = new Map();
-    for (const project of sourceProjects) {
-        // Check if project with same path exists in target
-        const existing = await targetDb.select()
-            .from(schema.projects)
-            .where((tbl, { eq }) => eq(tbl.path, project.path))
-            .limit(1);
-        if (existing.length > 0) {
-            projectIdMap.set(project.id, existing[0].id);
-        }
-        else {
-            // Create new project in target
-            const newId = randomUUID();
-            await targetDb.insert(schema.projects).values({
-                id: newId,
-                path: project.path,
-                name: project.name || 'migrated',
-                createdAt: new Date(),
-            });
-            projectIdMap.set(project.id, newId);
-        }
-    }
-    // Migrate memories
-    const sourceMemories = sourceDb.query('SELECT * FROM memories').all();
-    let memoriesCopied = 0;
-    for (const mem of sourceMemories) {
-        const oldProjectId = mem.project_id;
-        const newProjectId = projectIdMap.get(oldProjectId);
-        if (!newProjectId) {
-            console.warn(`Skipping memory ${mem.id}: no project mapping found`);
-            continue;
-        }
-        if (!dryRun) {
-            // Add 'imported' tag to track migrated memories
-            const existingTags = mem.tags ? JSON.parse(mem.tags) : [];
-            const newTags = [...existingTags, 'imported'];
-            await targetDb.insert(schema.memories).values({
-                id: randomUUID(),
-                projectId: newProjectId,
-                type: mem.type,
-                content: mem.content,
-                summary: mem.summary,
-                source: mem.source || 'migrated',
-                confidence: mem.confidence ?? 50,
-                confidenceLevel: mem.confidence_level || 'speculative',
-                tags: newTags,
-                metadata: { ...mem.metadata, migratedAt: new Date().toISOString(), originalId: mem.id },
-                isActive: mem.is_active ?? 1,
-                createdAt: mem.created_at ? new Date(mem.created_at * 1000) : new Date(),
-                updatedAt: new Date(),
-            });
-        }
-        memoriesCopied++;
-    }
-    // Migrate learnings (renamed from observations)
-    const sourceLearnings = sourceDb.query('SELECT * FROM learnings').all();
-    let learningsCopied = 0;
-    for (const learn of sourceLearnings) {
-        const oldProjectId = learn.project_id;
-        const newProjectId = projectIdMap.get(oldProjectId);
-        if (!newProjectId)
-            continue;
-        if (!dryRun) {
-            // Add is_imported flag to track migrated learnings
-            await targetDb.insert(schema.learnings).values({
-                id: randomUUID(),
-                projectId: newProjectId,
-                type: learn.type,
-                action: learn.action,
-                summary: learn.summary,
-                target: learn.target,
-                details: learn.details,
-                isImported: true,
-                createdAt: new Date(),
-            });
-        }
-        learningsCopied++;
-    }
-    // Migrate memory associations (simplified - skip for now)
-    const sourceAssoc = sourceDb.query('SELECT * FROM memory_associations').all();
-    let associationsCopied = 0;
-    if (!dryRun && sourceAssoc.length > 0) {
-        console.warn(`Note: ${sourceAssoc.length} associations not migrated (requires ID mapping)`);
-    }
-    // Close source DB
-    sourceDb.close();
-    // Delete source if requested
-    let sourceDeleted = false;
-    if (!dryRun && deleteSource && memoriesCopied > 0) {
-        // Implementation would delete the file
-        console.warn('Source deletion not implemented - requires manual removal');
-    }
-    return {
-        memoriesCopied,
-        observationsCopied: learningsCopied,
-        associationsCopied,
-        projectsMapped: projectIdMap.size,
-        sourceDeleted,
-        message: dryRun
-            ? 'Dry run complete - no changes made'
-            : `Successfully migrated ${memoriesCopied} memories, ${learningsCopied} learnings`
-    };
-}
-//# sourceMappingURL=migrate.js.map

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

@@ -1,22 +0,0 @@
-/**
- * Memory normalization utilities
- * Shared between memories.ts and loader.ts to avoid circular dependencies
- */
-export interface MemoryRecord {
-    id: string;
-    projectId?: string | null;
-    type: string;
-    content: string;
-    summary?: string | null;
-    tags: string[];
-    metadata?: Record<string, unknown> | null;
-    createdAt?: string | null;
-    validFrom?: string | null;
-    validTo?: string | null;
-    recordedAt?: string | null;
-    similarity?: number;
-    importance?: number;
-    confidenceLevel?: 'certain' | 'speculative' | 'outdated' | null;
-}
-export declare function normalizeMemory(row: any): MemoryRecord;
-//# sourceMappingURL=normalization.d.ts.map

package/dist/core/memory/normalization.js

@@ -1,26 +0,0 @@
-/**
- * Memory normalization utilities
- * Shared between memories.ts and loader.ts to avoid circular dependencies
- */
-import { deserializeTags, deserializeMetadata } from './serialization.js';
-import { normalizeTimestamp } from '../lib/utils.js';
-export function normalizeMemory(row) {
-    const tags = deserializeTags(row.tags ?? null);
-    const metadata = deserializeMetadata(row.metadata ?? null);
-    const createdAtStr = normalizeTimestamp(row.createdAt ?? row.created_at);
-    return {
-        id: row.id,
-        projectId: row.projectId ?? row.project_id ?? null,
-        type: row.type,
-        content: row.content,
-        summary: row.summary ?? null,
-        tags,
-        metadata,
-        createdAt: createdAtStr,
-        validFrom: row.validFrom ?? row.valid_from ?? null,
-        validTo: row.validTo ?? row.valid_to ?? null,
-        recordedAt: row.recordedAt ?? row.recorded_at ?? null,
-        confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
-    };
-}
-//# sourceMappingURL=normalization.js.map

package/dist/core/memory/progressive-disclosure.d.ts

@@ -1,43 +0,0 @@
-export interface LightweightIndex {
-    id: string;
-    memoryId: string;
-    contentHash: string;
-    contentPreview: string;
-    keyTerms: string[];
-    category: string;
-    importance: number;
-    createdAt: Date;
-}
-export interface MemoryPreview {
-    id: string;
-    type: string;
-    contentPreview: string;
-    keyTerms: string[];
-    category: string;
-    importance: number;
-    lastAccessedAt?: Date;
-}
-export interface FullMemoryLoad {
-    id: string;
-    content: string;
-    summary?: string;
-    tags: string[];
-    metadata?: Record<string, unknown>;
-}
-export interface TokenBudgetStatus {
-    budget: number;
-    used: number;
-    remaining: number;
-    loadedCount: number;
-    preloadCount: number;
-}
-export declare function createLightweightIndex(memoryId: string, content: string, category: string, importance: number): Promise<LightweightIndex>;
-export declare function searchLightweightIndices(projectId: string, query: string, limit?: number): Promise<MemoryPreview[]>;
-export declare function loadFullMemory(memoryId: string): Promise<FullMemoryLoad | null>;
-export declare function estimateTokenCount(text: string): Promise<number>;
-export declare function allocateTokenBudget(sessionId: string, budget: number): Promise<TokenBudgetStatus>;
-export declare function preloadCandidateMemories(sessionId: string, projectId: string, budget: number, excludeLoadedIds: string[]): Promise<string[]>;
-export declare function getPreloadCandidates(sessionId: string): Promise<MemoryPreview[]>;
-export declare function updateIndexImportance(memoryId: string, importance: number): Promise<void>;
-export declare function deleteLightweightIndex(memoryId: string): Promise<void>;
-//# sourceMappingURL=progressive-disclosure.d.ts.map

package/dist/core/memory/progressive-disclosure.js

@@ -1,280 +0,0 @@
-import { randomUUID } from 'crypto';
-import { eq, desc, and, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-const PREVIEW_TOKENS = 50;
-const MAX_PRELOAD_CANDIDATES = 20;
-const TOKEN_ESTIMATE_CHARS = 4;
-export async function createLightweightIndex(memoryId, content, category, importance) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const contentHash = hashContent(content);
-    const contentPreview = extractPreview(content);
-    const keyTerms = extractKeyTerms(content);
-    const index = {
-        id: randomUUID(),
-        memoryId,
-        contentHash,
-        contentPreview,
-        keyTerms,
-        category,
-        importance,
-        createdAt: new Date(),
-    };
-    await db.insert(schema.lightweightMemoryIndices).values({
-        id: index.id,
-        memoryId: index.memoryId,
-        contentHash: index.contentHash,
-        contentPreview: index.contentPreview,
-        keyTerms: JSON.stringify(index.keyTerms),
-        category: index.category,
-        importanceScore: index.importance,
-        createdAt: index.createdAt,
-    });
-    return index;
-}
-export async function searchLightweightIndices(projectId, query, limit = 10) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const queryLower = query.toLowerCase();
-    const queryTerms = queryLower.split(/\s+/).filter((t) => t.length > 2);
-    const results = await db
-        .select({
-        id: schema.lightweightMemoryIndices.id,
-        memoryId: schema.lightweightMemoryIndices.memoryId,
-        contentPreview: schema.lightweightMemoryIndices.contentPreview,
-        keyTerms: schema.lightweightMemoryIndices.keyTerms,
-        category: schema.lightweightMemoryIndices.category,
-        importanceScore: schema.lightweightMemoryIndices.importanceScore,
-        lastAccessedAt: schema.memories.lastAccessedAt,
-    })
-        .from(schema.lightweightMemoryIndices)
-        .leftJoin(schema.memories, eq(schema.lightweightMemoryIndices.memoryId, schema.memories.id))
-        .where(eq(schema.lightweightMemoryIndices.memoryId, schema.memories.id))
-        .limit(limit * 2);
-    const scored = results.map((row) => {
-        let score = row.importanceScore ?? 50;
-        const keyTerms = typeof row.keyTerms === 'string'
-            ? JSON.parse(row.keyTerms)
-            : row.keyTerms ?? [];
-        const termsLower = keyTerms.map((t) => t.toLowerCase());
-        for (const term of queryTerms) {
-            if (row.contentPreview.toLowerCase().includes(term)) {
-                score += 10;
-            }
-            if (termsLower.some((t) => t.includes(term))) {
-                score += 15;
-            }
-        }
-        return {
-            id: row.id,
-            memoryId: row.memoryId,
-            contentPreview: row.contentPreview,
-            keyTerms,
-            category: row.category,
-            importance: row.importanceScore ?? 50,
-            lastAccessedAt: row.lastAccessedAt,
-            score,
-        };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit).map((item) => ({
-        id: item.memoryId,
-        type: 'preview',
-        contentPreview: item.contentPreview,
-        keyTerms: item.keyTerms,
-        category: item.category,
-        importance: item.importance,
-        lastAccessedAt: item.lastAccessedAt,
-    }));
-}
-export async function loadFullMemory(memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const rows = await db
-        .select()
-        .from(schema.memories)
-        .where(eq(schema.memories.id, memoryId))
-        .limit(1);
-    if (rows.length === 0)
-        return null;
-    const row = rows[0];
-    return {
-        id: row.id,
-        content: row.content,
-        summary: row.summary ?? undefined,
-        tags: Array.isArray(row.tags) ? row.tags : [],
-        metadata: row.metadata ?? undefined,
-    };
-}
-export async function estimateTokenCount(text) {
-    return Math.ceil(text.length / TOKEN_ESTIMATE_CHARS);
-}
-export async function allocateTokenBudget(sessionId, budget) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const [session] = await db
-        .select()
-        .from(schema.contextPagingSessions)
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId))
-        .limit(1);
-    if (!session) {
-        return {
-            budget,
-            used: 0,
-            remaining: budget,
-            loadedCount: 0,
-            preloadCount: 0,
-        };
-    }
-    const tokensUsed = session.tokensUsed ?? 0;
-    const loadedCount = session.loadedMemoryIds?.length ?? 0;
-    const preloadCount = session.preloadCandidateIds?.length ?? 0;
-    return {
-        budget,
-        used: tokensUsed,
-        remaining: Math.max(0, budget - tokensUsed),
-        loadedCount,
-        preloadCount,
-    };
-}
-export async function preloadCandidateMemories(sessionId, projectId, budget, excludeLoadedIds) {
-    const status = await allocateTokenBudget(sessionId, budget);
-    const availableTokens = status.remaining;
-    if (availableTokens < PREVIEW_TOKENS * 2) {
-        return [];
-    }
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const rows = await db
-        .select({
-        id: schema.memories.id,
-        content: schema.memories.content,
-        importanceScore: schema.memories.importanceScore,
-        lastAccessedAt: schema.memories.lastAccessedAt,
-    })
-        .from(schema.memories)
-        .where(and(eq(schema.memories.projectId, projectId), eq(schema.memories.isActive, true), excludeLoadedIds.length > 0
-        ? sql `${schema.memories.id} NOT IN (${excludeLoadedIds.map(id => `'${id.replace(/'/g, "''")}'`).join(',')})`
-        : sql `TRUE`))
-        .orderBy(desc(schema.memories.importanceScore), desc(schema.memories.lastAccessedAt))
-        .limit(MAX_PRELOAD_CANDIDATES);
-    const candidates = [];
-    let tokensForPreload = Math.min(availableTokens - PREVIEW_TOKENS, availableTokens * 0.3);
-    for (const row of rows) {
-        const tokens = await estimateTokenCount(row.content ?? '');
-        if (tokens <= tokensForPreload) {
-            candidates.push(row.id);
-            tokensForPreload -= tokens;
-        }
-        if (candidates.length >= 5)
-            break;
-    }
-    await db
-        .update(schema.contextPagingSessions)
-        .set({
-        preloadCandidateIds: candidates,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId));
-    return candidates;
-}
-export async function getPreloadCandidates(sessionId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const [session] = await db
-        .select()
-        .from(schema.contextPagingSessions)
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId))
-        .limit(1);
-    if (!session)
-        return [];
-    const candidateIds = session.preloadCandidateIds ?? [];
-    if (candidateIds.length === 0)
-        return [];
-    const previews = [];
-    for (const memoryId of candidateIds.slice(0, 5)) {
-        const [index] = await db
-            .select()
-            .from(schema.lightweightMemoryIndices)
-            .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId))
-            .limit(1);
-        if (index) {
-            const keyTerms = typeof index.keyTerms === 'string'
-                ? JSON.parse(index.keyTerms)
-                : index.keyTerms ?? [];
-            previews.push({
-                id: index.memoryId,
-                type: 'preload',
-                contentPreview: index.contentPreview,
-                keyTerms,
-                category: index.category,
-                importance: index.importanceScore ?? 50,
-            });
-        }
-    }
-    return previews;
-}
-export async function updateIndexImportance(memoryId, importance) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    await db
-        .update(schema.lightweightMemoryIndices)
-        .set({
-        importanceScore: importance,
-    })
-        .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId));
-}
-export async function deleteLightweightIndex(memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    await db
-        .delete(schema.lightweightMemoryIndices)
-        .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId));
-}
-function hashContent(content) {
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash;
-    }
-    return Math.abs(hash).toString(36);
-}
-function extractPreview(content) {
-    const firstPeriod = content.indexOf('.');
-    const firstNewline = content.indexOf('\n');
-    let endIndex = content.length;
-    if (firstPeriod > 0 && firstPeriod < 100) {
-        endIndex = firstPeriod + 1;
-    }
-    else if (firstNewline > 0 && firstNewline < 100) {
-        endIndex = firstNewline;
-    }
-    return content.substring(0, Math.min(endIndex, 150)).trim();
-}
-function extractKeyTerms(content) {
-    const words = content.toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter((w) => w.length > 3);
-    const stopWords = new Set([
-        'this', 'that', 'with', 'from', 'have', 'been', 'were', 'they',
-        'their', 'which', 'about', 'would', 'could', 'should', 'there',
-        'what', 'when', 'where', 'who', 'will', 'just', 'like', 'into',
-        'than', 'then', 'both', 'each', 'more', 'most', 'other', 'some',
-        'such', 'only', 'over', 'very', 'also', 'back', 'after', 'being',
-    ]);
-    const termCounts = {};
-    for (const word of words) {
-        if (!stopWords.has(word) && !/^\d+$/.test(word)) {
-            termCounts[word] = (termCounts[word] ?? 0) + 1;
-        }
-    }
-    return Object.entries(termCounts)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([term]) => term);
-}
-//# sourceMappingURL=progressive-disclosure.js.map

package/dist/core/memory/query-processor.d.ts

@@ -1,21 +0,0 @@
-/**
- * Query Processor - Phase 4
- * Expands queries for better retrieval coverage
- */
-export interface ProcessedQuery {
-    original: string;
-    expanded: string[];
-    entities: string[];
-    synonyms: Map<string, string[]>;
-}
-/**
- * Simple synonym expansion without LLM calls
- * Fast, deterministic, no API costs
- */
-export declare function expandQuery(query: string): ProcessedQuery;
-/**
- * Multi-query search combiner
- * Searches with multiple query variants and merges results
- */
-export declare function multiQuerySearch<T>(queries: string[], searchFn: (query: string) => Promise<T[]>, dedupeKey: (item: T) => string): Promise<T[]>;
-//# sourceMappingURL=query-processor.d.ts.map

package/dist/core/memory/query-processor.js

@@ -1,72 +0,0 @@
-/**
- * Query Processor - Phase 4
- * Expands queries for better retrieval coverage
- */
-/**
- * Simple synonym expansion without LLM calls
- * Fast, deterministic, no API costs
- */
-export function expandQuery(query) {
-    const synonyms = new Map();
-    // Define common synonym mappings
-    const synonymMap = {
-        'manager': ['manager', 'boss', 'supervisor', 'lead'],
-        'team': ['team', 'group', 'staff', 'crew'],
-        'project': ['project', 'initiative', 'endeavor', 'work'],
-        'start': ['start', 'begin', 'commence', 'initiate'],
-        'budget': ['budget', 'funding', 'cost', 'allocation'],
-        'language': ['language', 'tech', 'stack', 'technology'],
-        'feature': ['feature', 'capability', 'function', 'aspect'],
-        'based': ['based', 'located', 'situated', 'headquartered'],
-    };
-    const lowerQuery = query.toLowerCase();
-    // Find matching synonyms
-    for (const [key, values] of Object.entries(synonymMap)) {
-        if (lowerQuery.includes(key)) {
-            synonyms.set(key, values);
-        }
-    }
-    // Generate expanded queries by substituting synonyms
-    const expanded = [query]; // Original
-    // Add one variation per synonym found
-    for (const [term, variants] of synonyms) {
-        for (const variant of variants) {
-            if (variant !== term) {
-                expanded.push(query.replace(new RegExp(term, 'gi'), variant));
-            }
-        }
-    }
-    // Extract simple entities (capitalized words)
-    const entityMatches = query.match(/\b[A-Z][a-z]+\b/g);
-    const entities = entityMatches ? [...new Set(entityMatches)] : [];
-    return {
-        original: query,
-        expanded: [...new Set(expanded)], // Deduplicate
-        entities,
-        synonyms,
-    };
-}
-/**
- * Multi-query search combiner
- * Searches with multiple query variants and merges results
- */
-export async function multiQuerySearch(queries, searchFn, dedupeKey) {
-    const allResults = [];
-    // Search with each query variant
-    for (const query of queries) {
-        const results = await searchFn(query);
-        allResults.push(...results);
-    }
-    // Deduplicate by key
-    const seen = new Set();
-    const unique = [];
-    for (const item of allResults) {
-        const key = dedupeKey(item);
-        if (!seen.has(key)) {
-            seen.add(key);
-            unique.push(item);
-        }
-    }
-    return unique;
-}
-//# sourceMappingURL=query-processor.js.map

package/dist/core/memory/query-rewriter.d.ts

@@ -1,13 +0,0 @@
-/** Query Rewriter - Rewrite user queries for better retrieval using LLM */
-import { type ContextMessage } from './context-collector.js';
-export interface RewriteResult {
-    original: string;
-    rewritten: string;
-    expansions: string[];
-    intent: 'search' | 'recall' | 'question' | 'context';
-    confidence: number;
-    method: 'llm' | 'synonym' | 'none';
-}
-export declare function rewriteQuery(query: string, context: ContextMessage[]): Promise<RewriteResult>;
-export declare function wouldBenefitFromRewrite(query: string): boolean;
-//# sourceMappingURL=query-rewriter.d.ts.map