squish-memory 1.1.5 → 1.2.1

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

@@ -1,118 +0,0 @@
-/** Query Rewriter - Rewrite user queries for better retrieval using LLM */
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { expandQuery } from './query-processor.js';
-const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
-
-Rules:
-1. Output ONLY the optimized search query - no explanations or extra text
-2. Remove filler words (please, can you, etc.)
-3. Focus on the core information need
-4. Preserve important entities (names, dates, technical terms)
-5. Add synonyms for key terms if helpful
-6. Consider what memories would be most relevant
-7. If the message is about recalling something specific, include those details`;
-export async function rewriteQuery(query, context) {
-    if (!config.queryRewritingEnabled) {
-        return {
-            original: query,
-            rewritten: query,
-            expansions: [],
-            intent: detectIntent(query),
-            confidence: 1.0,
-            method: 'none',
-        };
-    }
-    if (config.queryRewritingFallbackEnabled) {
-        try {
-            const llmResult = await rewriteWithLLM(query, context);
-            if (llmResult)
-                return llmResult;
-        }
-        catch (error) {
-            logger.warn(`[QueryRewriter] LLM rewrite failed, falling back to synonym: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (config.queryRewritingFallbackEnabled) {
-        const expanded = expandQuery(query);
-        return {
-            original: query,
-            rewritten: expanded.expanded[0] || query,
-            expansions: expanded.expanded.slice(1),
-            intent: detectIntent(query),
-            confidence: 0.7,
-            method: 'synonym',
-        };
-    }
-    return {
-        original: query,
-        rewritten: query,
-        expansions: [],
-        intent: detectIntent(query),
-        confidence: 1.0,
-        method: 'none',
-    };
-}
-async function rewriteWithLLM(query, context) {
-    if (context.length < 2)
-        return null;
-    const lastUserMsg = context.filter(m => m.role === 'user').pop()?.content || '';
-    const pronounPattern = /\b(it|that|this|they|them|those|these|he|she|his|her)\b/i;
-    const hasPronouns = pronounPattern.test(query);
-    const vaguePattern = /\b(the thing|the stuff|what (we|I) (talked|discussed|mentioned))\b/i;
-    const hasVagueRef = vaguePattern.test(query);
-    if (!hasPronouns && !hasVagueRef)
-        return null;
-    let rewritten = query;
-    const entityPattern = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
-    const contextEntities = lastUserMsg.match(entityPattern) || [];
-    const techPattern = /\b([a-z]+\.(?:ts|js|py|json|md)|@[a-z]+\/[a-z]+|\b[A-Z]{2,}\b)\b/gi;
-    const techTerms = lastUserMsg.match(techPattern) || [];
-    if (contextEntities.length > 0 && hasPronouns) {
-        const mostLikelyEntity = contextEntities[contextEntities.length - 1];
-        if (!query.toLowerCase().includes(mostLikelyEntity.toLowerCase())) {
-            rewritten = `${query} ${mostLikelyEntity}`;
-        }
-    }
-    const firstTechTerm = techTerms[0];
-    if (firstTechTerm && !query.includes(firstTechTerm)) {
-        rewritten = `${rewritten} ${firstTechTerm}`;
-    }
-    if (rewritten !== query) {
-        logger.info(`[QueryRewriter] Rewrote "${query}" -> "${rewritten}"`);
-        return {
-            original: query,
-            rewritten,
-            expansions: [],
-            intent: detectIntent(query),
-            confidence: 0.8,
-            method: 'llm',
-        };
-    }
-    return null;
-}
-function detectIntent(query) {
-    const lower = query.toLowerCase();
-    if (/\b(remember|recall|what did (we|I)|what was|retrieve)\b/.test(lower)) {
-        return 'recall';
-    }
-    if (/^(what|who|when|where|why|how|which|is|are|can|do|does)/.test(lower)) {
-        return 'question';
-    }
-    if (/\b(context|background|about|regarding|concerning)\b/.test(lower)) {
-        return 'context';
-    }
-    return 'search';
-}
-export function wouldBenefitFromRewrite(query) {
-    if (query.split(/\s+/).length < 3)
-        return true;
-    const pronounPattern = /\b(it|that|this|they|them|those|these|he|she|his|her)\b/i;
-    if (pronounPattern.test(query))
-        return true;
-    const vaguePattern = /\b(the thing|the stuff|what (we|I) (talked|discussed|mentioned))\b/i;
-    if (vaguePattern.test(query))
-        return true;
-    return false;
-}
-//# sourceMappingURL=query-rewriter.js.map

package/dist/core/memory/response-analyzer.d.ts

@@ -1,9 +0,0 @@
-/** Response Analyzer - Analyze LLM responses for memory references (Echo/Fizzle tracking) */
-export interface AnalysisResult {
-    referencedMemoryIds: string[];
-    referenceCount: number;
-    hasReferences: boolean;
-}
-export declare function analyzeResponseForMemoryReferences(responseText: string, injectedMemoryIds: string[], injectedMemoryContent: Map<string, string>): AnalysisResult;
-export declare function mightContainMemoryReferences(responseText: string): boolean;
-//# sourceMappingURL=response-analyzer.d.ts.map

package/dist/core/memory/response-analyzer.js

@@ -1,61 +0,0 @@
-/** Response Analyzer - Analyze LLM responses for memory references (Echo/Fizzle tracking) */
-import { logger } from '../logger.js';
-const REFERENCE_PATTERNS = [
-    /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi,
-    /as (?:i |we )?(?:mentioned|noted|remembered|recalled|stored|saved)/gi,
-    /(?:based|drawing) on (?:my|our|the) (?:memory|previous|earlier)/gi,
-    /(?:i |we )?(?:recall|remember|noted) (?:that |earlier )?/gi,
-    /from (?:my|our|the) (?:memory|notes|records)/gi,
-];
-export function analyzeResponseForMemoryReferences(responseText, injectedMemoryIds, injectedMemoryContent) {
-    const referencedMemoryIds = [];
-    const responseLower = responseText.toLowerCase();
-    for (const memoryId of injectedMemoryIds) {
-        if (responseText.includes(memoryId)) {
-            referencedMemoryIds.push(memoryId);
-            logger.debug(`[ResponseAnalyzer] Direct reference found: ${memoryId}`);
-        }
-    }
-    for (const [memoryId, content] of injectedMemoryContent) {
-        if (referencedMemoryIds.includes(memoryId))
-            continue;
-        const contentWords = content.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-        if (contentWords.length < 5)
-            continue;
-        let matchCount = 0;
-        for (const word of contentWords) {
-            if (responseLower.includes(word)) {
-                matchCount++;
-            }
-        }
-        const matchRatio = matchCount / contentWords.length;
-        if (matchRatio > 0.5) {
-            referencedMemoryIds.push(memoryId);
-            logger.debug(`[ResponseAnalyzer] Content match (${(matchRatio * 100).toFixed(0)}%): ${memoryId}`);
-        }
-    }
-    for (const pattern of REFERENCE_PATTERNS) {
-        const matches = responseText.match(pattern);
-        if (matches && matches.length > 0) {
-            logger.debug(`[ResponseAnalyzer] Reference pattern found: ${matches.length} matches`);
-        }
-    }
-    const result = {
-        referencedMemoryIds: [...new Set(referencedMemoryIds)],
-        referenceCount: referencedMemoryIds.length,
-        hasReferences: referencedMemoryIds.length > 0,
-    };
-    if (result.hasReferences) {
-        logger.info(`[ResponseAnalyzer] Found ${result.referenceCount} memory references`);
-    }
-    return result;
-}
-export function mightContainMemoryReferences(responseText) {
-    const responseLower = responseText.toLowerCase();
-    const quickPatterns = [
-        'remember', 'recall', 'mentioned', 'noted', 'earlier',
-        'previous', 'as i', 'as we', 'from my', 'from our',
-    ];
-    return quickPatterns.some(pattern => responseLower.includes(pattern));
-}
-//# sourceMappingURL=response-analyzer.js.map

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

@@ -1,10 +0,0 @@
-export declare function normalizeTags(tags?: string[]): string[];
-export declare function toSqliteJson(value: unknown): string | null;
-export declare function fromSqliteJson<T>(value: string | null | undefined): T | null;
-export declare function toSqliteTags(tags?: string[]): string | null;
-export declare function fromSqliteTags(value: string | null | undefined): string[];
-export declare function serializeTags(tags?: string[]): string[] | string | null | undefined;
-export declare function deserializeTags(value: string[] | string | null | undefined): string[];
-export declare function serializeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | string | null;
-export declare function deserializeMetadata(value: Record<string, unknown> | string | null | undefined): Record<string, unknown> | null;
-//# sourceMappingURL=serialization.d.ts.map

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/stats.d.ts

@@ -1,22 +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;
-}
-/**
- * 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,138 +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 { requireProject } from '../../core/projects.js';
-import { createDatabaseClient } from '../storage/database.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 requireProject(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);
-    }
-    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