squish-memory 1.1.5 → 1.2.1

package/dist/core/consolidation.d.ts

@@ -1,37 +0,0 @@
-export interface ConsolidationStats {
-    clustered: number;
-    merged: number;
-    tokensRecovered: number;
-    deduped: number;
-    consolidated: number;
-}
-export interface DeduplicationResult {
-    duplicatesFound: number;
-    mergedCount: number;
-    tokensRecovered: number;
-    groups: DuplicateGroup[];
-}
-export interface DuplicateGroup {
-    canonicalId: string;
-    duplicateIds: string[];
-    similarity: number;
-    reason: string;
-}
-/**
- * Run automated deduplication job
- * Finds and marks duplicates for review or auto-merges high-confidence duplicates
- */
-export declare function runDeduplicationJob(projectId?: string): Promise<DeduplicationResult>;
-/**
- * Run full consolidation job (dedup + memory consolidation)
- */
-export declare function runFullConsolidationJob(projectId?: string): Promise<ConsolidationStats>;
-/**
- * Get deduplication statistics
- */
-export declare function getDeduplicationStats(projectId?: string): Promise<{
-    totalMemories: number;
-    mergedMemories: number;
-    pendingDuplicates: number;
-}>;
-//# sourceMappingURL=consolidation.d.ts.map

package/dist/core/consolidation.js

@@ -1,248 +0,0 @@
-// Memory Consolidation & Deduplication
-import { eq, inArray, and } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { createAssociation } from './associations.js';
-import { logger } from './logger.js';
-import { consolidateMemories } from './memory/consolidation.js';
-/**
- * Run automated deduplication job
- * Finds and marks duplicates for review or auto-merges high-confidence duplicates
- */
-export async function runDeduplicationJob(projectId) {
-    const result = {
-        duplicatesFound: 0,
-        mergedCount: 0,
-        tokensRecovered: 0,
-        groups: [],
-    };
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get active memories for deduplication check
-        const whereClause = projectId
-            ? and(eq(schema.memories.projectId, projectId), eq(schema.memories.status, 'active'))
-            : eq(schema.memories.status, 'active');
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(whereClause)
-            .limit(500);
-        if (memories.length < 2) {
-            return result;
-        }
-        // Find duplicate groups using SimHash
-        const duplicateGroups = await findDuplicatesBySimHash(memories);
-        result.duplicatesFound = duplicateGroups.reduce((sum, g) => sum + g.duplicateIds.length, 0);
-        // Auto-merge high-confidence duplicates (>0.95 similarity)
-        for (const group of duplicateGroups) {
-            if (group.similarity >= 0.95) {
-                const tokensSaved = await autoMergeDuplicates(group.canonicalId, group.duplicateIds);
-                result.mergedCount += group.duplicateIds.length;
-                result.tokensRecovered += tokensSaved;
-            }
-            else {
-                // Lower confidence - just create association for review
-                for (const dupId of group.duplicateIds) {
-                    await createAssociation(group.canonicalId, dupId, 'duplicate', group.similarity);
-                }
-            }
-            result.groups.push(group);
-        }
-        logger.info('Deduplication job completed', {
-            duplicatesFound: result.duplicatesFound,
-            mergedCount: result.mergedCount,
-            tokensRecovered: result.tokensRecovered,
-        });
-    }
-    catch (error) {
-        logger.error('Deduplication job error', error);
-    }
-    return result;
-}
-/**
- * Find duplicates using SimHash (efficient near-duplicate detection)
- */
-async function findDuplicatesBySimHash(memories) {
-    const groups = [];
-    const processed = new Set();
-    // Compute SimHash for each memory
-    const hashes = memories.map(m => ({
-        id: m.id,
-        hash: computeSimHash(m.content),
-        content: m.content,
-        createdAt: m.createdAt,
-    }));
-    // Compare hashes to find similar content
-    for (let i = 0; i < hashes.length; i++) {
-        if (processed.has(hashes[i].id))
-            continue;
-        const duplicates = [];
-        let maxSimilarity = 0;
-        for (let j = i + 1; j < hashes.length; j++) {
-            if (processed.has(hashes[j].id))
-                continue;
-            const hammingDistance = computeHammingDistance(hashes[i].hash, hashes[j].hash);
-            const similarity = 1 - (hammingDistance / 64); // 64-bit hash
-            if (similarity >= 0.85) {
-                duplicates.push(hashes[j].id);
-                maxSimilarity = Math.max(maxSimilarity, similarity);
-                processed.add(hashes[j].id);
-            }
-        }
-        if (duplicates.length > 0) {
-            processed.add(hashes[i].id);
-            groups.push({
-                canonicalId: hashes[i].id, // Keep oldest as canonical
-                duplicateIds: duplicates,
-                similarity: maxSimilarity,
-                reason: 'content-similarity',
-            });
-        }
-    }
-    return groups;
-}
-/**
- * Compute SimHash for text (64-bit fingerprint)
- */
-function computeSimHash(text) {
-    const tokens = text.toLowerCase().split(/\s+/).filter(t => t.length > 2);
-    const weights = new Array(64).fill(0);
-    for (const token of tokens) {
-        const hash = simpleHash(token);
-        for (let i = 0; i < 64; i++) {
-            if ((hash >> BigInt(i)) & 1n) {
-                weights[i] += 1;
-            }
-            else {
-                weights[i] -= 1;
-            }
-        }
-    }
-    let simHash = 0n;
-    for (let i = 0; i < 64; i++) {
-        if (weights[i] > 0) {
-            simHash |= (1n << BigInt(i));
-        }
-    }
-    return simHash;
-}
-/**
- * Simple hash function for strings
- */
-function simpleHash(str) {
-    let hash = 0n;
-    for (let i = 0; i < str.length; i++) {
-        const char = BigInt(str.charCodeAt(i));
-        hash = ((hash << 5n) - hash) + char;
-        hash = hash & hash; // Convert to 64bit integer
-    }
-    return hash;
-}
-/**
- * Compute Hamming distance between two hashes
- */
-function computeHammingDistance(a, b) {
-    let xor = a ^ b;
-    let distance = 0;
-    while (xor !== 0n) {
-        distance += Number(xor & 1n);
-        xor >>= 1n;
-    }
-    return distance;
-}
-/**
- * Auto-merge duplicates into canonical memory
- */
-async function autoMergeDuplicates(canonicalId, duplicateIds) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Calculate tokens recovered
-        const duplicates = await db
-            .select()
-            .from(schema.memories)
-            .where(inArray(schema.memories.id, duplicateIds));
-        let tokensRecovered = 0;
-        for (const dup of duplicates) {
-            tokensRecovered += Math.ceil((dup.content?.length || 0) / 4);
-        }
-        // Mark duplicates as merged
-        await db
-            .update(schema.memories)
-            .set({
-            status: 'merged',
-            mergedInto: canonicalId,
-            mergedAt: now,
-            updatedAt: now,
-        })
-            .where(inArray(schema.memories.id, duplicateIds));
-        // Create associations for traceability
-        for (const dupId of duplicateIds) {
-            await createAssociation(canonicalId, dupId, 'merged', 0.95);
-        }
-        return tokensRecovered;
-    }
-    catch (error) {
-        logger.error('Error auto-merging duplicates', error);
-        return 0;
-    }
-}
-/**
- * Run full consolidation job (dedup + memory consolidation)
- */
-export async function runFullConsolidationJob(projectId) {
-    const stats = {
-        clustered: 0,
-        merged: 0,
-        tokensRecovered: 0,
-        deduped: 0,
-        consolidated: 0,
-    };
-    // Run deduplication first
-    const dedupResult = await runDeduplicationJob(projectId);
-    stats.deduped = dedupResult.duplicatesFound;
-    stats.merged = dedupResult.mergedCount;
-    stats.tokensRecovered += dedupResult.tokensRecovered;
-    // Run memory consolidation for each project
-    if (projectId) {
-        const consolidationResults = await consolidateMemories({
-            projectId,
-            minAge: 60,
-            maxImportance: 25,
-            minClusterSize: 3,
-            limit: 100,
-        });
-        stats.consolidated = consolidationResults.length;
-        stats.clustered = consolidationResults.reduce((sum, r) => sum + r.clusterSize, 0);
-    }
-    logger.info('Full consolidation job completed', stats);
-    return stats;
-}
-/**
- * Get deduplication statistics
- */
-export async function getDeduplicationStats(projectId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const whereClause = projectId
-            ? eq(schema.memories.projectId, projectId)
-            : undefined;
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(whereClause);
-        return {
-            totalMemories: memories.length,
-            mergedMemories: memories.filter((m) => m.status === 'merged').length,
-            pendingDuplicates: 0, // Would need to query associations
-        };
-    }
-    catch (error) {
-        logger.error('Error getting deduplication stats', error);
-        return { totalMemories: 0, mergedMemories: 0, pendingDuplicates: 0 };
-    }
-}
-//# sourceMappingURL=consolidation.js.map

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

@@ -1,106 +0,0 @@
-/**
- * Agent Context API - Direct access for agents
- *
- * Provides a simple API for agents to get context without CLI calls.
- * Use this instead of spawning squish CLI processes.
- *
- * Usage:
- *   import { getAgentContext, searchWithPlace } from './core/context/agent-context.js';
- *
- *   const context = await getAgentContext(projectPath, { task: "fix bug" });
- *   const results = await searchWithPlace(projectPath, "error fix", { limit: 5 });
- */
-export interface AgentContextOptions {
-    /** Current task or action (helps auto-detect relevant place) */
-    task?: string;
-    /** Preferred tier: quick (50 tokens), medium (170), full (500) */
-    tier?: 'quick' | 'medium' | 'full';
-    /** Max memories to return */
-    limit?: number;
-    /** Include place context */
-    includePlaces?: boolean;
-}
-export interface SearchOptions {
-    /** Query string */
-    query: string;
-    /** Optional place filter */
-    place?: string;
-    /** Max results */
-    limit?: number;
-    /** Memory type filter */
-    type?: string;
-}
-/**
- * Get agent context - the main function I can call directly
- *
- * Instead of: squish context --tier medium --has-memories
- * Use: const ctx = await getAgentContext(projectPath, { task: "fix bug", tier: "medium" })
- */
-export declare function getAgentContext(projectPath: string, options?: AgentContextOptions): Promise<{
-    ok: boolean;
-    memories: Array<{
-        id: string;
-        type: string;
-        content: string;
-        place?: string;
-        placeType?: string;
-    }>;
-    places: Array<{
-        name: string;
-        type: string;
-        purpose?: string;
-        memories: number;
-        preview?: string[];
-    }>;
-    sessionId?: string;
-    tokens?: number;
-}>;
-/**
- * Search memories with automatic place detection
- *
- * If query contains keywords associated with a place (e.g., "fix" -> Workshop),
- * it will automatically include that place in results or boost those results.
- */
-export declare function searchWithPlace(projectPath: string, query: string, options?: SearchOptions): Promise<{
-    ok: boolean;
-    query: string;
-    autoDetectedPlace?: string;
-    count: number;
-    results: Array<{
-        id: string;
-        type: string;
-        content: string;
-        score: number;
-        place?: string;
-        placeType?: string;
-    }>;
-}>;
-/**
- * Get single memory with place info
- */
-export declare function getMemoryWithPlace(projectPath: string, memoryId: string): Promise<{
-    ok: boolean;
-    memory?: {
-        id: string;
-        type: string;
-        content: string;
-        tags: string[];
-        createdAt: Date;
-        place?: string;
-        placeType?: string;
-    };
-}>;
-/**
- * Quick context for session start - lightweight version
- * Use this when you just need the basics without full context
- */
-export declare function getQuickContext(projectPath: string, limit?: number): Promise<{
-    ok: boolean;
-    memories: Array<{
-        id: string;
-        type: string;
-        content: string;
-    }>;
-    activePlaces: string[];
-}>;
-//# sourceMappingURL=agent-context.d.ts.map

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

@@ -1,274 +0,0 @@
-/**
- * Agent Context API - Direct access for agents
- *
- * Provides a simple API for agents to get context without CLI calls.
- * Use this instead of spawning squish CLI processes.
- *
- * Usage:
- *   import { getAgentContext, searchWithPlace } from './core/context/agent-context.js';
- *
- *   const context = await getAgentContext(projectPath, { task: "fix bug" });
- *   const results = await searchWithPlace(projectPath, "error fix", { limit: 5 });
- */
-import { getRecent, search } from '../memory/memories.js';
-import { getProjectByPath } from '../projects.js';
-import { ensureProject } from '../projects.js';
-import { initializeDefaultPlaces, getProjectPlaces, getMemoryPlace, getPlace, walkPlace } from '../places/index.js';
-import { logger } from '../logger.js';
-/**
- * Get agent context - the main function I can call directly
- *
- * Instead of: squish context --tier medium --has-memories
- * Use: const ctx = await getAgentContext(projectPath, { task: "fix bug", tier: "medium" })
- */
-export async function getAgentContext(projectPath, options = {}) {
-    try {
-        await ensureProject(projectPath);
-        const project = await getProjectByPath(projectPath);
-        if (!project) {
-            return { ok: false, memories: [], places: [] };
-        }
-        const tier = options.tier || 'medium';
-        const limit = options.limit || 5;
-        const includePlaces = options.includePlaces !== false;
-        // Get recent memories
-        const memories = await getRecent(projectPath, limit);
-        // Add place info to each memory
-        const memoriesWithPlace = await Promise.all(memories.map(async (m) => {
-            const placeId = await getMemoryPlace(m.id);
-            let placeInfo = {};
-            if (placeId) {
-                const place = await getPlace(placeId);
-                placeInfo = { place: place?.name || null, placeType: place?.placeType || null };
-            }
-            return {
-                id: m.id,
-                type: m.type,
-                content: m.content || m.content,
-                ...placeInfo,
-            };
-        }));
-        // Get places context
-        let places = [];
-        if (includePlaces) {
-            await initializeDefaultPlaces(project.id);
-            const projectPlaces = await getProjectPlaces(project.id);
-            // Filter to populated places only
-            const populatedPlaces = projectPlaces.filter(p => p.memoryCount > 0);
-            if (tier === 'quick') {
-                // Just names
-                places = populatedPlaces.map(p => ({
-                    name: p.name,
-                    type: p.placeType,
-                    memories: p.memoryCount,
-                }));
-            }
-            else if (tier === 'medium') {
-                // Top 3 per place
-                const mediumPlaces = [];
-                for (const p of populatedPlaces.slice(0, 5)) {
-                    const walkResult = await walkPlace(project.id, p.placeType, {
-                        tokenBudget: 170,
-                        maxMemoriesPerPlace: 3,
-                        compressWithToon: false,
-                    });
-                    mediumPlaces.push({
-                        name: p.name,
-                        type: p.placeType,
-                        purpose: p.purpose,
-                        memories: p.memoryCount,
-                        preview: walkResult?.memories.slice(0, 3).map((m) => m.content?.substring(0, 80)) || [],
-                    });
-                }
-                places = mediumPlaces;
-            }
-            else {
-                // Full
-                places = populatedPlaces.map(p => ({
-                    name: p.name,
-                    type: p.placeType,
-                    purpose: p.purpose,
-                    memories: p.memoryCount,
-                }));
-            }
-        }
-        // Estimate token count
-        const tokens = tier === 'quick' ? 50 : tier === 'medium' ? 170 : 500;
-        return {
-            ok: true,
-            memories: memoriesWithPlace,
-            places,
-            tokens,
-        };
-    }
-    catch (error) {
-        logger.error('[AgentContext] Error getting context:', error);
-        return { ok: false, memories: [], places: [] };
-    }
-}
-/**
- * Search memories with automatic place detection
- *
- * If query contains keywords associated with a place (e.g., "fix" -> Workshop),
- * it will automatically include that place in results or boost those results.
- */
-export async function searchWithPlace(projectPath, query, options = { query, limit: 10 }) {
-    try {
-        await ensureProject(projectPath);
-        const project = await getProjectByPath(projectPath);
-        if (!project) {
-            return { ok: false, query, count: 0, results: [] };
-        }
-        // Search
-        const results = await search({
-            query,
-            type: options.type,
-            limit: (options.limit || 10) * 2,
-            project: projectPath,
-        });
-        const limited = results.slice(0, options.limit || 10);
-        // Auto-detect place from query keywords
-        const autoPlace = detectPlaceFromQuery(query);
-        // Add place info to results
-        const resultsWithPlace = await Promise.all(limited.map(async (r) => {
-            const placeId = await getMemoryPlace(r.id);
-            let placeInfo = { place: null, placeType: null };
-            if (placeId) {
-                const place = await getPlace(placeId);
-                placeInfo = {
-                    place: place?.name || null,
-                    placeType: place?.placeType || null,
-                };
-            }
-            return {
-                id: r.id,
-                type: r.type,
-                content: r.content,
-                score: r.similarity ?? 0,
-                ...placeInfo,
-            };
-        }));
-        // Filter by place if specified or auto-detected
-        let filtered = resultsWithPlace;
-        const placeFilter = options.place || autoPlace;
-        if (placeFilter) {
-            filtered = resultsWithPlace.filter((r) => r.placeType === placeFilter);
-        }
-        return {
-            ok: true,
-            query,
-            autoDetectedPlace: autoPlace || undefined,
-            count: filtered.length,
-            results: filtered,
-        };
-    }
-    catch (error) {
-        logger.error('[AgentContext] Error searching:', error);
-        return { ok: false, query, count: 0, results: [] };
-    }
-}
-/**
- * Detect place type from query keywords
- *
- * Maps common terms to place types:
- * - fix, bug, error, issue -> workshop (fixing stuff)
- * - design, plan, architecture, api -> library (learning/docs)
- * - task, todo, manage, organize -> office (work management)
- * - code, implement, feature -> workshop
- * - research, learn, study -> library
- * - experiment, test, try -> lab
- * - review, archive -> archive
- */
-function detectPlaceFromQuery(query) {
-    const q = query.toLowerCase();
-    // Map keywords to places
-    const keywords = {
-        workshop: ['fix', 'bug', 'error', 'issue', 'code', 'implement', 'feature', 'refactor', 'debug'],
-        library: ['design', 'plan', 'architecture', 'api', 'learn', 'research', 'study', 'documentation', 'docs'],
-        office: ['task', 'todo', 'manage', 'organize', 'schedule', 'meeting', 'project'],
-        lab: ['test', 'experiment', 'try', 'verify', 'prototype', 'poc'],
-        garden: ['idea', 'brainstorm', 'create', 'design', 'concept'],
-        archive: ['review', 'archive', 'old', 'past', 'historical'],
-    };
-    // Check each place's keywords
-    for (const [placeType, words] of Object.entries(keywords)) {
-        for (const word of words) {
-            if (q.includes(word)) {
-                return placeType;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Get single memory with place info
- */
-export async function getMemoryWithPlace(projectPath, memoryId) {
-    try {
-        const { getMemory } = await import('../memory/memories.js');
-        const memory = await getMemory(memoryId);
-        if (!memory) {
-            return { ok: false };
-        }
-        // Get place info
-        const placeId = await getMemoryPlace(memoryId);
-        let placeInfo = {};
-        if (placeId) {
-            const place = await getPlace(placeId);
-            placeInfo = {
-                place: place?.name || null,
-                placeType: place?.placeType || null,
-            };
-        }
-        return {
-            ok: true,
-            memory: {
-                id: memory.id,
-                type: memory.type,
-                content: memory.content || '',
-                tags: memory.tags || [],
-                createdAt: memory.createdAt,
-                ...placeInfo,
-            },
-        };
-    }
-    catch (error) {
-        logger.error('[AgentContext] Error getting memory:', error);
-        return { ok: false };
-    }
-}
-/**
- * Quick context for session start - lightweight version
- * Use this when you just need the basics without full context
- */
-export async function getQuickContext(projectPath, limit = 3) {
-    try {
-        await ensureProject(projectPath);
-        const project = await getProjectByPath(projectPath);
-        if (!project) {
-            return { ok: false, memories: [], activePlaces: [] };
-        }
-        // Get recent memories
-        const memories = await getRecent(projectPath, limit);
-        // Get places with memories
-        await initializeDefaultPlaces(project.id);
-        const places = await getProjectPlaces(project.id);
-        const activePlaces = places
-            .filter(p => p.memoryCount > 0)
-            .map(p => p.name);
-        return {
-            ok: true,
-            memories: memories.map((m) => ({
-                id: m.id,
-                type: m.type,
-                content: m.content?.substring(0, 100) || '',
-            })),
-            activePlaces,
-        };
-    }
-    catch (error) {
-        logger.error('[AgentContext] Error getting quick context:', error);
-        return { ok: false, memories: [], activePlaces: [] };
-    }
-}
-//# sourceMappingURL=agent-context.js.map