secufusion-mcp 2.5.0 → 3.0.0

package/mcp/dist/regression_engine.js

@@ -0,0 +1,196 @@
+import fs from "fs";
+import path from "path";
+import { loadExperience } from "./experience_manager.js";
+// --- Snapshot Management ---
+export function loadSnapshot(ecosystemRoot, name) {
+    const p = path.join(ecosystemRoot, '.secufusion', `graph.${name}.json`);
+    if (!fs.existsSync(p))
+        return null;
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+export function saveSnapshot(ecosystemRoot, name, snap) {
+    const p = path.join(ecosystemRoot, '.secufusion', `graph.${name}.json`);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(snap, null, 2), "utf-8");
+}
+export function compareRepositorySnapshots(base, current) {
+    const changes = [];
+    const baseNodes = new Map(base.nodes.map(n => [n.id, n]));
+    const currNodes = new Map(current.nodes.map(n => [n.id, n]));
+    for (const [id, curr] of currNodes.entries()) {
+        if (!baseNodes.has(id)) {
+            changes.push({ category: `${curr.type}_ADDED`, artifact_id: id, current_evidence: curr });
+        }
+        else {
+            // Assume modified if it exists. A real diff would check metadata.
+            const b = baseNodes.get(id);
+            if (JSON.stringify(curr.metadata) !== JSON.stringify(b?.metadata)) {
+                changes.push({ category: `${curr.type}_MODIFIED`, artifact_id: id, base_evidence: b, current_evidence: curr });
+            }
+        }
+    }
+    for (const [id, b] of baseNodes.entries()) {
+        if (!currNodes.has(id)) {
+            changes.push({ category: `${b.type}_REMOVED`, artifact_id: id, base_evidence: b });
+        }
+    }
+    // Edges
+    const baseEdges = new Map(base.edges.map(e => [e.id, e]));
+    const currEdges = new Map(current.edges.map(e => [e.id, e]));
+    for (const [id, curr] of currEdges.entries()) {
+        if (!baseEdges.has(id)) {
+            changes.push({ category: `RELATIONSHIP_ADDED`, artifact_id: id, current_evidence: curr });
+        }
+    }
+    for (const [id, b] of baseEdges.entries()) {
+        if (!currEdges.has(id)) {
+            changes.push({ category: `RELATIONSHIP_REMOVED`, artifact_id: id, base_evidence: b });
+        }
+    }
+    return changes;
+}
+// --- Architecture Drift ---
+export function detectArchitectureDrift(base, current) {
+    const drift = [];
+    const changes = compareRepositorySnapshots(base, current);
+    for (const ch of changes) {
+        if (ch.category === "RELATIONSHIP_REMOVED" || ch.category === "RELATIONSHIP_ADDED") {
+            const edge = ch.current_evidence || ch.base_evidence;
+            if (edge.type === "CONSUMES" || edge.type === "PRODUCES") {
+                drift.push({ category: "EVENT_DRIFT", affected_component: edge.source, base_evidence: ch.base_evidence, current_evidence: ch.current_evidence, status: "DRIFT_DETECTED" });
+            }
+            else if (edge.type === "CALLS") {
+                drift.push({ category: "DEPENDENCY_DRIFT", affected_component: edge.source, base_evidence: ch.base_evidence, current_evidence: ch.current_evidence, status: "DRIFT_DETECTED" });
+            }
+            else if (edge.type === "OWNS") {
+                drift.push({ category: "DATABASE_DRIFT", affected_component: edge.source, base_evidence: ch.base_evidence, current_evidence: ch.current_evidence, status: "DRIFT_DETECTED" });
+            }
+            else if (edge.type === "EXPOSES") {
+                drift.push({ category: "API_DRIFT", affected_component: edge.source, base_evidence: ch.base_evidence, current_evidence: ch.current_evidence, status: "DRIFT_DETECTED" });
+            }
+        }
+    }
+    return drift;
+}
+// --- Requirement Drift ---
+export function detectRequirementDrift(reqs, current) {
+    const drift = [];
+    const currNodes = new Map(current.nodes.map(n => [n.id, n]));
+    for (const req of reqs) {
+        if (req.status !== "CONFIRMED")
+            continue;
+        if (req.apis) {
+            for (const api of req.apis) {
+                if (!currNodes.has(`API:${api}`)) {
+                    drift.push({ state: "DRIFT_DETECTED", condition: "API_NOT_IN_IMPLEMENTATION", requirement_id: req.id, expected_artifact: api });
+                }
+            }
+        }
+    }
+    return drift;
+}
+// --- Traceability Drift ---
+export function detectTraceabilityDrift(links, current) {
+    const drift = [];
+    const currNodes = new Map(current.nodes.map(n => [n.id, n]));
+    for (const link of links) {
+        if (link.target && ["API", "CLASS", "SERVICE", "DATABASE_TABLE", "TOPIC"].includes(link.type) || link.target.startsWith("API:") || link.target.startsWith("CLASS:")) {
+            if (!currNodes.has(link.target)) {
+                drift.push({ condition: "CODE_WITHOUT_TRACEABILITY", source_id: link.source, target_id: link.target }); // Target disappeared
+            }
+        }
+    }
+    return drift;
+}
+// --- Historical Matching ---
+export function getChangeHistoryContext(ecosystemRoot, changes) {
+    const list = loadExperience(ecosystemRoot);
+    const affected = new Set(changes.map(c => {
+        if (c.current_evidence && c.current_evidence.source)
+            return c.current_evidence.source;
+        if (c.base_evidence && c.base_evidence.source)
+            return c.base_evidence.source;
+        return c.artifact_id;
+    }));
+    const results = [];
+    for (const exp of list) {
+        if (exp.status === "RETIRED")
+            continue;
+        if (exp.affected_components && exp.affected_components.some(c => affected.has(c))) {
+            results.push(exp);
+        }
+        if (results.length >= 10)
+            break; // Bounded
+    }
+    return results;
+}
+export function findRegressionTests(ecosystemRoot, changes, tests) {
+    const affected = new Set(changes.map(c => c.artifact_id));
+    return tests.filter(t => t.target_components && t.target_components.some((c) => affected.has(c)));
+}
+// --- Risk Indicators ---
+export function analyzeRegressionRisk(changes, history, drift, reqDrift, traceDrift, regressionTests) {
+    const risks = [];
+    if (history.length > 0) {
+        const failures = history.filter(h => h.outcome === "FAILURE" || h.outcome === "BLOCKED");
+        if (failures.length > 0) {
+            risks.push({ indicator: "HISTORICAL_FAILURE_MATCH", evidence: { matching_history: failures.map(f => f.id) }, risk_level: "HIGH_EVIDENCE_RISK" });
+        }
+        const experiences = history.filter(h => h.status === "VALIDATED");
+        if (experiences.length > 0) {
+            risks.push({ indicator: "HISTORICAL_VALIDATED_EXPERIENCE_MATCH", evidence: { matching_experience: experiences.map(e => e.id) }, risk_level: "MODERATE_EVIDENCE_RISK" });
+        }
+    }
+    if (drift.length > 0) {
+        risks.push({ indicator: "ARCHITECTURE_DRIFT", evidence: { drift_count: drift.length }, risk_level: "MODERATE_EVIDENCE_RISK" });
+    }
+    if (traceDrift.length > 0) {
+        risks.push({ indicator: "TRACEABILITY_GAP", evidence: { gaps: traceDrift }, risk_level: "MODERATE_EVIDENCE_RISK" });
+    }
+    // Cross-service
+    const services = new Set();
+    changes.forEach(c => {
+        const node = c.current_evidence || c.base_evidence;
+        if (node?.repository)
+            services.add(node.repository);
+        if (node?.id?.startsWith("SERVICE:"))
+            services.add(node.id);
+    });
+    if (services.size > 1) {
+        risks.push({ indicator: "CROSS_SERVICE_CHANGE", evidence: { services: Array.from(services) }, risk_level: "HIGH_EVIDENCE_RISK" });
+    }
+    return risks;
+}
+export function getRegressionContext(ecosystemRoot, base, current, reqs, links, allTests) {
+    const changes = compareRepositorySnapshots(base, current);
+    const archDrift = detectArchitectureDrift(base, current);
+    const reqDrift = detectRequirementDrift(reqs, current);
+    const traceDrift = detectTraceabilityDrift(links, current);
+    const history = getChangeHistoryContext(ecosystemRoot, changes);
+    const regTests = findRegressionTests(ecosystemRoot, changes, allTests);
+    // Check regression test gaps
+    if (history.some(h => h.outcome === "FAILURE") && regTests.length === 0) {
+        traceDrift.push({ condition: "REQUIRED_REGRESSION_TEST_MISSING", source_id: "MULTIPLE" });
+    }
+    const risks = analyzeRegressionRisk(changes, history, archDrift, reqDrift, traceDrift, regTests);
+    return {
+        current_changes: changes.slice(0, 50), // Bounded
+        architecture_drift: archDrift.slice(0, 20),
+        requirement_drift: reqDrift.slice(0, 20),
+        traceability_drift: traceDrift.slice(0, 20),
+        historical_experience: history.filter(h => h.status === "VALIDATED"),
+        historical_failures: history.filter(h => h.outcome === "FAILURE" || h.outcome === "BLOCKED"),
+        regression_tests: regTests,
+        risk_indicators: risks
+    };
+}
+export function recordRegressionObservation(ecosystemRoot, observation) {
+    const p = path.join(ecosystemRoot, '.secufusion', 'regressions.json');
+    let list = [];
+    if (fs.existsSync(p)) {
+        list = JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    list.push({ ...observation, id: `OBS-${Date.now()}` });
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(list, null, 2), "utf-8");
+}

package/mcp/dist/requirement_manager.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path from 'path';
+export function getRequirementPath(ecosystemRoot, reqId) {
+    const reqDir = path.join(ecosystemRoot, ".secufusion", "requirements");
+    if (!fs.existsSync(reqDir)) {
+        fs.mkdirSync(reqDir, { recursive: true });
+    }
+    return path.join(reqDir, `${reqId}.json`);
+}
+export function loadRequirement(ecosystemRoot, reqId) {
+    const p = getRequirementPath(ecosystemRoot, reqId);
+    if (!fs.existsSync(p))
+        return null;
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+export function saveRequirement(ecosystemRoot, req) {
+    const p = getRequirementPath(ecosystemRoot, req.id);
+    fs.writeFileSync(p, JSON.stringify(req, null, 2));
+}
+export function validateStateTransition(current, next, req) {
+    if (next === "BLOCKED" || next === "SUPERSEDED")
+        return true;
+    const validFlows = {
+        "RAW": ["UNDERSTOOD", "INVESTIGATING", "BLOCKED", "SUPERSEDED"],
+        "UNDERSTOOD": ["INVESTIGATING", "BLOCKED", "SUPERSEDED"],
+        "INVESTIGATING": ["CONFIRMED", "CLARIFICATION_REQUIRED", "BLOCKED", "SUPERSEDED"],
+        "CLARIFICATION_REQUIRED": ["INVESTIGATING", "BLOCKED", "SUPERSEDED"],
+        "CONFIRMED": ["INVESTIGATING", "BLOCKED", "SUPERSEDED"],
+        "BLOCKED": ["INVESTIGATING", "SUPERSEDED"],
+        "SUPERSEDED": []
+    };
+    if (!validFlows[current].includes(next)) {
+        throw new Error(`Invalid transition from ${current} to ${next}`);
+    }
+    if (next === "CONFIRMED") {
+        if (req.blockers && req.blockers.length > 0) {
+            throw new Error("Cannot transition to CONFIRMED with active blockers.");
+        }
+        const openClarifications = req.clarification_questions.filter(c => c.state === "OPEN" && c.blocking);
+        if (openClarifications.length > 0) {
+            throw new Error("Cannot transition to CONFIRMED with OPEN blocking clarification questions.");
+        }
+    }
+    return true;
+}
+export function generateConfirmedSpecification(req) {
+    let spec = `---
+Requirement ID: ${req.id}
+Title: ${req.title || "Untitled"}
+Status: ${req.status}
+---
+
+# CONFIRMED SPECIFICATION
+
+## WHAT THE USER REQUESTED
+${req.raw_request || "Not provided."}
+
+## WHAT THE REPOSITORY CURRENTLY DOES
+(Based on gathered facts)
+${req.facts ? req.facts.map(f => "- " + f).join("\\n") : "No facts recorded."}
+
+## WHAT WAS CONFIRMED BY THE USER
+${req.decisions ? req.decisions.map(d => "- " + d).join("\\n") : "No specific decisions recorded."}
+
+## WHAT REMAINS UNKNOWN
+${req.unknowns ? req.unknowns.map(u => "- " + u).join("\\n") : "None."}
+
+## SCOPE & DETAILS
+- Scope: ${req.scope || "Unknown"}
+- Tenancy: ${req.tenancy || "Unknown"}
+- Authorization: ${req.authorization || "Unknown"}
+- Data Lifecycle: ${req.data_lifecycle || "Unknown"}
+
+### Technical Implications
+- APIs: ${req.apis ? req.apis.join(", ") : "None"}
+- Events: ${req.events ? req.events.join(", ") : "None"}
+- Persistence: ${req.persistence ? req.persistence.join(", ") : "None"}
+- Frontend: ${req.frontend ? req.frontend.join(", ") : "None"}
+
+## ACCEPTANCE CRITERIA
+${req.acceptance_criteria ? req.acceptance_criteria.map(a => "- [ ] " + a).join("\\n") : "None specified."}
+`;
+    return spec;
+}

package/mcp/dist/run_benchmarks.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+function runQuery(graph, query, depth) {
+    const queryLower = query.toLowerCase();
+    let startNodes = graph.nodes.filter((n) => (n.id.toLowerCase().includes(queryLower) || n.name.toLowerCase().includes(queryLower)));
+    const resultNodes = new Map();
+    const resultEdges = new Map();
+    let currentLayer = startNodes;
+    for (let d = 0; d <= depth; d++) {
+        const nextLayer = [];
+        for (const n of currentLayer) {
+            if (!resultNodes.has(n.id))
+                resultNodes.set(n.id, n);
+        }
+        if (d < depth) {
+            for (const edge of graph.edges) {
+                if (resultNodes.has(edge.source) || resultNodes.has(edge.target)) {
+                    if (!resultEdges.has(edge.id)) {
+                        resultEdges.set(edge.id, edge);
+                        const sourceNode = graph.nodes.find((n) => n.id === edge.source);
+                        const targetNode = graph.nodes.find((n) => n.id === edge.target);
+                        if (sourceNode && !resultNodes.has(sourceNode.id))
+                            nextLayer.push(sourceNode);
+                        if (targetNode && !resultNodes.has(targetNode.id))
+                            nextLayer.push(targetNode);
+                    }
+                }
+            }
+        }
+        currentLayer = nextLayer;
+    }
+    return {
+        query,
+        nodes: Array.from(resultNodes.values()),
+        edges: Array.from(resultEdges.values())
+    };
+}
+const ecosystemRoot = "c:\\Users\\Yash\\Desktop\\mcp";
+const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+if (!fs.existsSync(dnaPath)) {
+    console.error("No dna.json found at", dnaPath);
+    process.exit(1);
+}
+const dna = JSON.parse(fs.readFileSync(dnaPath, 'utf8'));
+const graph = dna.graph;
+if (!graph) {
+    console.error("No graph in dna.json");
+    process.exit(1);
+}
+console.log("--- User Deletion Benchmark ---");
+const userRes = runQuery(graph, "User", 2);
+console.log(`Found ${userRes.nodes.length} nodes and ${userRes.edges.length} edges for 'User'.`);
+// Print paths
+userRes.edges.slice(0, 10).forEach(e => {
+    console.log(`  ${e.source} --[${e.type}]--> ${e.target}`);
+});
+console.log("\n--- Retention Policy Benchmark ---");
+const retRes = runQuery(graph, "retention", 2);
+console.log(`Found ${retRes.nodes.length} nodes and ${retRes.edges.length} edges for 'retention'.`);
+retRes.edges.slice(0, 10).forEach(e => {
+    console.log(`  ${e.source} --[${e.type}]--> ${e.target}`);
+});