squish-memory 1.0.2 → 1.2.0

package/dist/core/graph/relationship-extractor.js

@@ -0,0 +1,351 @@
+/**
+ * Relationship Extractor
+ *
+ * Populates entity_relations table with typed relationships extracted
+ * from memory content.
+ */
+import { eq, and, or } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+import { extractEntitiesAndRelations, } from './llm-entity-extractor.js';
+// Fallback relationship types for non-LLM extraction
+const FALLBACK_RELATION_TYPES = {
+    CO_OCCURS: 'co_occurs_with',
+    SAME_SENTENCE: 'mentioned_together',
+    SEQUENTIAL: 'mentioned_before',
+};
+/**
+ * Generate fallback relationships from entity co-occurrence when LLM is unavailable.
+ * Creates edges between entities that appear in the same memory or sentence.
+ */
+function generateCoOccurrenceRelations(entities, content) {
+    const relations = [];
+    if (entities.length < 2)
+        return relations;
+    // Split content into sentences
+    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    // For each pair of entities, determine relationship strength based on proximity
+    for (let i = 0; i < entities.length; i++) {
+        for (let j = i + 1; j < entities.length; j++) {
+            const e1 = entities[i];
+            const e2 = entities[j];
+            // Skip if same entity
+            if (e1.name.toLowerCase() === e2.name.toLowerCase())
+                continue;
+            // Check if they appear in the same sentence
+            const sameSentence = sentences.some(sentence => {
+                return sentence.toLowerCase().includes(e1.name.toLowerCase()) &&
+                    sentence.toLowerCase().includes(e2.name.toLowerCase());
+            });
+            // Check if e1 appears before e2 in text
+            const e1Index = content.toLowerCase().indexOf(e1.name.toLowerCase());
+            const e2Index = content.toLowerCase().indexOf(e2.name.toLowerCase());
+            const sequential = e1Index >= 0 && e2Index >= 0 && e1Index < e2Index;
+            // Determine relation type and confidence
+            let relationType;
+            let confidence;
+            if (sameSentence) {
+                relationType = FALLBACK_RELATION_TYPES.SAME_SENTENCE;
+                confidence = 0.7;
+            }
+            else if (sequential) {
+                relationType = FALLBACK_RELATION_TYPES.SEQUENTIAL;
+                confidence = 0.5;
+            }
+            else {
+                relationType = FALLBACK_RELATION_TYPES.CO_OCCURS;
+                confidence = 0.3;
+            }
+            // Create bidirectional relationships
+            relations.push({
+                fromEntity: e1.name,
+                toEntity: e2.name,
+                relationType,
+                confidence,
+                context: `Co-occurrence in memory (${relationType})`,
+            });
+            relations.push({
+                fromEntity: e2.name,
+                toEntity: e1.name,
+                relationType,
+                confidence,
+                context: `Co-occurrence in memory (${relationType})`,
+            });
+        }
+    }
+    return relations;
+}
+/**
+ * Extract entities and relations from memory content and store them in the database.
+ * Returns the stored entities and relations.
+ */
+export async function extractAndStoreRelations(memoryId, content, projectId, options) {
+    // Step 1: Extract entities and relations from content
+    const extraction = await extractEntitiesAndRelations(content, options);
+    if (extraction.entities.length === 0 && extraction.relations.length === 0) {
+        return { entities: 0, relations: 0, source: extraction.source };
+    }
+    // Step 2: Store entities and get their IDs
+    const entityIdMap = await storeEntities(extraction.entities, projectId);
+    // Step 3: Generate fallback relationships if LLM didn't produce any
+    let relationsToStore = extraction.relations;
+    if (relationsToStore.length === 0 && extraction.entities.length >= 2) {
+        logger.debug('No relations extracted, generating co-occurrence fallback', {
+            entityCount: extraction.entities.length,
+        });
+        const fallbackRelations = generateCoOccurrenceRelations(extraction.entities, content);
+        relationsToStore = fallbackRelations;
+    }
+    // Step 4: Store relations between entities
+    const storedRelations = await storeRelations(relationsToStore, entityIdMap);
+    // Step 5: Link entities to the memory record
+    await linkEntitiesToMemory(memoryId, extraction.entities, projectId);
+    logger.info('Extracted and stored entities/relations', {
+        memoryId,
+        entityCount: entityIdMap.size,
+        relationCount: storedRelations,
+        source: extraction.source,
+    });
+    return {
+        entities: entityIdMap.size,
+        relations: storedRelations,
+        source: extraction.source === 'none' ? 'fallback' : extraction.source,
+    };
+}
+/**
+ * Store extracted entities in the database, returning a map of entity name -> ID.
+ * Deduplicates by name+type within the project.
+ */
+async function storeEntities(entities, projectId) {
+    const db = await getDb();
+    const schema = await getSchema();
+    const entityIdMap = new Map();
+    for (const entity of entities) {
+        try {
+            // Check if entity already exists (by name + type + project)
+            const existing = await db
+                .select()
+                .from(schema.entities)
+                .where(and(eq(schema.entities.projectId, projectId), eq(schema.entities.name, entity.name), eq(schema.entities.type, entity.type)))
+                .limit(1);
+            if (existing.length > 0) {
+                // Update mention count and last_mentioned_at
+                await db
+                    .update(schema.entities)
+                    .set({
+                    mentionCount: (existing[0].mentionCount || 0) + 1,
+                    lastMentionedAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(schema.entities.id, existing[0].id));
+                entityIdMap.set(entity.name, existing[0].id);
+            }
+            else {
+                // Create new entity
+                const newEntity = {
+                    name: entity.name,
+                    type: entity.type,
+                    projectId,
+                    description: entity.context || null,
+                    properties: {
+                        confidence: entity.confidence,
+                        normalized: entity.normalized,
+                    },
+                };
+                const inserted = await db
+                    .insert(schema.entities)
+                    .values(newEntity)
+                    .returning();
+                entityIdMap.set(entity.name, inserted[0].id);
+            }
+        }
+        catch (error) {
+            logger.debug('Error storing entity', { entity: entity.name, error: error });
+            // Continue with other entities
+        }
+    }
+    return entityIdMap;
+}
+/**
+ * Store extracted relations in the entity_relations table.
+ * Deduplicates by from+to+type.
+ */
+async function storeRelations(relations, entityIdMap) {
+    const db = await getDb();
+    const schema = await getSchema();
+    let storedCount = 0;
+    for (const relation of relations) {
+        const fromId = entityIdMap.get(relation.fromEntity);
+        const toId = entityIdMap.get(relation.toEntity);
+        // Skip relations where we can't resolve both entities
+        if (!fromId || !toId) {
+            // Try to find entities by name even if not in our extraction
+            continue;
+        }
+        try {
+            // Check if relation already exists
+            const existing = await db
+                .select()
+                .from(schema.entityRelations)
+                .where(and(eq(schema.entityRelations.fromEntityId, fromId), eq(schema.entityRelations.toEntityId, toId), eq(schema.entityRelations.type, relation.relationType)))
+                .limit(1);
+            if (existing.length > 0) {
+                // Strengthen existing relation
+                await db
+                    .update(schema.entityRelations)
+                    .set({
+                    weight: Math.min(10, (existing[0].weight || 1) + 1),
+                    properties: {
+                        ...(existing[0].properties || {}),
+                        confidence: relation.confidence,
+                        context: relation.context,
+                        lastSeen: new Date().toISOString(),
+                    },
+                })
+                    .where(eq(schema.entityRelations.id, existing[0].id));
+            }
+            else {
+                // Create new relation
+                await db.insert(schema.entityRelations).values({
+                    fromEntityId: fromId,
+                    toEntityId: toId,
+                    type: relation.relationType,
+                    weight: Math.round(relation.confidence * 10),
+                    properties: {
+                        confidence: relation.confidence,
+                        context: relation.context,
+                    },
+                });
+            }
+            storedCount++;
+        }
+        catch (error) {
+            logger.debug('Error storing relation', {
+                from: relation.fromEntity,
+                to: relation.toEntity,
+                error: error,
+            });
+        }
+    }
+    return storedCount;
+}
+/**
+ * Link extracted entities to a memory record.
+ * Updates the memory's metadata with entity references.
+ */
+async function linkEntitiesToMemory(memoryId, entities, projectId) {
+    const db = await getDb();
+    const schema = await getSchema();
+    try {
+        // Get current memory metadata
+        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];
+        const existingMetadata = memory.metadata || {};
+        // Add entity names to metadata
+        const entityNames = entities.map(e => e.name);
+        const existingEntities = Array.isArray(existingMetadata.entities) ? existingMetadata.entities : [];
+        const updatedMetadata = {
+            ...existingMetadata,
+            entities: [...new Set([...existingEntities, ...entityNames])],
+        };
+        await db
+            .update(schema.memories)
+            .set({ metadata: updatedMetadata })
+            .where(eq(schema.memories.id, memoryId));
+    }
+    catch (error) {
+        logger.debug('Error linking entities to memory', { memoryId, error: error });
+    }
+}
+/**
+ * Get all relations for a set of entity IDs.
+ * Used by graph traversal to find connected entities.
+ */
+export async function getEntityRelations(entityIds, relationTypes) {
+    const db = await getDb();
+    const schema = await getSchema();
+    const whereConditions = relationTypes
+        ? and(or(...entityIds.map(id => eq(schema.entityRelations.fromEntityId, id))), or(...relationTypes.map(type => eq(schema.entityRelations.type, type))))
+        : or(...entityIds.map(id => eq(schema.entityRelations.fromEntityId, id)));
+    const relations = await db
+        .select()
+        .from(schema.entityRelations)
+        .where(whereConditions);
+    // Also get incoming relations
+    const incomingRelations = await db
+        .select()
+        .from(schema.entityRelations)
+        .where(or(...entityIds.map(id => eq(schema.entityRelations.toEntityId, id))));
+    // Combine and deduplicate
+    const allRelations = [...relations, ...incomingRelations];
+    const seen = new Set();
+    const unique = [];
+    for (const r of allRelations) {
+        if (!seen.has(r.id)) {
+            seen.add(r.id);
+            unique.push({
+                id: r.id,
+                fromEntityId: r.fromEntityId,
+                toEntityId: r.toEntityId,
+                fromEntityName: '', // Will be populated by caller if needed
+                toEntityName: '',
+                relationType: r.type,
+                weight: r.weight || 1,
+                properties: r.properties,
+            });
+        }
+    }
+    return unique;
+}
+/**
+ * Get all entities for a project.
+ */
+export async function getProjectEntities(projectId, limit = 100) {
+    const db = await getDb();
+    const schema = await getSchema();
+    const entities = await db
+        .select({
+        id: schema.entities.id,
+        name: schema.entities.name,
+        type: schema.entities.type,
+        description: schema.entities.description,
+    })
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId))
+        .limit(limit);
+    return entities;
+}
+/**
+ * Delete all entities and relations for a project (for graph rebuild).
+ */
+export async function clearProjectGraph(projectId) {
+    const db = await getDb();
+    const schema = await getSchema();
+    // Delete relations first (foreign key constraint)
+    const projectEntities = await db
+        .select({ id: schema.entities.id })
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    const entityIds = projectEntities.map((e) => e.id);
+    if (entityIds.length > 0) {
+        // Delete relations involving these entities
+        for (const entityId of entityIds) {
+            await db
+                .delete(schema.entityRelations)
+                .where(or(eq(schema.entityRelations.fromEntityId, entityId), eq(schema.entityRelations.toEntityId, entityId)));
+        }
+    }
+    // Delete entities
+    await db
+        .delete(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    logger.info('Cleared project graph', { projectId, entityCount: entityIds.length });
+}
+//# sourceMappingURL=relationship-extractor.js.map

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

@@ -0,0 +1,83 @@
+/**
+ * Agent Hooks - Core Logic
+ *
+ * Universal hooks for auto-capturing agent activities.
+ * Works with Claude Code, OpenCode, Cursor, Windsurf.
+ *
+ * Hook events:
+ * - sessionStart: Inject relevant memories on session start
+ * - postToolUse: Record observations after tool execution
+ * - sessionEnd: Save snapshot and sync learnings
+ * - preCompact: Save state before context compaction
+ */
+/**
+ * Generate a new session ID (universal across agents)
+ */
+export declare function generateSessionId(): string;
+/**
+ * Get current session ID
+ */
+export declare function getCurrentSessionId(): string | null;
+/**
+ * Set session ID (for resume/continue)
+ */
+export declare function setSessionId(sessionId: string): void;
+/**
+ * Session start hook - inject relevant context
+ */
+export declare function handleSessionStart(params: {
+    projectPath: string;
+    mode: 'startup' | 'resume' | 'compact';
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    memories: string[];
+    sessionId: string;
+    count: number;
+    preferences?: Array<{
+        key: string;
+        value: string;
+    }>;
+    beliefs?: {
+        failures: string[];
+        constraints: string[];
+        decisions: string[];
+    };
+}>;
+/**
+ * Post-tool-use hook - record observations
+ */
+export declare function handlePostToolUse(params: {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolResult: unknown;
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    captured: boolean;
+    memoryId?: string;
+    reason?: string;
+}>;
+/**
+ * Session end hook - save snapshot and sync to persistent hot cache
+ */
+export declare function handleSessionEnd(params: {
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+    workInProgress?: string;
+}): Promise<{
+    snapshotId?: string;
+    memoriesSaved: number;
+}>;
+/**
+ * Pre-compact hook - save state for recovery
+ */
+export declare function handlePreCompact(params: {
+    projectPath: string;
+    agentType: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+}): Promise<{
+    stateSaved: boolean;
+    stateId?: string;
+}>;
+export { shouldCaptureTool, categorizeTool } from './capture-filter.js';
+export { inferTags } from './auto-tagger.js';
+//# sourceMappingURL=agent-hooks.d.ts.map