secufusion-mcp 2.5.0 → 3.0.0

package/mcp/dist/benchmark_phase4.js

@@ -0,0 +1,135 @@
+import { savePlan, validatePlan } from "./implementation_plan.js";
+import { generateTestObligations, aggregateValidation } from "./validation_engine.js";
+import { recordExperience, loadExperience } from "./experience_manager.js";
+import { saveRequirement } from "./requirement_manager.js";
+import { saveTraceability } from "./traceability_engine.js";
+import { performFullExtraction } from "./server.js";
+import fs from 'fs';
+import path from 'path';
+const ecosystemRoot = "c:\\Users\\Yash\\Desktop\\mcp";
+function setupRequirement(id, title, status, decisions = []) {
+    const req = {
+        id,
+        title,
+        status,
+        raw_request: title,
+        clarification_questions: [],
+        decisions
+    };
+    saveRequirement(ecosystemRoot, req);
+}
+function runPhase4Benchmark() {
+    console.log("=== RUNNING PHASE 4 VALIDATION BENCHMARK ===");
+    // 1. Initial State Setup
+    const stats = performFullExtraction(ecosystemRoot);
+    const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+    const dna = JSON.parse(fs.readFileSync(dnaPath, "utf-8"));
+    const graph = dna.graph;
+    saveTraceability(ecosystemRoot, []);
+    // 2. Retention Benchmark (Destructive Operation without Explicit Decision)
+    console.log("\\n--- RETENTION: Destructive Operation Guardrails ---");
+    setupRequirement("REQ-RET-2", "Implement retention policy cleanup", "CONFIRMED"); // No decisions array has "cleanup"
+    let planRet = {
+        id: "PLAN-RET",
+        requirement_id: "REQ-RET-2",
+        status: "DRAFT",
+        summary: "Delete old events",
+        affected_services: ["sfn-events-api"],
+        affected_files: [],
+        api_changes: [],
+        database_changes: [],
+        event_changes: [],
+        frontend_changes: [],
+        extension_changes: [],
+        security_implications: [],
+        implementation_steps: ["cleanup events older than 30 days"], // destructive keyword
+        test_obligations: ["Test deletion limits"],
+        validation_requirements: [],
+        traceability_requirements: [],
+        risks: [],
+        assumptions: [],
+        unknowns: [],
+        blockers: [],
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        snapshot_id: "LATEST"
+    };
+    savePlan(ecosystemRoot, planRet);
+    let errorsRet = validatePlan(ecosystemRoot, planRet);
+    console.log("Validation Errors (No Decision):", errorsRet);
+    let validationRet = aggregateValidation("CONFIRMED", errorsRet, [], [], [], false);
+    console.log("Overall State (No Decision):", validationRet.overall);
+    // Now with explicit decision
+    setupRequirement("REQ-RET-2", "Implement retention policy cleanup", "CONFIRMED", ["Authorized to cleanup old events"]);
+    errorsRet = validatePlan(ecosystemRoot, planRet);
+    console.log("Validation Errors (With Decision):", errorsRet);
+    validationRet = aggregateValidation("CONFIRMED", errorsRet, [], [], [], false);
+    console.log("Overall State (With Decision):", validationRet.overall);
+    // 3. User Deletion Benchmark (Test Obligations)
+    console.log("\\n--- USER DELETION: Test Intelligence ---");
+    setupRequirement("REQ-DEL-2", "User Deletion Feature", "CONFIRMED");
+    let planDel = {
+        id: "PLAN-DEL",
+        requirement_id: "REQ-DEL-2",
+        status: "DRAFT",
+        summary: "Delete user via API",
+        affected_services: ["sfn-iam-api"],
+        affected_files: [],
+        api_changes: ["DELETE /users/{id}"],
+        database_changes: ["DELETE cascade on users table"],
+        event_changes: ["Produce user-deleted event"],
+        frontend_changes: [],
+        extension_changes: [],
+        security_implications: ["Requires admin scope"],
+        implementation_steps: ["Perform deletion"],
+        test_obligations: [],
+        validation_requirements: [],
+        traceability_requirements: [],
+        risks: [],
+        assumptions: [],
+        unknowns: [],
+        blockers: [],
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        snapshot_id: "LATEST"
+    };
+    const generatedTests = generateTestObligations(planDel);
+    console.log("Auto-Generated Test Obligations:");
+    generatedTests.forEach(t => console.log("-", t));
+    // Missing test obligations validation check
+    let errorsDel = validatePlan(ecosystemRoot, planDel);
+    console.log("Validation Errors (Missing Tests in Plan):", errorsDel);
+    let validationDel = aggregateValidation("CONFIRMED", errorsDel, [], [], [], false);
+    console.log("Overall State (Missing Tests):", validationDel.overall);
+    // 4. Stale Evidence Check
+    console.log("\\n--- STALE EVIDENCE ---");
+    planDel.test_obligations = generatedTests;
+    planDel.created_at = new Date(Date.now() - 100000).toISOString(); // Make it older than last extraction
+    savePlan(ecosystemRoot, planDel);
+    let errorsStale = validatePlan(ecosystemRoot, planDel);
+    console.log("Validation Errors (Stale Plan):", errorsStale);
+    let validationStale = aggregateValidation("CONFIRMED", errorsStale, [], [], [], false);
+    console.log("Overall State (Stale):", validationStale.overall);
+    // 5. Experience Persistence
+    console.log("\\n--- EXPERIENCE PERSISTENCE ---");
+    const exp = recordExperience(ecosystemRoot, {
+        id: "EXP-1",
+        category: "ANTI_PATTERN",
+        title: "Silent Deletion",
+        summary: "Never delete users without producing a user-deleted event.",
+        lesson: "Never delete users without producing a user-deleted event.",
+        context: "Discovered during User Deletion Phase 4 benchmark",
+        related_artifacts: []
+    });
+    console.log("Recorded Experience ID:", exp.id);
+    const loadedExp = loadExperience(ecosystemRoot);
+    console.log("Loaded Experiences:", loadedExp.length);
+    console.log("Experience Title:", loadedExp[0].title);
+}
+try {
+    runPhase4Benchmark();
+}
+catch (e) {
+    console.error("Benchmark failed:", e);
+    process.exit(1);
+}

package/mcp/dist/benchmark_phase5.js

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import path from 'path';
+import { savePlan, validatePlan } from "./implementation_plan.js";
+import { generateTestObligations, aggregateValidation } from "./validation_engine.js";
+import { executeTests, ingestTestResults, loadTestResults, correlateTestFailure } from "./test_engine.js";
+import { saveRequirement } from "./requirement_manager.js";
+import { saveTraceability } from "./traceability_engine.js";
+import { performFullExtraction } from "./server.js";
+const ecosystemRoot = "c:\\Users\\Yash\\Desktop\\mcp";
+function setupRequirement(id, title, status, decisions = []) {
+    const req = {
+        id,
+        title,
+        status,
+        raw_request: title,
+        clarification_questions: [],
+        decisions
+    };
+    saveRequirement(ecosystemRoot, req);
+}
+function runPhase5Benchmark() {
+    console.log("=== RUNNING PHASE 5 TESTING INTELLIGENCE BENCHMARK ===");
+    // Initial Setup
+    const stats = performFullExtraction(ecosystemRoot);
+    const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+    const dna = JSON.parse(fs.readFileSync(dnaPath, "utf-8"));
+    const graph = dna.graph;
+    saveTraceability(ecosystemRoot, []);
+    fs.writeFileSync(path.join(ecosystemRoot, '.secufusion', 'tests', 'results.json'), '[]'); // Clear tests
+    console.log("\\n--- 1. TEST DISCOVERY & INGESTION (User Deletion) ---");
+    setupRequirement("REQ-DEL-5", "User Deletion Tests", "CONFIRMED", ["Authorized to delete user"]);
+    // Create Plan
+    let planDel = {
+        id: "PLAN-DEL-5",
+        requirement_id: "REQ-DEL-5",
+        status: "DRAFT",
+        summary: "Delete user test execution",
+        affected_services: ["sfn-iam-api"],
+        affected_files: [],
+        api_changes: ["DELETE /users/{id}"],
+        database_changes: ["DELETE cascade on users table"],
+        event_changes: [],
+        frontend_changes: [],
+        extension_changes: [],
+        security_implications: [],
+        implementation_steps: ["Perform deletion"],
+        test_obligations: ["Test deletion limits"],
+        validation_requirements: [],
+        traceability_requirements: [],
+        risks: [],
+        assumptions: [],
+        unknowns: [],
+        blockers: [],
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        snapshot_id: "LATEST"
+    };
+    const obligations = generateTestObligations(planDel);
+    planDel.test_obligations = obligations;
+    savePlan(ecosystemRoot, planDel);
+    // Missing test execution -> Should be UNKNOWN
+    let errors = validatePlan(ecosystemRoot, planDel);
+    console.log("Validation Errors:", errors);
+    let tests = loadTestResults(ecosystemRoot);
+    let validation = aggregateValidation("CONFIRMED", errors, planDel.test_obligations, tests, [], false);
+    console.log("Validation State with MISSING test executions:", validation.overall); // Should be UNKNOWN
+    // Ingest PASS results
+    const passResult = {
+        id: "TR-1",
+        test_name: "testUserDeletionCascade",
+        suite_name: "UserDeletionTest",
+        repository: "sfn-iam-api",
+        file_path: "UNKNOWN",
+        status: "PASS",
+        duration_ms: 150,
+        exit_code: 0,
+        timestamp: new Date().toISOString(),
+        execution_identity: "EXEC-1"
+    };
+    ingestTestResults(ecosystemRoot, [passResult]);
+    tests = loadTestResults(ecosystemRoot);
+    validation = aggregateValidation("CONFIRMED", errors, planDel.test_obligations, tests, [], false);
+    console.log("Validation State with PASS tests:", validation.overall, "(tests=", validation.tests, ", planErrors=", errors, ", testResults=", tests, ")"); // Should be PASS
+    console.log("\\n--- 2. FAIL NORMALIZATION & CORRELATION (Retention) ---");
+    // Ingest FAIL results
+    const failResult = {
+        id: "TR-2",
+        test_name: "testRetentionPolicyCleanup",
+        suite_name: "RetentionJobTest",
+        repository: "sfn-events-api",
+        file_path: "UNKNOWN",
+        status: "FAIL",
+        duration_ms: 1200,
+        exit_code: 1,
+        failure_message: "Expected 0 events, found 5",
+        failure_type: "ASSERTION_FAILURE",
+        timestamp: new Date().toISOString(),
+        execution_identity: "EXEC-2"
+    };
+    // Map traceability to a fake RetentionJob node
+    graph.nodes.push({ id: "CLASS:RetentionJob", type: "CLASS", name: "RetentionJob", repository: "sfn-events-api" });
+    const edges = [{ source: "TEST:testRetentionPolicyCleanup", target: "CLASS:RetentionJob", relation: "TESTS", confidence: "DIRECT", extractionMethod: "STATIC" }];
+    const correlated = correlateTestFailure(graph, edges, failResult);
+    console.log("Failure Correlated Artifacts:", correlated);
+    ingestTestResults(ecosystemRoot, [failResult]);
+    tests = loadTestResults(ecosystemRoot);
+    validation = aggregateValidation("CONFIRMED", errors, planDel.test_obligations, tests, [], false);
+    console.log("Validation State with FAIL test:", validation.overall); // Should be FAIL
+    console.log("\\n--- 3. TEST EXECUTION (Controlled BOUNDARY) ---");
+    // Run an echo command
+    const execResults = executeTests(ecosystemRoot, "echo 'Testing controlled execution'", ".");
+    console.log("Execution Result Status:", execResults[0].status);
+    console.log("Execution Output Captured:", execResults.length);
+}
+try {
+    runPhase5Benchmark();
+}
+catch (e) {
+    console.error("Benchmark failed:", e);
+    process.exit(1);
+}

package/mcp/dist/benchmark_phase6.js

@@ -0,0 +1,83 @@
+import fs from "fs";
+import path from "path";
+import { recordExperience, getEngineeringExperience, validateExperience, markExperienceStale, linkExperience, findExperienceConflicts } from "./experience_manager.js";
+function resetExperience(ecosystemRoot) {
+    const expPath = path.join(ecosystemRoot, '.secufusion', 'experience.json');
+    if (fs.existsSync(expPath))
+        fs.unlinkSync(expPath);
+}
+function runBenchmark() {
+    console.log("=== RUNNING PHASE 6 ENGINEERING KNOWLEDGE BENCHMARK ===\n");
+    // Use a temp workspace to avoid polluting real .secufusion
+    const ecosystemRoot = path.join(process.cwd(), '.benchmark_tmp_ph6');
+    if (!fs.existsSync(ecosystemRoot))
+        fs.mkdirSync(ecosystemRoot, { recursive: true });
+    resetExperience(ecosystemRoot);
+    try {
+        console.log("--- 1. RECORDING PROPOSED EXPERIENCE ---");
+        const exp1 = recordExperience(ecosystemRoot, {
+            id: "EXP-RETENTION",
+            title: "Retention Cleanup Idempotency",
+            summary: "Previous retention cleanup required idempotent execution due to retries.",
+            category: "SCHEDULING",
+            lesson: "Always use idempotent queries for cleanup jobs in RetentionPolicy.",
+            outcome: "FAILURE",
+            affected_components: ["CLASS:RetentionJob", "CLASS:Scheduler"],
+            status: "PROPOSED",
+            evidence: "Run failures in Phase 3"
+        });
+        console.log(`Recorded: ${exp1.id} with status ${exp1.status}`);
+        console.log("\n--- 2. VALIDATING EXPERIENCE WITH EVIDENCE ---");
+        const validatedExp = validateExperience(ecosystemRoot, exp1.id, "TEST-RESULT: PASS for idempotent query");
+        console.log(`Validated: ${validatedExp.id}, Status: ${validatedExp.status}, Evidence: ${validatedExp.evidence}`);
+        console.log("\n--- 3. TRACEABILITY INTEGRATION (LINKING) ---");
+        const linkedExp = linkExperience(ecosystemRoot, exp1.id, {
+            source_requirement_id: "REQ-101",
+            source_traceability_ids: ["TR-99"]
+        });
+        console.log(`Linked: ${linkedExp.id}, Source Req: ${linkedExp.source_requirement_id}`);
+        console.log("\n--- 4. RETENTION BENCHMARK (STALENESS) ---");
+        // Simulated: We discover that the current repository scheduler implementation has changed
+        console.log("Simulating repository evidence check: Scheduler has been replaced with Quartz.");
+        const staleExp = markExperienceStale(ecosystemRoot, exp1.id, "Scheduler implementation replaced by Quartz, making old idempotency logic obsolete.");
+        console.log(`Stale State: ${staleExp.status}`);
+        console.log(`Stale Reason in context: ${staleExp.context}`);
+        console.log("\n--- 5. USER DELETION BENCHMARK (CONFLICTS) ---");
+        recordExperience(ecosystemRoot, {
+            id: "EXP-DEL-1",
+            title: "Hard delete user events",
+            summary: "User deletion must cascade to events.",
+            category: "DELETION",
+            lesson: "Use cascade delete.",
+            outcome: "SUCCESS",
+            affected_components: ["CLASS:UserDeletionService"],
+            status: "VALIDATED"
+        });
+        recordExperience(ecosystemRoot, {
+            id: "EXP-DEL-2",
+            title: "Anonymize user events",
+            summary: "User deletion must anonymize events.",
+            category: "DELETION",
+            lesson: "Use anonymization strategy.",
+            outcome: "SUCCESS",
+            affected_components: ["CLASS:UserDeletionService"],
+            status: "VALIDATED"
+        });
+        const conflicts = findExperienceConflicts(ecosystemRoot);
+        console.log(`Conflicts Detected: ${conflicts.length} records on shared component.`);
+        conflicts.forEach(c => console.log(` - ${c.id}: ${c.title} (Outcome: ${c.outcome})`));
+        console.log("\n--- 6. BOUNDED RETRIEVAL ---");
+        const retrieved = getEngineeringExperience(ecosystemRoot, "", { affected_components: ["CLASS:RetentionJob"] });
+        console.log(`Retrieved ${retrieved.length} records for CLASS:RetentionJob`);
+        console.log(`Retrieved Record Status: ${retrieved[0].status}`);
+        console.log("\n=== BENCHMARK COMPLETE (ALL PASS) ===");
+    }
+    catch (e) {
+        console.error("Benchmark Failed:", e.message);
+        process.exit(1);
+    }
+    finally {
+        fs.rmSync(ecosystemRoot, { recursive: true, force: true });
+    }
+}
+runBenchmark();

package/mcp/dist/benchmark_phase7.js

@@ -0,0 +1,106 @@
+import fs from "fs";
+import path from "path";
+import { compareRepositorySnapshots, detectArchitectureDrift, detectRequirementDrift, detectTraceabilityDrift, getRegressionContext } from "./regression_engine.js";
+import { recordExperience } from "./experience_manager.js";
+function reset(ecosystemRoot) {
+    if (fs.existsSync(ecosystemRoot)) {
+        fs.rmSync(ecosystemRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(ecosystemRoot, { recursive: true });
+}
+function runBenchmark() {
+    console.log("=== RUNNING PHASE 7 CONTINUOUS INTELLIGENCE BENCHMARK ===\n");
+    const ecosystemRoot = path.join(process.cwd(), '.benchmark_tmp_ph7');
+    reset(ecosystemRoot);
+    try {
+        // --- Setup Data ---
+        const baseSnapshot = {
+            schema_version: "1.0",
+            nodes: [
+                { id: "SERVICE:sfn-iam-api", type: "SERVICE", name: "sfn-iam-api", repository: "sfn-iam-api" },
+                { id: "SERVICE:sfn-tenants-api", type: "SERVICE", name: "sfn-tenants-api", repository: "sfn-tenants-api" },
+                { id: "CLASS:UserDeletionService", type: "CLASS", name: "UserDeletionService", repository: "sfn-iam-api" },
+                { id: "CLASS:RetentionJob", type: "CLASS", name: "RetentionJob", repository: "sfn-tenants-api" },
+                { id: "API:GET:/api/tenants", type: "API", name: "GET /api/tenants", repository: "sfn-tenants-api" },
+                { id: "TOPIC:user-deleted", type: "TOPIC", name: "user-deleted" }
+            ],
+            edges: [
+                { id: "E1", source: "CLASS:UserDeletionService", target: "TOPIC:user-deleted", type: "PRODUCES" },
+                { id: "E2", source: "SERVICE:sfn-iam-api", target: "SERVICE:sfn-tenants-api", type: "CALLS" }
+            ]
+        };
+        const currentSnapshot = {
+            schema_version: "1.0",
+            nodes: [
+                { id: "SERVICE:sfn-iam-api", type: "SERVICE", name: "sfn-iam-api", repository: "sfn-iam-api" },
+                { id: "SERVICE:sfn-tenants-api", type: "SERVICE", name: "sfn-tenants-api", repository: "sfn-tenants-api" },
+                // UserDeletionService still exists but metadata/logic changed (represented via snapshot diff)
+                { id: "CLASS:UserDeletionService", type: "CLASS", name: "UserDeletionService", repository: "sfn-iam-api", metadata: { updated: true } },
+                { id: "CLASS:RetentionJob", type: "CLASS", name: "RetentionJob", repository: "sfn-tenants-api" },
+                // API GET /api/tenants is REMOVED
+                { id: "TOPIC:user-deleted", type: "TOPIC", name: "user-deleted" }
+            ],
+            edges: [
+            // Produces edge E1 is REMOVED (Architecture drift)
+            // Calls edge E2 is REMOVED
+            ]
+        };
+        const reqs = [
+            {
+                id: "REQ-1", status: "CONFIRMED",
+                apis: ["GET:/api/tenants"]
+            }
+        ];
+        const links = [
+            { id: "L1", source: "REQ-1", target: "API:GET:/api/tenants", type: "IMPLEMENTS", provenance: "USER_CONFIRMED", confidence: "CONFIRMED" }
+        ];
+        const allTests = [
+            { id: "TEST-1", name: "testUserDeletionCascade", target_components: ["CLASS:UserDeletionService"] }
+        ];
+        recordExperience(ecosystemRoot, {
+            id: "EXP-1", title: "Orphaned Events", summary: "User deletion left event references orphaned.",
+            category: "DELETION", lesson: "Validate cascade deletion.", outcome: "FAILURE",
+            affected_components: ["CLASS:UserDeletionService"], status: "VALIDATED"
+        });
+        // --- Benchmark 1: Snapshot Comparison ---
+        console.log("--- 1. SNAPSHOT COMPARISON ---");
+        const changes = compareRepositorySnapshots(baseSnapshot, currentSnapshot);
+        console.log(`Changes detected: ${changes.length}`);
+        changes.forEach(c => console.log(` - ${c.category}: ${c.artifact_id}`));
+        // --- Benchmark 2: Architecture Drift ---
+        console.log("\n--- 2. ARCHITECTURE DRIFT (BENCHMARK #26) ---");
+        const archDrift = detectArchitectureDrift(baseSnapshot, currentSnapshot);
+        console.log(`Drifts detected: ${archDrift.length}`);
+        archDrift.forEach(d => console.log(` - ${d.category} on ${d.affected_component} (Status: ${d.status})`));
+        // --- Benchmark 3: Requirement Drift ---
+        console.log("\n--- 3. REQUIREMENT DRIFT (BENCHMARK #27) ---");
+        const reqDrift = detectRequirementDrift(reqs, currentSnapshot);
+        console.log(`Requirement Drifts: ${reqDrift.length}`);
+        reqDrift.forEach(d => console.log(` - ${d.condition}: ${d.expected_artifact} for ${d.requirement_id}`));
+        // --- Benchmark 4: Traceability Drift ---
+        console.log("\n--- 4. TRACEABILITY DRIFT ---");
+        const traceDrift = detectTraceabilityDrift(links, currentSnapshot);
+        console.log(`Traceability Drifts: ${traceDrift.length}`);
+        traceDrift.forEach(d => console.log(` - ${d.condition}: ${d.target_id}`));
+        // --- Benchmark 5: Regression Tests & Context ---
+        console.log("\n--- 5. USER DELETION REGRESSION (BENCHMARK #25) & COVERAGE (BENCHMARK #28) ---");
+        const context = getRegressionContext(ecosystemRoot, baseSnapshot, currentSnapshot, reqs, links, allTests);
+        console.log(`Historical Failures matching changes: ${context.historical_failures.length}`);
+        console.log(`Regression Tests found: ${context.regression_tests.length}`);
+        console.log("\n--- 6. RISK INDICATORS (BENCHMARK #29 CROSS-SERVICE) ---");
+        context.risk_indicators.forEach(r => {
+            console.log(` - ${r.indicator} (${r.risk_level})`);
+            if (r.indicator === "CROSS_SERVICE_CHANGE")
+                console.log(`   Services: ${r.evidence.services.join(", ")}`);
+        });
+        console.log("\n=== BENCHMARK COMPLETE (ALL PASS) ===");
+    }
+    catch (e) {
+        console.error("Benchmark Failed:", e.message);
+        process.exit(1);
+    }
+    finally {
+        fs.rmSync(ecosystemRoot, { recursive: true, force: true });
+    }
+}
+runBenchmark();

package/mcp/dist/benchmark_phase8.js

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { discoverUIPatterns, generateStaticUIReference, getDesignContext } from "./ui_intelligence.js";
+function reset(ecosystemRoot) {
+    if (fs.existsSync(ecosystemRoot)) {
+        fs.rmSync(ecosystemRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(ecosystemRoot, { recursive: true });
+}
+function runBenchmark() {
+    console.log("=== RUNNING PHASE 8 UX & UI DESIGN BENCHMARK ===\n");
+    const ecosystemRoot = path.join(process.cwd(), '.benchmark_tmp_ph8');
+    reset(ecosystemRoot);
+    try {
+        // --- Setup Mock State ---
+        const snapshot = {
+            schema_version: "1.0",
+            nodes: [
+                { id: "FRONTEND_APP:sfn-web-ui", type: "FRONTEND_APP", name: "sfn-web-ui" },
+                { id: "UI_PATTERN:TenantSelector", type: "UI_PATTERN", name: "TenantSelector", repository: "sfn-web-ui", evidence: { filePath: "src/components/TenantSelector.tsx" }, metadata: { type: "React", description: "Standard tenant dropdown" } },
+                { id: "UI_PATTERN:ConfirmationModal", type: "UI_PATTERN", name: "ConfirmationModal", repository: "sfn-web-ui", evidence: { filePath: "src/components/ConfirmationModal.tsx" }, metadata: { type: "React", description: "Destructive confirmation dialog" } },
+                { id: "FRONTEND_COMPONENT:RetentionSettings", type: "FRONTEND_COMPONENT", name: "RetentionSettings", repository: "sfn-web-ui", evidence: { filePath: "src/pages/RetentionSettings.tsx" }, metadata: { type: "React" } },
+                { id: "API:DELETE:/api/users", type: "API", name: "DELETE /api/users", repository: "sfn-iam-api" }
+            ],
+            edges: []
+        };
+        fs.mkdirSync(path.join(ecosystemRoot, ".secufusion", "requirements"), { recursive: true });
+        const retentionReq = { id: "REQ-RETENTION", status: "CONFIRMED" };
+        const deletionReq = { id: "REQ-DELETE-USER", status: "CONFIRMED", apis: ["DELETE:/api/users"] };
+        fs.writeFileSync(path.join(ecosystemRoot, ".secufusion", "requirements", "REQ-RETENTION.json"), JSON.stringify(retentionReq));
+        fs.writeFileSync(path.join(ecosystemRoot, ".secufusion", "requirements", "REQ-DELETE-USER.json"), JSON.stringify(deletionReq));
+        // --- Benchmark 1: Retention Policy (New Feature) ---
+        console.log("--- 1. RETENTION POLICY BENCHMARK ---");
+        const retentionContext = getDesignContext(ecosystemRoot, "REQ-RETENTION", snapshot);
+        console.log(`Context status: ${retentionContext.status}`);
+        const tenantPatterns = discoverUIPatterns(ecosystemRoot, "tenant selector", snapshot);
+        console.log(`Discovered Tenant Patterns: ${tenantPatterns.length}`);
+        tenantPatterns.forEach(p => console.log(` - ${p.name} (Source: ${p.evidence.location.filePath})`));
+        const retentionHtml = `<html><body><h1>Retention Policy</h1><p>Set retention here</p></body></html>`;
+        const retentionPath = generateStaticUIReference(ecosystemRoot, "DESIGN-RETENTION", retentionHtml, { status: "DRAFT" });
+        console.log(`Generated HTML at: ${retentionPath}`);
+        const retentionContent = fs.readFileSync(retentionPath, "utf-8");
+        if (retentionContent.includes("REFERENCE_ONLY"))
+            console.log("SUCCESS: Retention HTML contains REFERENCE_ONLY marker.");
+        // --- Benchmark 2: User Deletion (Destructive Operation) ---
+        console.log("\n--- 2. USER DELETION BENCHMARK ---");
+        const deletionContext = getDesignContext(ecosystemRoot, "REQ-DELETE-USER", snapshot);
+        console.log(`Architecture Context Nodes: ${deletionContext.architecture_context.length}`);
+        deletionContext.architecture_context.forEach((n) => console.log(` - Affected: ${n.id}`));
+        const deletePatterns = discoverUIPatterns(ecosystemRoot, "confirmation destructive", snapshot);
+        console.log(`Discovered Confirmation Patterns: ${deletePatterns.length}`);
+        deletePatterns.forEach(p => console.log(` - ${p.name} (Source: ${p.evidence.location.filePath})`));
+        const deletionHtml = `<html><body><h1>Delete User</h1></body></html>`;
+        const deletionPath = generateStaticUIReference(ecosystemRoot, "DESIGN-DELETE-USER", deletionHtml, { status: "USER_REVIEW_REQUIRED" });
+        console.log(`Generated HTML at: ${deletionPath}`);
+        const deletionContent = fs.readFileSync(deletionPath, "utf-8");
+        if (deletionContent.includes("REFERENCE_ONLY"))
+            console.log("SUCCESS: Deletion HTML contains REFERENCE_ONLY marker.");
+        // --- Benchmark 3: Validate Metadata ---
+        console.log("\n--- 3. DESIGN METADATA VALIDATION ---");
+        const metaPath = path.join(ecosystemRoot, ".secufusion", "designs", "DESIGN-DELETE-USER", "design.json");
+        const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+        console.log(`Design Status: ${meta.status}`);
+        console.log(`Design ID: ${meta.design_id}`);
+        console.log("\n=== BENCHMARK COMPLETE (ALL PASS) ===");
+    }
+    catch (e) {
+        console.error("Benchmark Failed:", e.message);
+        process.exit(1);
+    }
+    finally {
+        fs.rmSync(ecosystemRoot, { recursive: true, force: true });
+    }
+}
+runBenchmark();

package/mcp/dist/benchmark_runner.js

@@ -0,0 +1,130 @@
+import { investigateEntity, investigateRelationship } from "./investigation_engine.js";
+import { saveRequirement, generateConfirmedSpecification } from "./requirement_manager.js";
+import fs from 'fs';
+import path from 'path';
+const ecosystemRoot = "c:\\Users\\Yash\\Desktop\\mcp";
+function getGraph() {
+    const dnaPath = path.join(ecosystemRoot, ".secufusion", "dna.json");
+    return JSON.parse(fs.readFileSync(dnaPath, "utf-8")).graph;
+}
+function runRetentionBenchmark() {
+    console.log("=== RUNNING RETENTION BENCHMARK ===");
+    const reqId = "BM-RET-1";
+    let req = {
+        id: reqId,
+        title: "Retention Policy Setup",
+        status: "RAW",
+        clarification_questions: [],
+        raw_request: "The feature is available only to Master MSSP/MSSP users. Any tenant can configure retention. After span, events are cleaned using dynamic scheduling."
+    };
+    saveRequirement(ecosystemRoot, req);
+    req.status = "UNDERSTOOD";
+    // 1. Investigation Phase
+    req.status = "INVESTIGATING";
+    const graph = getGraph();
+    const retRes = investigateEntity(graph, "Retention");
+    const tenantRes = investigateEntity(graph, "Tenant");
+    const eventRes = investigateEntity(graph, "Event");
+    const relRes = investigateRelationship(graph, "Retention", "Event");
+    req.facts = [
+        retRes.summary,
+        tenantRes.summary,
+        eventRes.summary,
+        relRes.summary
+    ];
+    // 2. Unknown / Conflict Detection
+    req.unknowns = [
+        "Which timestamp governs retention on Event?",
+        "Are all event types covered?",
+        "What happens when retention changes?",
+        "Is deletion hard delete, soft delete?",
+        "What authorization applies to parent/child access?"
+    ];
+    req.blockers = ["Missing explicit deletion semantics", "Missing authorization logic"];
+    saveRequirement(ecosystemRoot, req);
+    // 3. Clarification Required
+    req.status = "CLARIFICATION_REQUIRED";
+    req.clarification_questions.push({
+        id: "CQ-RET-1",
+        topic: "Deletion Semantics",
+        issue: "Deletion is destructive and type is unknown.",
+        state: "OPEN",
+        severity: "CRITICAL",
+        blocking: true,
+        question: "Is the cleanup a hard delete or soft delete? Which timestamp governs it?",
+        evidence: retRes.evidence,
+        created_at: new Date().toISOString()
+    });
+    saveRequirement(ecosystemRoot, req);
+    // 4. Resolve and Confirm
+    req.clarification_questions[0].state = "RESOLVED";
+    req.clarification_questions[0].answer = "Hard delete governed by created_at.";
+    req.clarification_questions[0].decision = "Retention cleanup will hard delete based on created_at.";
+    req.decisions = [req.clarification_questions[0].decision];
+    req.blockers = [];
+    req.status = "CONFIRMED";
+    req.tenancy = "Parent reads/writes child policy";
+    req.authorization = "Master MSSP only";
+    req.data_lifecycle = "Hard delete after N days based on created_at";
+    saveRequirement(ecosystemRoot, req);
+    console.log(generateConfirmedSpecification(req));
+}
+function runUserDeletionBenchmark() {
+    console.log("=== RUNNING USER DELETION BENCHMARK ===");
+    const reqId = "BM-DEL-1";
+    let req = {
+        id: reqId,
+        title: "User Deletion",
+        status: "RAW",
+        clarification_questions: [],
+        raw_request: "End-to-end functionality for deleting a selected user from the UI across all services."
+    };
+    saveRequirement(ecosystemRoot, req);
+    req.status = "UNDERSTOOD";
+    req.status = "INVESTIGATING";
+    const graph = getGraph();
+    const userRes = investigateEntity(graph, "User");
+    const eventRes = investigateEntity(graph, "Event");
+    const userEventRel = investigateRelationship(graph, "User", "Event");
+    req.facts = [
+        userRes.summary,
+        userEventRel.summary
+    ];
+    req.unknowns = [
+        "What happens to events generated by the user?",
+        "Are there audit records that must be retained?"
+    ];
+    req.blockers = ["Unspecified retention of related audit events"];
+    saveRequirement(ecosystemRoot, req);
+    req.status = "CLARIFICATION_REQUIRED";
+    req.clarification_questions.push({
+        id: "CQ-DEL-1",
+        topic: "Orphan Data",
+        issue: "Events associated with the user exist.",
+        state: "OPEN",
+        severity: "CRITICAL",
+        blocking: true,
+        question: "Should events created by the user be deleted, anonymized, or retained?",
+        evidence: userEventRel.evidence,
+        created_at: new Date().toISOString()
+    });
+    saveRequirement(ecosystemRoot, req);
+    req.clarification_questions[0].state = "RESOLVED";
+    req.clarification_questions[0].answer = "Anonymize events, retain audit records.";
+    req.clarification_questions[0].decision = "Events will be anonymized instead of deleted.";
+    req.decisions = [req.clarification_questions[0].decision];
+    req.blockers = [];
+    req.status = "CONFIRMED";
+    req.data_lifecycle = "Hard delete user metadata, anonymize associated events, retain audit records.";
+    saveRequirement(ecosystemRoot, req);
+    console.log(generateConfirmedSpecification(req));
+}
+try {
+    runRetentionBenchmark();
+    console.log("\\n");
+    runUserDeletionBenchmark();
+}
+catch (e) {
+    console.error("Benchmark failed:", e);
+    process.exit(1);
+}