squish-memory 1.1.5 → 1.2.1

package/dist/core/memory/entity-extractor.js

@@ -1,336 +0,0 @@
-/**
- * Entity Extractor
- * Extracts named entities from memory content
- * Supports people, files, functions, dates, locations, concepts, tools, and patterns
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { eq, and } from 'drizzle-orm';
-import { logger } from '../../core/logger.js';
-// Regex patterns for entity detection
-const PATTERNS = {
-    // File paths: src/components/Button.tsx, ./config.json, /var/log/app.log
-    filePath: /(?:^|[^\w])(?:\.?\/[\w.-]*[\w.-]*(?:\/[\w.-]+)*|[\w.-]+\.(?:ts|tsx|js|jsx|py|rb|go|java|cpp|c|h|json|yaml|yml|env|md|txt|csv|sql|graphql))\b/gm,
-    // Functions/methods: `functionName()`, `object.method()`, `Class.staticMethod()`
-    functionCall: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g,
-    // Classes: `class ClassName`, `new ClassName()`, `extends ClassName`
-    className: /\b(?:class|new|extends|implements)\s+([A-Z][a-zA-Z0-9_$]*)\b/g,
-    // Common names (capitalized words not at sentence start)
-    personName: /(?:^|[^.\w])\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\b(?![^.\w])/g,
-    // Capitalized concepts: `Machine Learning`, `React Hooks`
-    concept: /\b(?:[A-Z][a-z]+\s+)+(?:System|Architecture|Pattern|Model|Algorithm|Framework|Library|Process|Concept|Theory|Method)\b/g,
-    // Technologies/Tools: React, Node.js, PostgreSQL, Docker, Kubernetes
-    tool: /\b(?:React|Vue|Angular|Node\.?js?|Express|Django|Flask|FastAPI|PostgreSQL|MongoDB|Redis|Docker|Kubernetes|Terraform|AWS|Azure|GCP|GitHub|GitLab|Jenkins|Figma|Sketch|Adobe|Webpack|Vite|npm|yarn|pnpm|TypeScript|JavaScript|Python|Go|Rust|Java|C\+\+|C#)\b/g,
-    // Design patterns: `singleton pattern`, `factory method`, `observer pattern`
-    designPattern: /\b(?:abstract\s+)?(?:factory|singleton|observer|decorator|strategy|adapter|bridge|facade|proxy|chain\s+of\s+responsibility|composite|template\s+method|visitor|builder|prototype|memento|interpreter|command|state|mediator)\s+(?:pattern|method)\b/gi,
-    // Techniques/Methodologies: `memoization`, `caching`, `lazy loading`, `debouncing`
-    technique: /\b(?:memoization|caching|lazy\s+loading|debouncing|throttling|currying|composition|recursion|iteration|hashing|indexing|sharding|replication|optimization|refactoring|testing|debugging|profiling|monitoring|logging)\b/gi,
-    // Quoted concepts and important terms
-    quotedConcept: /["`]([^"`]+)["`]/g,
-    // ISO dates
-    date: /\b(\d{4}-\d{2}-\d{2})(?:T\d{2}:\d{2}:\d{2})?\b/g,
-    // Common code keywords and variables
-    codeVariable: /\b(?:const|let|var|function|async|await|return|import|export|class|interface|type|enum)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g,
-};
-/**
- * Extract entities from content
- */
-export async function extractEntities(content) {
-    const entities = [];
-    const seenKeys = new Set(); // Deduplicate entities
-    // Extract file paths
-    const filePaths = Array.from(content.matchAll(PATTERNS.filePath));
-    for (const match of filePaths) {
-        const name = match[0].trim();
-        const key = `file:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'file',
-                confidence: 0.9,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-                normalized: normalizePath(name),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract function calls
-    const functionCalls = Array.from(content.matchAll(PATTERNS.functionCall));
-    for (const match of functionCalls) {
-        const name = match[1];
-        const key = `function:${name}`;
-        if (!seenKeys.has(key) && name.length > 2) {
-            entities.push({
-                name,
-                type: 'function',
-                confidence: 0.85,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract class names
-    const classNames = Array.from(content.matchAll(PATTERNS.className));
-    for (const match of classNames) {
-        const name = match[1];
-        const key = `class:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'class',
-                confidence: 0.95,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract technologies/tools
-    const tools = Array.from(content.matchAll(PATTERNS.tool));
-    for (const match of tools) {
-        const name = match[0];
-        const key = `tool:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'tool',
-                confidence: 0.9,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract design patterns
-    const patterns = Array.from(content.matchAll(PATTERNS.designPattern));
-    for (const match of patterns) {
-        const name = match[0];
-        const key = `pattern:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'pattern',
-                confidence: 0.92,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract techniques/methodologies
-    const techniques = Array.from(content.matchAll(PATTERNS.technique));
-    for (const match of techniques) {
-        const name = match[0];
-        const key = `technique:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'technique',
-                confidence: 0.88,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract dates
-    const dates = Array.from(content.matchAll(PATTERNS.date));
-    for (const match of dates) {
-        const name = match[0];
-        const key = `date:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'date',
-                confidence: 0.95,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract quoted important concepts
-    const quotedConcepts = Array.from(content.matchAll(PATTERNS.quotedConcept));
-    for (const match of quotedConcepts) {
-        const name = match[1];
-        const key = `concept:${name}`;
-        if (!seenKeys.has(key) && name.length > 2) {
-            entities.push({
-                name,
-                type: 'concept',
-                confidence: 0.8,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Extract capitalized concepts
-    const concepts = Array.from(content.matchAll(PATTERNS.concept));
-    for (const match of concepts) {
-        const name = match[0];
-        const key = `concept:${name}`;
-        if (!seenKeys.has(key)) {
-            entities.push({
-                name,
-                type: 'concept',
-                confidence: 0.75,
-                startIndex: match.index || 0,
-                endIndex: (match.index || 0) + match[0].length,
-                context: extractContext(content, match.index || 0),
-            });
-            seenKeys.add(key);
-        }
-    }
-    // Sort by start index
-    entities.sort((a, b) => a.startIndex - b.startIndex);
-    logger.debug('Entities extracted', {
-        count: entities.length,
-        byType: countByType(entities),
-    });
-    return entities;
-}
-/**
- * Link extracted entities to memory records
- * Creates entity records in the knowledge graph
- */
-export async function linkEntitiesToMemories(memoryId, entities) {
-    if (entities.length === 0)
-        return;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get memory to find project
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memories.length === 0)
-            return;
-        const memory = memories[0];
-        // Insert unique entities into the knowledge graph
-        for (const entity of entities) {
-            try {
-                // Check if entity already exists
-                const existing = await db
-                    .select()
-                    .from(schema.entities)
-                    .where(and(eq(schema.entities.projectId, memory.projectId), eq(schema.entities.name, entity.name), eq(schema.entities.type, entity.type)))
-                    .limit(1);
-                if (existing.length === 0) {
-                    // Insert new entity with metadata in properties
-                    await db.insert(schema.entities).values({
-                        name: entity.name,
-                        type: entity.type,
-                        projectId: memory.projectId,
-                        description: entity.context,
-                        properties: {
-                            confidence: entity.confidence,
-                            extractedFrom: memoryId,
-                            normalized: entity.normalized,
-                        },
-                    });
-                }
-            }
-            catch (error) {
-                logger.error('Error inserting entity', { entity, error });
-            }
-        }
-        logger.debug('Entities linked to memory', {
-            memoryId,
-            entityCount: entities.length,
-        });
-    }
-    catch (error) {
-        logger.error('Error linking entities to memories', error);
-    }
-}
-/**
- * Get entities extracted from a memory based on properties
- */
-export async function getMemoryEntities(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Find all entities with this memory ID in properties
-        const allEntities = await db.select().from(schema.entities);
-        const entities = [];
-        for (const entity of allEntities) {
-            const props = entity.properties;
-            if (props && props.extractedFrom === memoryId) {
-                entities.push({
-                    name: entity.name,
-                    type: entity.type,
-                    confidence: props.confidence || 0.8,
-                    startIndex: 0,
-                    endIndex: 0,
-                    context: entity.description || '',
-                    normalized: props.normalized,
-                });
-            }
-        }
-        return entities;
-    }
-    catch (error) {
-        logger.error('Error getting memory entities', error);
-        return [];
-    }
-}
-/**
- * Get all entities for a project
- */
-export async function getProjectEntities(projectId, type) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        let query = db.select().from(schema.entities).where(eq(schema.entities.projectId, projectId));
-        if (type) {
-            query = query.where(eq(schema.entities.type, type));
-        }
-        return await query;
-    }
-    catch (error) {
-        logger.error('Error getting project entities', error);
-        return [];
-    }
-}
-/**
- * Extract context around entity
- */
-function extractContext(content, index, contextLength = 50) {
-    const start = Math.max(0, index - contextLength);
-    const end = Math.min(content.length, index + contextLength);
-    return content.substring(start, end).trim();
-}
-/**
- * Normalize file path
- */
-function normalizePath(path) {
-    return path
-        .trim()
-        .replace(/^\.\//, '')
-        .toLowerCase()
-        .replace(/\\/g, '/');
-}
-/**
- * Count entities by type
- */
-function countByType(entities) {
-    const counts = {};
-    for (const entity of entities) {
-        counts[entity.type] = (counts[entity.type] || 0) + 1;
-    }
-    return counts;
-}
-//# sourceMappingURL=entity-extractor.js.map

package/dist/core/memory/entity-resolver.d.ts

@@ -1,23 +0,0 @@
-export interface ExtractedEntities {
-    primary: string[];
-    secondary: string[];
-    queryType: 'factual' | 'relational' | 'temporal';
-}
-/**
- * Extract entities from a query using Claude
- * NO FALLBACKS - real extraction or throw
- */
-export declare function extractQueryEntities(query: string, callClaudeFn: (prompt: string, maxTokens: number) => Promise<string>): Promise<ExtractedEntities>;
-/**
- * Score memory relevance based on entity matching
- * Returns boost factor (0-1)
- */
-export declare function scoreEntityMatch(memoryEntities: string[], queryEntities: string[]): number;
-/**
- * Filter and boost memories by entity relevance
- */
-export declare function filterByEntities(memories: any[], queryEntities: string[]): Array<{
-    memory: any;
-    entityBoost: number;
-}>;
-//# sourceMappingURL=entity-resolver.d.ts.map

package/dist/core/memory/entity-resolver.js

@@ -1,64 +0,0 @@
-/**
- * Extract entities from a query using Claude
- * NO FALLBACKS - real extraction or throw
- */
-export async function extractQueryEntities(query, callClaudeFn) {
-    const prompt = `Extract entities from this question. Return ONLY JSON:
-{
-  "primary": ["Alice", "project name"],
-  "secondary": ["team", "budget"],
-  "queryType": "factual"
-}
-
-Question: ${query}`;
-    const response = await callClaudeFn(prompt, 500);
-    const jsonMatch = response.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-        throw new Error('No JSON in entity extraction');
-    }
-    const parsed = JSON.parse(jsonMatch[0]);
-    return {
-        primary: parsed.primary || [],
-        secondary: parsed.secondary || [],
-        queryType: parsed.queryType || 'factual',
-    };
-}
-/**
- * Score memory relevance based on entity matching
- * Returns boost factor (0-1)
- */
-export function scoreEntityMatch(memoryEntities, queryEntities) {
-    if (!queryEntities.length || !memoryEntities.length) {
-        return 0.5; // Neutral if no entities
-    }
-    const querySet = new Set(queryEntities.map(e => e.toLowerCase()));
-    const memorySet = new Set(memoryEntities.map(e => e.toLowerCase()));
-    // Count matches
-    let matches = 0;
-    for (const entity of querySet) {
-        if (memorySet.has(entity)) {
-            matches++;
-        }
-    }
-    // Calculate boost (0-1)
-    const matchRatio = matches / querySet.size;
-    return 0.5 + (matchRatio * 0.5); // 0.5 to 1.0
-}
-/**
- * Filter and boost memories by entity relevance
- */
-export function filterByEntities(memories, queryEntities) {
-    if (!queryEntities.length) {
-        // No entities to filter by, return all with neutral boost
-        return memories.map(m => ({ memory: m, entityBoost: 0.5 }));
-    }
-    return memories.map(memory => {
-        const memoryEntities = memory.metadata?.entities || [];
-        const boost = scoreEntityMatch(memoryEntities, queryEntities);
-        return {
-            memory,
-            entityBoost: boost,
-        };
-    });
-}
-//# sourceMappingURL=entity-resolver.js.map

package/dist/core/memory/fact-extractor.d.ts

@@ -1,24 +0,0 @@
-import type { RememberInput } from './memories.js';
-export interface ExtractedFact {
-    content: string;
-    confidence: number;
-    entities: string[];
-    relation?: string;
-}
-export interface FactExtractionResult {
-    facts: ExtractedFact[];
-    summary: string;
-    entities: string[];
-}
-/**
- * Extract facts from conversation text using Claude API
- *
- * This function MUST return valid facts or throw an error.
- * NO FALLBACKS - we need real extraction to reach 90% accuracy.
- */
-export declare function extractFacts(text: string, callClaude: (prompt: string, maxTokens: number) => Promise<string>): Promise<FactExtractionResult>;
-/**
- * Convert extracted facts to memory inputs
- */
-export declare function factsToMemoryInputs(sourceMemory: RememberInput, extraction: FactExtractionResult, sourceId: string): RememberInput[];
-//# sourceMappingURL=fact-extractor.d.ts.map

package/dist/core/memory/fact-extractor.js

@@ -1,89 +0,0 @@
-/**
- * Extract facts from conversation text using Claude API
- *
- * This function MUST return valid facts or throw an error.
- * NO FALLBACKS - we need real extraction to reach 90% accuracy.
- */
-export async function extractFacts(text, callClaude) {
-    if (!text || text.length < 50) {
-        // Too short for meaningful extraction - return as single fact
-        return {
-            facts: [{ content: text.trim(), confidence: 1.0, entities: [] }],
-            summary: text.trim(),
-            entities: []
-        };
-    }
-    const prompt = `Extract atomic facts from this conversation. 
-
-Requirements:
-- Extract specific, verifiable facts (names, dates, numbers, relationships)
-- Each fact should be a standalone statement
-- Identify entities (people, organizations, projects, locations)
-- Note temporal information and relationships
-
-Return ONLY valid JSON in this exact format:
-{"facts":[{"content":"fact statement","confidence":0.95,"entities":["Name"],"relation":"optional"}],"summary":"brief summary","entities":["all","entities"]}
-
-Text to analyze:
-${text.substring(0, 4000)}`;
-    const response = await callClaude(prompt, 2000);
-    // Extract JSON - look for the first { and last }
-    const startIdx = response.indexOf('{');
-    const endIdx = response.lastIndexOf('}');
-    if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) {
-        throw new Error(`Fact extraction failed: No valid JSON found in response. Response: ${response.substring(0, 200)}`);
-    }
-    const jsonStr = response.substring(startIdx, endIdx + 1);
-    let parsed;
-    try {
-        parsed = JSON.parse(jsonStr);
-    }
-    catch (parseError) {
-        throw new Error(`Fact extraction failed: JSON parse error. JSON: ${jsonStr.substring(0, 200)}`);
-    }
-    // Validate facts array exists and has content
-    if (!parsed.facts || !Array.isArray(parsed.facts)) {
-        throw new Error(`Fact extraction failed: Missing 'facts' array in response. Keys: ${Object.keys(parsed).join(', ')}`);
-    }
-    // Filter and clean facts
-    const validFacts = parsed.facts
-        .filter((f) => f && typeof f.content === 'string' && f.content.trim().length > 10)
-        .map((f) => ({
-        content: f.content.trim(),
-        confidence: Math.max(0, Math.min(1, typeof f.confidence === 'number' ? f.confidence : 0.8)),
-        entities: Array.isArray(f.entities) ? f.entities.filter((e) => typeof e === 'string') : [],
-        relation: typeof f.relation === 'string' ? f.relation : undefined
-    }));
-    if (validFacts.length === 0) {
-        throw new Error(`Fact extraction failed: No valid facts after filtering. Original count: ${parsed.facts.length}`);
-    }
-    return {
-        facts: validFacts,
-        summary: typeof parsed.summary === 'string' && parsed.summary.trim()
-            ? parsed.summary.trim()
-            : text.substring(0, 200),
-        entities: Array.isArray(parsed.entities)
-            ? parsed.entities.filter((e) => typeof e === 'string')
-            : []
-    };
-}
-/**
- * Convert extracted facts to memory inputs
- */
-export function factsToMemoryInputs(sourceMemory, extraction, sourceId) {
-    return extraction.facts.map((fact, index) => ({
-        content: fact.content,
-        type: 'fact',
-        metadata: {
-            sourceMemoryId: sourceId,
-            extractedAt: new Date().toISOString(),
-            entities: fact.entities,
-            relation: fact.relation,
-            confidence: Math.floor(fact.confidence * 100),
-            factIndex: index
-        },
-        tags: [...(sourceMemory.tags || []), 'extracted-fact', ...fact.entities],
-        project: sourceMemory.project
-    }));
-}
-//# sourceMappingURL=fact-extractor.js.map

package/dist/core/memory/feedback-tracker.d.ts

@@ -1,12 +0,0 @@
-/** Feedback Tracker - Track memory usage in responses for Echo/Fizzle loop */
-export declare function recordInjection(sessionId: string, memoryIds: string[], memoryContent: Map<string, string>): Promise<void>;
-export declare function analyzeAndRecordFeedback(sessionId: string, responseText: string): Promise<void>;
-export declare function updateRetrievalPriority(memoryId: string, delta: number): Promise<void>;
-export declare function getMemoryFeedbackStats(memoryId: string): Promise<{
-    totalInjections: number;
-    totalReferences: number;
-    echoRate: number;
-    averagePriorityDelta: number;
-}>;
-export declare function cleanupInjectionTracker(maxAgeMs?: number): void;
-//# sourceMappingURL=feedback-tracker.d.ts.map