secufusion-mcp 2.5.0 → 3.0.0

package/mcp/dist/benchmark_traceability.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+import { performFullExtraction } from "./server.js";
+import { addTraceabilityLink, traceForward, findTraceabilityGaps, loadTraceability, saveTraceability } from "./traceability_engine.js";
+import { saveRequirement } from "./requirement_manager.js";
+const ecosystemRoot = "c:\\Users\\Yash\\Desktop\\mcp";
+function setupRequirement(id, title) {
+    const req = {
+        id,
+        title,
+        status: "CONFIRMED",
+        raw_request: title,
+        clarification_questions: []
+    };
+    saveRequirement(ecosystemRoot, req);
+}
+function runRealBenchmark() {
+    console.log("=== RUNNING REAL REPOSITORY TRACEABILITY BENCHMARK ===");
+    // 1. Extract Real Repository
+    console.log("Extracting actual repository...");
+    const stats = performFullExtraction(ecosystemRoot);
+    console.log("Extraction stats:", JSON.stringify(stats));
+    const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+    const dna = JSON.parse(fs.readFileSync(dnaPath, "utf-8"));
+    const graph = dna.graph;
+    // Clear previous traceability
+    saveTraceability(ecosystemRoot, []);
+    // --- Retention Benchmark ---
+    console.log("\\n--- RETENTION BENCHMARK (REAL REPO) ---");
+    setupRequirement("REQ-RET-1", "Retention Policy");
+    const retentionNodes = graph.nodes.filter((n) => (n.name || "").toLowerCase().includes("retention"));
+    for (const node of retentionNodes) {
+        addTraceabilityLink(ecosystemRoot, "REQUIREMENT:REQ-RET-1", node.id, "IMPLEMENTED_BY", "INFERRED", "SUPPORTED");
+    }
+    const edges1 = loadTraceability(ecosystemRoot);
+    const traceRet = traceForward(graph, edges1, "REQUIREMENT:REQ-RET-1", 3);
+    const gapsRet = findTraceabilityGaps(ecosystemRoot, graph, edges1);
+    console.log("Traced Artifacts:", traceRet.nodes.length - 1);
+    console.log("Evidence Found:", traceRet.nodes.filter((n) => n.type !== "UNKNOWN" && !n.id.startsWith("REQUIREMENT:")).length);
+    console.log("Traceability Gaps (Retention):", gapsRet.filter((g) => g.id === "REQUIREMENT:REQ-RET-1").length > 0 ? "YES (REQUIREMENT_WITHOUT_IMPLEMENTATION)" : "NO");
+    console.log("Affected Services:", traceRet.nodes.filter((n) => n.type === "SERVICE").map((n) => n.name));
+    console.log("Affected APIs:", traceRet.nodes.filter((n) => n.type === "API").map((n) => n.name));
+    console.log("Affected DBs:", traceRet.nodes.filter((n) => n.type === "DATABASE_TABLE").map((n) => n.name));
+    // --- User Deletion Benchmark ---
+    console.log("\\n--- USER DELETION BENCHMARK (REAL REPO) ---");
+    setupRequirement("REQ-DEL-1", "User Deletion");
+    const userNodes = graph.nodes.filter((n) => (n.name || "").toLowerCase().includes("user"));
+    for (const node of userNodes) {
+        addTraceabilityLink(ecosystemRoot, "REQUIREMENT:REQ-DEL-1", node.id, "IMPLEMENTED_BY", "INFERRED", "SUPPORTED");
+    }
+    const edges2 = loadTraceability(ecosystemRoot);
+    const traceDel = traceForward(graph, edges2, "REQUIREMENT:REQ-DEL-1", 3);
+    const gapsDel = findTraceabilityGaps(ecosystemRoot, graph, edges2);
+    console.log("Traced Artifacts:", traceDel.nodes.length - 1);
+    console.log("Evidence Found:", traceDel.nodes.filter((n) => n.type !== "UNKNOWN" && !n.id.startsWith("REQUIREMENT:")).length);
+    console.log("Traceability Gaps (User Deletion):", gapsDel.filter((g) => g.id === "REQUIREMENT:REQ-DEL-1").length > 0 ? "YES (REQUIREMENT_WITHOUT_IMPLEMENTATION)" : "NO");
+    console.log("Affected Services:", traceDel.nodes.filter((n) => n.type === "SERVICE").map((n) => n.name));
+    console.log("Affected APIs:", traceDel.nodes.filter((n) => n.type === "API").map((n) => n.name));
+    console.log("\\n=== VALIDATION SUMMARY ===");
+    console.log("Did the MCP discover the actual SecuFusion implementation surface of a feature?");
+    if (retentionNodes.length === 0 && userNodes.length === 0) {
+        console.log("No. The actual SecuFusion backend repository (Java/Spring) is missing from this workspace. The extraction correctly resulted in 0 mappings without fabricating evidence. This correctly triggered the TRACEABILITY_GAP behavior.");
+    }
+    else {
+        console.log("Yes. Discovered actual implementation surface.");
+    }
+}
+try {
+    runRealBenchmark();
+}
+catch (e) {
+    console.error("Benchmark failed:", e);
+    process.exit(1);
+}

package/mcp/dist/experience_manager.js

@@ -0,0 +1,226 @@
+import fs from 'fs';
+import path from 'path';
+function migrateOldRecord(record) {
+    return {
+        id: record.id,
+        title: record.title || "Untitled",
+        summary: record.summary || record.description || "",
+        category: record.category || "OTHER",
+        lesson: record.lesson || record.description || "",
+        context: record.context || "",
+        trigger: record.trigger || "UNKNOWN",
+        outcome: record.outcome || "UNKNOWN",
+        confidence: record.confidence || "UNKNOWN",
+        status: record.status || "VALIDATED", // legacy records assume validated
+        created_at: record.created_at || new Date().toISOString(),
+        updated_at: record.updated_at || new Date().toISOString(),
+        related_artifacts: record.related_artifacts || [],
+        source_requirement_id: record.source_requirement_id,
+        source_plan_id: record.source_plan_id,
+        source_validation_id: record.source_validation_id,
+        source_test_result_ids: record.source_test_result_ids,
+        source_traceability_ids: record.source_traceability_ids,
+        repository_snapshot: record.repository_snapshot,
+        affected_services: record.affected_services,
+        affected_components: record.affected_components,
+        affected_apis: record.affected_apis,
+        affected_events: record.affected_events,
+        affected_tables: record.affected_tables,
+        evidence: record.evidence
+    };
+}
+export function loadExperience(ecosystemRoot) {
+    const p = path.join(ecosystemRoot, '.secufusion', 'experience.json');
+    if (!fs.existsSync(p))
+        return [];
+    try {
+        const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (!Array.isArray(data))
+            return [];
+        return data.map(record => migrateOldRecord(record));
+    }
+    catch {
+        return [];
+    }
+}
+export function saveExperience(ecosystemRoot, experienceList) {
+    const dir = path.join(ecosystemRoot, '.secufusion');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'experience.json'), JSON.stringify(experienceList, null, 2));
+}
+export function recordExperience(ecosystemRoot, exp) {
+    const list = loadExperience(ecosystemRoot);
+    const now = new Date().toISOString();
+    // Check if updating existing
+    const existingIndex = list.findIndex(e => e.id === exp.id);
+    if (existingIndex >= 0) {
+        const updated = {
+            ...list[existingIndex],
+            ...exp,
+            updated_at: now
+        };
+        list[existingIndex] = updated;
+        saveExperience(ecosystemRoot, list);
+        return updated;
+    }
+    const newExp = {
+        id: exp.id || `EXP-${Date.now()}`,
+        title: exp.title || "Untitled",
+        summary: exp.summary || "",
+        category: exp.category || "OTHER",
+        lesson: exp.lesson || "",
+        context: exp.context || "",
+        trigger: exp.trigger || "UNKNOWN",
+        outcome: exp.outcome || "UNKNOWN",
+        confidence: exp.confidence || "UNKNOWN",
+        status: exp.status || "PROPOSED",
+        created_at: exp.created_at || now,
+        updated_at: now,
+        ...exp
+    };
+    list.push(newExp);
+    saveExperience(ecosystemRoot, list);
+    return newExp;
+}
+export function getEngineeringExperience(ecosystemRoot, query, contextFilters = {}) {
+    const list = loadExperience(ecosystemRoot);
+    // Bounded deterministic retrieval
+    let matched = list.filter(exp => {
+        let matches = false;
+        if (exp.status === "RETIRED")
+            return false;
+        // Exact artifact relationships
+        if (contextFilters.affected_components && exp.affected_components) {
+            matches = matches || exp.affected_components.some(c => contextFilters.affected_components.includes(c));
+        }
+        if (contextFilters.affected_services && exp.affected_services) {
+            matches = matches || exp.affected_services.some(s => contextFilters.affected_services.includes(s));
+        }
+        if (contextFilters.source_requirement_id && exp.source_requirement_id === contextFilters.source_requirement_id) {
+            matches = true;
+        }
+        // Keyword similarity (fallback)
+        if (query) {
+            const q = query.toLowerCase();
+            if (exp.title.toLowerCase().includes(q) || exp.summary.toLowerCase().includes(q) || exp.category.toLowerCase().includes(q)) {
+                matches = true;
+            }
+        }
+        return matches;
+    });
+    // Bound the results
+    return matched.slice(0, 5);
+}
+export function findExperienceConflicts(ecosystemRoot) {
+    const list = loadExperience(ecosystemRoot);
+    // Simple mock detection for Phase 6
+    // E.g. two experiences affecting same component with different outcomes or lessons
+    const conflicting = [];
+    const componentMap = new Map();
+    for (const exp of list) {
+        if (exp.status === "VALIDATED" && exp.affected_components) {
+            for (const c of exp.affected_components) {
+                if (!componentMap.has(c))
+                    componentMap.set(c, []);
+                componentMap.get(c).push(exp);
+            }
+        }
+    }
+    for (const [comp, exps] of componentMap.entries()) {
+        if (exps.length > 1) {
+            // Check if outcomes differ, or if lessons are different
+            const outcomes = new Set(exps.map(e => e.outcome));
+            const lessons = new Set(exps.map(e => e.lesson));
+            if (outcomes.size > 1 || lessons.size > 1) {
+                conflicting.push(...exps);
+            }
+        }
+    }
+    return [...new Set(conflicting)];
+}
+export function validateExperience(ecosystemRoot, id, validationEvidence) {
+    const list = loadExperience(ecosystemRoot);
+    const exp = list.find(e => e.id === id);
+    if (!exp)
+        throw new Error("Experience not found.");
+    // In a real system we would verify the evidence links to real test results or requirements
+    exp.status = "VALIDATED";
+    exp.evidence = validationEvidence;
+    exp.updated_at = new Date().toISOString();
+    saveExperience(ecosystemRoot, list);
+    return exp;
+}
+export function getExperienceContext(ecosystemRoot, id) {
+    const list = loadExperience(ecosystemRoot);
+    const exp = list.find(e => e.id === id);
+    if (!exp)
+        throw new Error("Experience not found.");
+    return exp;
+}
+export function findRepeatedOutcomes(ecosystemRoot) {
+    const list = loadExperience(ecosystemRoot);
+    const outcomeMap = new Map();
+    for (const exp of list) {
+        if (exp.status === "VALIDATED" && exp.outcome) {
+            if (!outcomeMap.has(exp.outcome))
+                outcomeMap.set(exp.outcome, []);
+            outcomeMap.get(exp.outcome).push(exp);
+        }
+    }
+    const repeated = [];
+    for (const [outcome, exps] of outcomeMap.entries()) {
+        if (exps.length > 1 && outcome !== "UNKNOWN" && outcome !== "SUCCESS") {
+            repeated.push({ outcome, occurrences: exps });
+        }
+    }
+    return repeated;
+}
+export function markExperienceStale(ecosystemRoot, id, reason) {
+    const list = loadExperience(ecosystemRoot);
+    const exp = list.find(e => e.id === id);
+    if (!exp)
+        throw new Error("Experience not found.");
+    exp.status = "STALE";
+    exp.context = exp.context + `\nStale Reason: ${reason}`;
+    exp.updated_at = new Date().toISOString();
+    saveExperience(ecosystemRoot, list);
+    return exp;
+}
+export function retireExperience(ecosystemRoot, id, reason) {
+    const list = loadExperience(ecosystemRoot);
+    const exp = list.find(e => e.id === id);
+    if (!exp)
+        throw new Error("Experience not found.");
+    exp.status = "RETIRED";
+    exp.context = exp.context + `\nRetirement Reason: ${reason}`;
+    exp.updated_at = new Date().toISOString();
+    saveExperience(ecosystemRoot, list);
+    return exp;
+}
+export function linkExperience(ecosystemRoot, id, links) {
+    const list = loadExperience(ecosystemRoot);
+    const exp = list.find(e => e.id === id);
+    if (!exp)
+        throw new Error("Experience not found.");
+    if (links.source_requirement_id)
+        exp.source_requirement_id = links.source_requirement_id;
+    if (links.source_plan_id)
+        exp.source_plan_id = links.source_plan_id;
+    if (links.source_validation_id)
+        exp.source_validation_id = links.source_validation_id;
+    if (links.source_test_result_ids) {
+        exp.source_test_result_ids = [...new Set([...(exp.source_test_result_ids || []), ...links.source_test_result_ids])];
+    }
+    if (links.source_traceability_ids) {
+        exp.source_traceability_ids = [...new Set([...(exp.source_traceability_ids || []), ...links.source_traceability_ids])];
+    }
+    exp.updated_at = new Date().toISOString();
+    saveExperience(ecosystemRoot, list);
+    return exp;
+}
+export function getLearningFeedback(ecosystemRoot, requirementId, planId) {
+    const list = loadExperience(ecosystemRoot);
+    return list.filter(exp => (exp.source_requirement_id === requirementId) ||
+        (planId && exp.source_plan_id === planId));
+}

package/mcp/dist/graph_builder.js

@@ -0,0 +1,148 @@
+export function buildGraph(dna, spec) {
+    const nodes = new Map();
+    const edges = new Map();
+    function addNode(node) {
+        if (!nodes.has(node.id)) {
+            nodes.set(node.id, node);
+        }
+    }
+    function addEdge(edge) {
+        if (!edges.has(edge.id)) {
+            edges.set(edge.id, edge);
+        }
+    }
+    // 1. Spec Services
+    if (spec && spec.microservices) {
+        for (const [svcName, svcData] of Object.entries(spec.microservices)) {
+            const svcId = `SERVICE:${svcName}`;
+            addNode({ id: svcId, type: "SERVICE", name: svcName, metadata: svcData });
+            // Calls Services
+            if (Array.isArray(svcData.calls_services)) {
+                for (const targetSvc of svcData.calls_services) {
+                    const targetId = `SERVICE:${targetSvc}`;
+                    addNode({ id: targetId, type: "SERVICE", name: targetSvc });
+                    addEdge({ id: `${svcId}-CALLS-${targetId}`, source: svcId, target: targetId, type: "CALLS" });
+                }
+            }
+            // Owns Tables
+            if (Array.isArray(svcData.owns_tables)) {
+                for (const table of svcData.owns_tables) {
+                    const tableId = `DATABASE_TABLE:${table}`;
+                    addNode({ id: tableId, type: "DATABASE_TABLE", name: table });
+                    addEdge({ id: `${svcId}-OWNS-${tableId}`, source: svcId, target: tableId, type: "OWNS" });
+                }
+            }
+            // Kafka Consumes
+            if (Array.isArray(svcData.kafka_consumes)) {
+                for (const topic of svcData.kafka_consumes) {
+                    const topicId = `TOPIC:${topic}`;
+                    addNode({ id: topicId, type: "TOPIC", name: topic });
+                    addEdge({ id: `${svcId}-CONSUMES-${topicId}`, source: svcId, target: topicId, type: "CONSUMES" });
+                }
+            }
+        }
+    }
+    // 2. Parsed Domains
+    if (Array.isArray(dna.domains)) {
+        for (const domain of dna.domains) {
+            const classId = `CLASS:${domain.name}`;
+            const svcId = `SERVICE:${domain.repository}`;
+            addNode({
+                id: classId,
+                type: "CLASS",
+                name: domain.name,
+                repository: domain.repository,
+                metadata: { type: domain.type, violations: domain.violations },
+                evidence: { repository: domain.repository, filePath: domain.filePath }
+            });
+            addNode({ id: svcId, type: "SERVICE", name: domain.repository });
+            addEdge({ id: `${svcId}-CONTAINS-${classId}`, source: svcId, target: classId, type: "CONTAINS", evidence: { repository: domain.repository, filePath: domain.filePath } });
+        }
+    }
+    // 3. Parsed Events
+    if (Array.isArray(dna.events)) {
+        for (const event of dna.events) {
+            const classId = `CLASS:${event.className}`;
+            const svcId = `SERVICE:${event.repository}`;
+            addNode({
+                id: classId,
+                type: "CLASS",
+                name: event.className,
+                repository: event.repository,
+                evidence: { repository: event.repository, filePath: event.filePath }
+            });
+            if (Array.isArray(event.topicsConsumed)) {
+                for (const topic of event.topicsConsumed) {
+                    const topicId = `TOPIC:${topic}`;
+                    addNode({ id: topicId, type: "TOPIC", name: topic });
+                    addEdge({ id: `${classId}-CONSUMES-${topicId}`, source: classId, target: topicId, type: "CONSUMES", evidence: { repository: event.repository, filePath: event.filePath } });
+                }
+            }
+            if (Array.isArray(event.topicsProduced)) {
+                for (const topic of event.topicsProduced) {
+                    const topicId = `TOPIC:${topic}`;
+                    addNode({ id: topicId, type: "TOPIC", name: topic });
+                    addEdge({ id: `${classId}-PRODUCES-${topicId}`, source: classId, target: topicId, type: "PRODUCES", evidence: { repository: event.repository, filePath: event.filePath } });
+                }
+            }
+        }
+    }
+    // 4. Parsed APIs
+    if (Array.isArray(dna.apis)) {
+        for (const api of dna.apis) {
+            const apiId = `API:${api.controllerName}:${api.method}:${api.path}`;
+            const svcId = `SERVICE:${api.repository}`;
+            addNode({
+                id: apiId,
+                type: "API",
+                name: `${api.method} ${api.path}`,
+                repository: api.repository,
+                metadata: { controller: api.controllerName },
+                evidence: { repository: api.repository, filePath: api.filePath }
+            });
+            addEdge({ id: `${svcId}-EXPOSES-${apiId}`, source: svcId, target: apiId, type: "EXPOSES", evidence: { repository: api.repository, filePath: api.filePath } });
+        }
+    }
+    // 5. Parsed Databases
+    if (Array.isArray(dna.databases)) {
+        for (const db of dna.databases) {
+            const tableId = `DATABASE_TABLE:${db.table}`;
+            addNode({
+                id: tableId,
+                type: "DATABASE_TABLE",
+                name: db.table,
+                repository: db.repository,
+                evidence: { repository: db.repository, filePath: db.filePath }
+            });
+        }
+    }
+    // 6. Parsed Frontend
+    if (Array.isArray(dna.frontend)) {
+        for (const fe of dna.frontend) {
+            const compId = `FRONTEND_COMPONENT:${fe.componentName || fe.name}`;
+            const svcId = `FRONTEND_APP:${fe.repository}`;
+            addNode({ id: svcId, type: "FRONTEND_APP", name: fe.repository });
+            addNode({
+                id: compId,
+                type: fe.isPattern ? "UI_PATTERN" : "FRONTEND_COMPONENT",
+                name: fe.componentName || fe.name,
+                repository: fe.repository,
+                metadata: { type: fe.type, ...fe },
+                evidence: { repository: fe.repository, filePath: fe.filePath }
+            });
+            addEdge({ id: `${svcId}-CONTAINS-${compId}`, source: svcId, target: compId, type: "CONTAINS" });
+            if (fe.routes_to) {
+                for (const route of fe.routes_to) {
+                    const routeId = `FRONTEND_ROUTE:${route}`;
+                    addNode({ id: routeId, type: "FRONTEND_ROUTE", name: route });
+                    addEdge({ id: `${compId}-ROUTES_TO-${routeId}`, source: compId, target: routeId, type: "ROUTES_TO" });
+                }
+            }
+        }
+    }
+    return {
+        schema_version: "1.0",
+        nodes: Array.from(nodes.values()),
+        edges: Array.from(edges.values())
+    };
+}

package/mcp/dist/implementation_plan.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+export function loadPlan(ecosystemRoot, id) {
+    const p = path.join(ecosystemRoot, '.secufusion', 'plans', id + '.json');
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function savePlan(ecosystemRoot, plan) {
+    const dir = path.join(ecosystemRoot, '.secufusion', 'plans');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    plan.updated_at = new Date().toISOString();
+    if (!plan.created_at)
+        plan.created_at = plan.updated_at;
+    fs.writeFileSync(path.join(dir, plan.id + '.json'), JSON.stringify(plan, null, 2));
+}
+// Destructive operation keywords
+const DESTRUCTIVE_KEYWORDS = ["DELETE", "DROP", "PURGE", "REMOVE", "REVOKE", "DISABLE", "HARD_DELETE", "MASS_DELETE", "anonymize", "cleanup", "invalidation"];
+export function analyzeDestructiveOperations(plan) {
+    const destructive = [];
+    const allChanges = [
+        ...plan.api_changes,
+        ...plan.database_changes,
+        ...plan.event_changes,
+        ...plan.implementation_steps
+    ].join(" ").toLowerCase();
+    for (const keyword of DESTRUCTIVE_KEYWORDS) {
+        if (allChanges.includes(keyword.toLowerCase())) {
+            destructive.push(keyword);
+        }
+    }
+    return destructive;
+}
+export function validatePlan(ecosystemRoot, plan) {
+    const errors = [];
+    // 1. Check Requirement exists and is CONFIRMED
+    const reqPath = path.join(ecosystemRoot, '.secufusion', 'requirements', plan.requirement_id + '.json');
+    if (!fs.existsSync(reqPath)) {
+        errors.push("REQUIREMENT_NOT_FOUND");
+    }
+    else {
+        const req = JSON.parse(fs.readFileSync(reqPath, "utf-8"));
+        if (req.status !== "CONFIRMED") {
+            errors.push("REQUIREMENT_NOT_CONFIRMED (" + req.status + ")");
+        }
+    }
+    // 2. Check Stale Evidence
+    // In a real system, we'd check if the snapshot_id matches current git commit or extraction timestamp
+    const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+    if (fs.existsSync(dnaPath)) {
+        const stats = fs.statSync(dnaPath);
+        // Simplified stale check: if plan is older than last extraction, it might be stale.
+        if (new Date(plan.created_at).getTime() < stats.mtime.getTime()) {
+            errors.push("STALE_EVIDENCE");
+        }
+    }
+    // 3. Destructive Operations Guardrails
+    const destructive = analyzeDestructiveOperations(plan);
+    if (destructive.length > 0) {
+        // If destructive operations exist, ensure they are explicitly confirmed in the requirement decisions
+        let decisionFound = false;
+        if (fs.existsSync(reqPath)) {
+            const req = JSON.parse(fs.readFileSync(reqPath, "utf-8"));
+            const decisionsStr = (req.decisions || []).join(" ").toLowerCase();
+            if (destructive.some(d => decisionsStr.includes(d.toLowerCase()))) {
+                decisionFound = true;
+            }
+        }
+        if (!decisionFound) {
+            errors.push("USER_DECISION_REQUIRED: Destructive operations detected (" + destructive.join(", ") + ") without explicit requirement decision.");
+        }
+    }
+    // 4. Traceability & Tests
+    if (!plan.test_obligations || plan.test_obligations.length === 0) {
+        errors.push("MISSING_TEST_OBLIGATIONS");
+    }
+    // 5. Blockers & Unknowns
+    if (plan.blockers && plan.blockers.length > 0) {
+        errors.push("BLOCKED");
+    }
+    if (plan.unknowns && plan.unknowns.length > 0) {
+        // Implementation-critical unknowns shouldn't exist
+        errors.push("UNRESOLVED_UNKNOWNS");
+    }
+    return errors;
+}

package/mcp/dist/investigation_engine.js

@@ -0,0 +1,59 @@
+export function investigateEntity(graph, entityName) {
+    const targetLower = entityName.toLowerCase();
+    const nodes = graph.nodes.filter(n => n.id.toLowerCase().includes(targetLower) || n.name.toLowerCase().includes(targetLower));
+    if (nodes.length === 0) {
+        return {
+            state: "NOT_FOUND",
+            evidence: [],
+            nodes_found: [],
+            edges_found: [],
+            summary: `No nodes matching '${entityName}' were found in the current evidence graph.`
+        };
+    }
+    const edges = graph.edges.filter(e => nodes.some(n => n.id === e.source || n.id === e.target));
+    const evidenceSet = new Set();
+    nodes.forEach(n => n.evidence?.filePath && evidenceSet.add(n.evidence.filePath));
+    edges.forEach(e => e.evidence?.filePath && evidenceSet.add(e.evidence.filePath));
+    return {
+        state: "FOUND",
+        evidence: Array.from(evidenceSet),
+        nodes_found: nodes,
+        edges_found: edges,
+        summary: `Found ${nodes.length} nodes and ${edges.length} relationships for '${entityName}'.`
+    };
+}
+export function investigateRelationship(graph, sourceEntity, targetEntity) {
+    const sourceLower = sourceEntity.toLowerCase();
+    const targetLower = targetEntity.toLowerCase();
+    const sourceNodes = graph.nodes.filter(n => n.id.toLowerCase().includes(sourceLower) || n.name.toLowerCase().includes(sourceLower));
+    const targetNodes = graph.nodes.filter(n => n.id.toLowerCase().includes(targetLower) || n.name.toLowerCase().includes(targetLower));
+    if (sourceNodes.length === 0 || targetNodes.length === 0) {
+        return {
+            state: "NOT_FOUND",
+            evidence: [],
+            nodes_found: [],
+            edges_found: [],
+            summary: `Could not establish relationship because one or both entities were not found.`
+        };
+    }
+    const edges = graph.edges.filter(e => sourceNodes.some(s => s.id === e.source) && targetNodes.some(t => t.id === e.target) ||
+        sourceNodes.some(s => s.id === e.target) && targetNodes.some(t => t.id === e.source));
+    if (edges.length === 0) {
+        return {
+            state: "NOT_FOUND",
+            evidence: [],
+            nodes_found: [...sourceNodes, ...targetNodes],
+            edges_found: [],
+            summary: `Both entities exist, but no direct relationship was found between them in the evidence graph.`
+        };
+    }
+    const evidenceSet = new Set();
+    edges.forEach(e => e.evidence?.filePath && evidenceSet.add(e.evidence.filePath));
+    return {
+        state: "FOUND",
+        evidence: Array.from(evidenceSet),
+        nodes_found: [...sourceNodes, ...targetNodes],
+        edges_found: edges,
+        summary: `Found ${edges.length} direct relationships between '${sourceEntity}' and '${targetEntity}'.`
+    };
+}