@massa-ai/core 1.2.1

package/dist/services/graph/memory-graph.service.js

@@ -0,0 +1,171 @@
+/**
+ * Memory Graph Service
+ *
+ * Orchestration layer that coordinates graph operations triggered
+ * by memory lifecycle events (store, search, delete).
+ *
+ * This service owns the composition of GraphStore, RelationExtractor,
+ * and GraphQueries. Tools and other services interact with the graph
+ * exclusively through this service, keeping them decoupled from
+ * graph internals.
+ *
+ * Uses `getGraphStore()` (the factory) so the active backend is selected
+ * by `DATABASE_URL` — PostgreSQL or PostgreSQL — rather than hardcoding the
+ * PostgreSQL singleton (structural gap #14).
+ */
+import { MemoryRelationType, logger, } from "@massa-ai/shared";
+import { getGraphStore } from "./graph-store-factory.js";
+import { RelationExtractor } from "./relation-extractor.js";
+import { GraphQueries } from "./graph-queries.js";
+export class MemoryGraphService {
+    static instance = null;
+    store;
+    extractor;
+    queries;
+    constructor() {
+        // Route through the factory so the PG store is used when DATABASE_URL
+        // points at PostgreSQL (structural gap #14).
+        this.store = getGraphStore();
+        this.extractor = new RelationExtractor(this.store);
+        this.queries = new GraphQueries(this.store);
+    }
+    static getInstance() {
+        if (!MemoryGraphService.instance) {
+            MemoryGraphService.instance = new MemoryGraphService();
+        }
+        return MemoryGraphService.instance;
+    }
+    // ── Lifecycle hooks (called by tools) ──────────────────────
+    /**
+     * Called after a memory is successfully stored.
+     * Creates explicit links and triggers background relation extraction.
+     */
+    async onMemoryStored(memoryId, linkTo = []) {
+        try {
+            // 1. Create explicit edges requested by the caller
+            for (const targetId of linkTo) {
+                await this.store.createEdge({
+                    sourceId: memoryId,
+                    targetId,
+                    relationType: MemoryRelationType.RELATES_TO,
+                    weight: 0.8,
+                    evidence: "Explicit link by user/agent",
+                });
+            }
+            // 2. Extract automatic relations (non-blocking)
+            const edgesCreated = await this.extractor.extractRelations(memoryId);
+            if (edgesCreated > 0 || linkTo.length > 0) {
+                logger.info("Graph updated after memory store", {
+                    memoryId,
+                    explicitLinks: linkTo.length,
+                    autoExtracted: edgesCreated,
+                });
+            }
+        }
+        catch (error) {
+            // Graph operations are best-effort; never fail the store
+            logger.warn("Graph update failed after memory store", {
+                memoryId,
+                error: error.message,
+            });
+        }
+    }
+    /**
+     * Called when a memory is deleted.
+     * Cleans up all connected edges.
+     */
+    async onMemoryDeleted(memoryId) {
+        try {
+            const removed = await this.store.deleteEdgesForMemory(memoryId);
+            if (removed > 0) {
+                logger.info("Graph edges cleaned after memory delete", {
+                    memoryId,
+                    edgesRemoved: removed,
+                });
+            }
+        }
+        catch (error) {
+            logger.warn("Graph cleanup failed after memory delete", {
+                memoryId,
+                error: error.message,
+            });
+        }
+    }
+    // ── Query operations (called by tools and services) ────────
+    /**
+     * Get memories related to a given memory via graph traversal.
+     */
+    async getRelatedContext(memoryId, options) {
+        return this.queries.getRelatedContext(memoryId, options);
+    }
+    /**
+     * Find the shortest path between two memories.
+     */
+    async findPath(fromId, toId, maxDepth) {
+        return this.queries.findPath(fromId, toId, maxDepth);
+    }
+    /**
+     * Detect contradictions in the memory graph.
+     */
+    async findContradictions(limit) {
+        return this.queries.findContradictions(limit);
+    }
+    /**
+     * Follow the decision chain leading to a memory.
+     */
+    async getDecisionChain(memoryId, maxDepth) {
+        return this.queries.getDecisionChain(memoryId, maxDepth);
+    }
+    /**
+     * Get hub memories (most connected nodes).
+     */
+    async getHubMemories(limit) {
+        return this.queries.getHubMemories(limit);
+    }
+    /**
+     * Get a human-readable summary of a memory's neighborhood.
+     * Useful for injecting into LLM context alongside search results.
+     */
+    async getNeighborhoodSummary(memoryId) {
+        return this.queries.getNeighborhoodSummary(memoryId);
+    }
+    // ── Direct edge operations ─────────────────────────────────
+    /**
+     * Create a manual edge between two memories.
+     */
+    async linkMemories(sourceId, targetId, relationType, options) {
+        return this.store.createEdge({
+            sourceId,
+            targetId,
+            relationType,
+            ...options,
+            autoExtracted: false,
+        });
+    }
+    /**
+     * Remove an edge by ID.
+     */
+    async unlinkMemories(edgeId) {
+        return this.store.deleteEdge(edgeId);
+    }
+    /**
+     * Get all edges for a memory.
+     */
+    async getEdges(memoryId) {
+        return this.store.getAllEdges(memoryId);
+    }
+    // ── Analytics ──────────────────────────────────────────────
+    /**
+     * Get graph-level statistics.
+     */
+    async getStats() {
+        return this.store.getStats();
+    }
+    /**
+     * Get degree centrality for a specific memory.
+     */
+    async getDegree(memoryId) {
+        return this.store.getDegree(memoryId);
+    }
+}
+//# sourceMappingURL=memory-graph.service.js.map

package/dist/services/graph/memory-graph.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-graph.service.js","sourceRoot":"","sources":["../../../src/services/graph/memory-graph.service.ts"],"names":[],"mappings":"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"}

package/dist/services/graph/relation-extractor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Relation Extractor
+ *
+ * Extracts semantic relationships between memories using:
+ * 1. Embedding similarity to find candidate pairs
+ * 2. Heuristic rules to classify relation types
+ *
+ * Runs in background after each store_memory call.
+ * Uses rule-based extraction (no LLM dependency) for speed,
+ * with optional LLM refinement when available.
+ */
+import { ExtractedRelation } from "@massa-ai/shared";
+import type { MemoryRow } from "../../data/memory/memory-repository.js";
+import type { IGraphStore } from "./types.js";
+interface ExtractionOptions {
+    /** Max similar memories to compare against */
+    candidateLimit?: number;
+    /** Min similarity to consider a relation */
+    similarityThreshold?: number;
+    /** Min confidence to create an edge */
+    confidenceThreshold?: number;
+}
+export declare class RelationExtractor {
+    private embeddingService;
+    private graphStore;
+    constructor(graphStore?: IGraphStore);
+    /**
+     * Extract relations for a newly stored memory.
+     * Called in background after store_memory.
+     *
+     * Steps:
+     * 1. Get embedding of new memory
+     * 2. Find top-N similar existing memories
+     * 3. For each candidate, classify the relation
+     * 4. Create edges for high-confidence relations
+     */
+    extractRelations(memoryId: string, options?: ExtractionOptions): Promise<number>;
+    /**
+     * Find memories with similar embeddings (brute-force cosine similarity).
+     */
+    private findSimilarMemories;
+    /**
+     * Classify the relation between two memories using heuristic rules.
+     *
+     * Rules cascade by priority:
+     * 1. SUPERSEDES: same type, high similarity, newer contradicts older
+     * 2. CONTRADICTS: contradiction signals in newer content
+     * 3. RESOLVES: resolution signals + related bug/decision
+     * 4. DERIVED_FROM: derivation signals or same topic chain
+     * 5. SUPPORTS: support signals or reinforcing pattern
+     * 6. RELATES_TO: high similarity but no specific relation
+     */
+    classifyRelation(newMemory: MemoryRow, existingMemory: MemoryRow & {
+        similarity: number;
+    }): ExtractedRelation;
+    private loadMemory;
+    private sharesTags;
+    private cosineSimilarity;
+}
+export {};
+//# sourceMappingURL=relation-extractor.d.ts.map

package/dist/services/graph/relation-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-extractor.d.ts","sourceRoot":"","sources":["../../../src/services/graph/relation-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAEL,iBAAiB,EAElB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,UAAU,iBAAiB;IACzB,8CAA8C;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uCAAuC;IACvC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAqED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,UAAU,CAAc;gBAEpB,UAAU,CAAC,EAAE,WAAW;IAKpC;;;;;;;;;OASG;IACG,gBAAgB,CACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,MAAM,CAAC;IA+ElB;;OAEG;YACW,mBAAmB;IA4CjC;;;;;;;;;;OAUG;IACH,gBAAgB,CACd,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,SAAS,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GACjD,iBAAiB;YAsHN,UAAU;IAIxB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,gBAAgB;CAezB"}

package/dist/services/graph/relation-extractor.js

@@ -0,0 +1,306 @@
+/**
+ * Relation Extractor
+ *
+ * Extracts semantic relationships between memories using:
+ * 1. Embedding similarity to find candidate pairs
+ * 2. Heuristic rules to classify relation types
+ *
+ * Runs in background after each store_memory call.
+ * Uses rule-based extraction (no LLM dependency) for speed,
+ * with optional LLM refinement when available.
+ */
+import { MemoryRelationType, logger, } from "@massa-ai/shared";
+import { EmbeddingService } from "../embeddings/index.js";
+import { getGraphStore } from "./graph-store-factory.js";
+import { getMemoryRepository } from "../../data/memory/memory-repository-factory.js";
+const DEFAULT_OPTIONS = {
+    candidateLimit: 5,
+    similarityThreshold: 0.65,
+    confidenceThreshold: 0.6,
+};
+// Keywords that indicate contradiction
+const CONTRADICTION_SIGNALS = [
+    "instead of",
+    "no longer",
+    "don't use",
+    "deprecated",
+    "replaced by",
+    "wrong approach",
+    "should not",
+    "avoid",
+    "changed from",
+    "was incorrect",
+    "não usar",
+    "substituir",
+    "evitar",
+    "incorreto",
+];
+// Keywords that indicate resolution
+const RESOLUTION_SIGNALS = [
+    "fixed",
+    "resolved",
+    "solved",
+    "workaround",
+    "fix for",
+    "solution",
+    "corrected",
+    "patched",
+    "resolvido",
+    "corrigido",
+    "solução",
+];
+// Keywords that indicate derivation
+const DERIVATION_SIGNALS = [
+    "based on",
+    "derived from",
+    "building on",
+    "extending",
+    "following up",
+    "as discussed",
+    "per decision",
+    "baseado em",
+    "derivado de",
+    "conforme",
+];
+// Keywords that indicate support
+const SUPPORT_SIGNALS = [
+    "confirms",
+    "supports",
+    "validates",
+    "consistent with",
+    "aligns with",
+    "evidence for",
+    "proves",
+    "confirma",
+    "valida",
+    "consistente",
+];
+export class RelationExtractor {
+    embeddingService;
+    graphStore;
+    constructor(graphStore) {
+        this.embeddingService = new EmbeddingService();
+        this.graphStore = graphStore ?? getGraphStore();
+    }
+    /**
+     * Extract relations for a newly stored memory.
+     * Called in background after store_memory.
+     *
+     * Steps:
+     * 1. Get embedding of new memory
+     * 2. Find top-N similar existing memories
+     * 3. For each candidate, classify the relation
+     * 4. Create edges for high-confidence relations
+     */
+    async extractRelations(memoryId, options) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        let edgesCreated = 0;
+        try {
+            // Load the new memory
+            const memory = await this.loadMemory(memoryId);
+            if (!memory) {
+                logger.warn("RelationExtractor: memory not found", { memoryId });
+                return 0;
+            }
+            // Get embedding
+            const embedding = memory.embedding
+                ? Array.from(new Float32Array(memory.embedding.buffer, memory.embedding.byteOffset, memory.embedding.byteLength / 4))
+                : null;
+            if (!embedding || embedding.every((v) => v === 0)) {
+                logger.debug("RelationExtractor: no valid embedding", { memoryId });
+                return 0;
+            }
+            // Find similar memories
+            const candidates = await this.findSimilarMemories(memoryId, embedding, memory.project_id, opts.candidateLimit, opts.similarityThreshold);
+            if (candidates.length === 0) {
+                return 0;
+            }
+            // Classify relation for each candidate
+            for (const candidate of candidates) {
+                const relation = this.classifyRelation(memory, candidate);
+                if (relation.relation !== "NONE" &&
+                    relation.confidence >= opts.confidenceThreshold) {
+                    const edge = await this.graphStore.createEdge({
+                        sourceId: memoryId,
+                        targetId: candidate.id,
+                        relationType: relation.relation,
+                        weight: relation.confidence,
+                        evidence: relation.evidence,
+                        autoExtracted: true,
+                    });
+                    if (edge) {
+                        edgesCreated++;
+                    }
+                }
+            }
+            if (edgesCreated > 0) {
+                logger.info("RelationExtractor: edges created", {
+                    memoryId,
+                    edgesCreated,
+                    candidatesEvaluated: candidates.length,
+                });
+            }
+        }
+        catch (error) {
+            logger.warn("RelationExtractor: extraction failed", {
+                memoryId,
+                error: error.message,
+            });
+        }
+        return edgesCreated;
+    }
+    /**
+     * Find memories with similar embeddings (brute-force cosine similarity).
+     */
+    async findSimilarMemories(excludeId, queryEmbedding, projectId, limit, threshold) {
+        const repo = getMemoryRepository();
+        if (typeof repo.findRecentWithEmbeddings !== "function")
+            return [];
+        const rows = await repo.findRecentWithEmbeddings(excludeId, projectId, 500);
+        // Calculate cosine similarity
+        const scored = [];
+        for (const row of rows) {
+            if (!row.embedding)
+                continue;
+            const candidateEmbedding = Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
+            if (candidateEmbedding.length !== queryEmbedding.length)
+                continue;
+            if (candidateEmbedding.every((v) => v === 0))
+                continue;
+            const similarity = this.cosineSimilarity(queryEmbedding, candidateEmbedding);
+            if (similarity >= threshold) {
+                scored.push({ ...row, similarity });
+            }
+        }
+        // Sort by similarity descending
+        scored.sort((a, b) => b.similarity - a.similarity);
+        return scored.slice(0, limit);
+    }
+    /**
+     * Classify the relation between two memories using heuristic rules.
+     *
+     * Rules cascade by priority:
+     * 1. SUPERSEDES: same type, high similarity, newer contradicts older
+     * 2. CONTRADICTS: contradiction signals in newer content
+     * 3. RESOLVES: resolution signals + related bug/decision
+     * 4. DERIVED_FROM: derivation signals or same topic chain
+     * 5. SUPPORTS: support signals or reinforcing pattern
+     * 6. RELATES_TO: high similarity but no specific relation
+     */
+    classifyRelation(newMemory, existingMemory) {
+        const newContent = newMemory.content.toLowerCase();
+        const existingContent = existingMemory.content.toLowerCase();
+        const similarity = existingMemory.similarity;
+        // ── Rule 1: SUPERSEDES ───────────────────────────────────
+        // Same type, very high similarity, newer replaces older
+        if (newMemory.type === existingMemory.type &&
+            similarity >= 0.92 &&
+            newMemory.created_at > existingMemory.created_at) {
+            return {
+                relation: MemoryRelationType.SUPERSEDES,
+                confidence: Math.min(0.95, similarity),
+                evidence: `Very high similarity (${(similarity * 100).toFixed(0)}%) with same type; newer memory likely supersedes older`,
+            };
+        }
+        // ── Rule 2: CONTRADICTS ──────────────────────────────────
+        const contradictionMatch = CONTRADICTION_SIGNALS.find((signal) => newContent.includes(signal) &&
+            (similarity >= 0.5 || this.sharesTags(newMemory, existingMemory)));
+        if (contradictionMatch) {
+            return {
+                relation: MemoryRelationType.CONTRADICTS,
+                confidence: 0.7 + similarity * 0.2,
+                evidence: `Contradiction signal "${contradictionMatch}" detected in new memory`,
+            };
+        }
+        // ── Rule 3: RESOLVES ─────────────────────────────────────
+        const resolutionMatch = RESOLUTION_SIGNALS.find((signal) => newContent.includes(signal));
+        if (resolutionMatch &&
+            (existingMemory.type === "decision" || existingMemory.type === "pattern")) {
+            return {
+                relation: MemoryRelationType.RESOLVES,
+                confidence: 0.65 + similarity * 0.25,
+                evidence: `Resolution signal "${resolutionMatch}" found; existing memory is ${existingMemory.type}`,
+            };
+        }
+        // ── Rule 4: DERIVED_FROM ─────────────────────────────────
+        const derivationMatch = DERIVATION_SIGNALS.find((signal) => newContent.includes(signal));
+        if (derivationMatch) {
+            return {
+                relation: MemoryRelationType.DERIVED_FROM,
+                confidence: 0.6 + similarity * 0.3,
+                evidence: `Derivation signal "${derivationMatch}" detected`,
+            };
+        }
+        // Type-based derivation: code from decision, pattern from code
+        if ((newMemory.type === "code" && existingMemory.type === "decision") ||
+            (newMemory.type === "pattern" && existingMemory.type === "code")) {
+            if (similarity >= 0.7) {
+                return {
+                    relation: MemoryRelationType.DERIVED_FROM,
+                    confidence: 0.55 + similarity * 0.3,
+                    evidence: `Type derivation chain: ${existingMemory.type} → ${newMemory.type}`,
+                };
+            }
+        }
+        // ── Rule 5: SUPPORTS ─────────────────────────────────────
+        const supportMatch = SUPPORT_SIGNALS.find((signal) => newContent.includes(signal));
+        if (supportMatch) {
+            return {
+                relation: MemoryRelationType.SUPPORTS,
+                confidence: 0.6 + similarity * 0.3,
+                evidence: `Support signal "${supportMatch}" detected`,
+            };
+        }
+        // Same type, moderate-high similarity = implicit support
+        if (newMemory.type === existingMemory.type &&
+            similarity >= 0.8 &&
+            (newMemory.type === "pattern" || newMemory.type === "decision")) {
+            return {
+                relation: MemoryRelationType.SUPPORTS,
+                confidence: 0.5 + similarity * 0.3,
+                evidence: `Same type (${newMemory.type}) with high similarity suggests mutual support`,
+            };
+        }
+        // ── Rule 6: RELATES_TO (fallback for high similarity) ────
+        if (similarity >= 0.75) {
+            return {
+                relation: MemoryRelationType.RELATES_TO,
+                confidence: similarity * 0.8,
+                evidence: `High semantic similarity (${(similarity * 100).toFixed(0)}%) without specific relation pattern`,
+            };
+        }
+        // No relation detected
+        return {
+            relation: "NONE",
+            confidence: 0,
+            evidence: "",
+        };
+    }
+    // ── Helpers ────────────────────────────────────────────────
+    async loadMemory(memoryId) {
+        return getMemoryRepository().getById(memoryId);
+    }
+    sharesTags(a, b) {
+        try {
+            const tagsA = a.tags ? JSON.parse(a.tags) : [];
+            const tagsB = b.tags ? JSON.parse(b.tags) : [];
+            return tagsA.some((t) => tagsB.includes(t));
+        }
+        catch {
+            return false;
+        }
+    }
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+}
+//# sourceMappingURL=relation-extractor.js.map

package/dist/services/graph/relation-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-extractor.js","sourceRoot":"","sources":["../../../src/services/graph/relation-extractor.ts"],"names":[],"mappings":"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"}