secufusion-mcp 3.0.0 → 3.1.0

package/README.md

@@ -1016,3 +1016,9 @@ PR Ready to Merge 🚀
 ## License
 
 ISC © SecuFusion
+
+## Phase 9 Features Added
+- Config-driven deterministic Workspace Discovery (`.secufusion/workspace.json`)
+- Dynamic Core vs Optional Repository Classification
+- Evidence Completeness Engine (`get_evidence_completeness`)
+- Portable Workspace Paths (No hardcoded paths)

package/agents/planner.md

@@ -390,3 +390,11 @@ STEP 5: call manage_task(action: "log_decision",
 
 6. **Learning Loop (Phase 6)**: Assess if a new lesson was learned. If so, call `record_engineering_experience` (Status: PROPOSED), then `validate_experience` with evidence, and `link_experience` to tie it to traceability.
 
+
+
+## Phase 9 — Workspace & Evidence Completeness
+(TRIGGER: During repository investigation or implementation planning)
+
+1. **Verify Evidence Completeness**: Call `get_evidence_completeness` to ensure all relevant CORE and OPTIONAL repositories are available in the current workspace.
+2. **Missing Evidence Rule**: If a relevant repository is missing (e.g. `sfn-policy-api` is missing and the task modifies policy), you MUST report this as an explicit blocker or limitation rather than assuming the code does not exist.
+3. **Status Check**: If the workspace status is `BLOCKED` or `PARTIAL` concerning the specific feature, notify the user. Never claim unsupported evidence as a negative fact.

package/agents/reviewer.md

@@ -432,3 +432,13 @@ Flag the following if found:
 - `PRODUCTION_UI_CHANGED_WITHOUT_PLAN`
 - `CONFIRMED_DESIGN_WITHOUT_TRACEABILITY`
 - `IMPLEMENTATION_DEVIATES_FROM_CONFIRMED_DESIGN`
+
+
+### Phase 9 Workspace & Evidence Verification
+When reviewing an implementation plan or code changes, verify:
+- The implementation does not assume facts based on missing repositories.
+- `get_evidence_completeness` was considered if cross-service impacts are suspected.
+
+Flag the following if found:
+- `EVIDENCE_TREATED_AS_FACT_WHEN_MISSING`
+- `WORKSPACE_PARTIAL_RESTRICTION_IGNORED`

package/mcp/dist/benchmark_phase9.js

@@ -0,0 +1,69 @@
+import fs from "fs";
+import path from "path";
+import { inspectWorkspaceRepositories, getEvidenceCompleteness } from "./workspace_intelligence.js";
+import { performFullExtraction } from "./server.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 9 WORKSPACE INTELLIGENCE BENCHMARK ===\n");
+    const ecosystemRoot = path.join(process.cwd(), '.benchmark_tmp_ph9');
+    reset(ecosystemRoot);
+    try {
+        // --- Setup Mock Workspace ---
+        const coreRepos = ["sfn-iam-api", "sfn-events-api", "sfn-tenants-api", "sfn-web-ui"];
+        const optionalRepos = ["sfn-auth-api", "sfn-browser-ext"];
+        [...coreRepos, ...optionalRepos].forEach(repo => {
+            fs.mkdirSync(path.join(ecosystemRoot, repo), { recursive: true });
+            fs.writeFileSync(path.join(ecosystemRoot, repo, "index.ts"), "console.log('test');");
+        });
+        // --- Benchmark 1: All Available ---
+        console.log("--- 1. FULL WORKSPACE BENCHMARK ---");
+        let inspection = inspectWorkspaceRepositories(ecosystemRoot);
+        console.log(`Status: ${inspection.status}`);
+        if (inspection.status !== "READY")
+            throw new Error("Status should be READY");
+        if (inspection.core_found.length !== 4)
+            throw new Error("Should find 4 core repos");
+        let completeness = getEvidenceCompleteness(ecosystemRoot);
+        console.log(`Completeness Status: ${completeness.completeness_status}`);
+        // --- Benchmark 2: Missing Optional Repository ---
+        console.log("\n--- 2. MISSING OPTIONAL BENCHMARK ---");
+        fs.rmSync(path.join(ecosystemRoot, "sfn-browser-ext"), { recursive: true, force: true });
+        inspection = inspectWorkspaceRepositories(ecosystemRoot);
+        console.log(`Status after missing optional: ${inspection.status}`);
+        if (inspection.status !== "READY")
+            throw new Error("Status should still be READY");
+        if (inspection.optional_missing.includes("sfn-browser-ext") === false)
+            throw new Error("Missing optional should be tracked");
+        // --- Benchmark 3: Missing Core Repository ---
+        console.log("\n--- 3. MISSING CORE BENCHMARK ---");
+        fs.rmSync(path.join(ecosystemRoot, "sfn-iam-api"), { recursive: true, force: true });
+        inspection = inspectWorkspaceRepositories(ecosystemRoot);
+        console.log(`Status after missing core: ${inspection.status}`);
+        if (inspection.status !== "PARTIAL")
+            throw new Error("Status should be PARTIAL (some core found, some missing)");
+        if (inspection.core_missing.includes("sfn-iam-api") === false)
+            throw new Error("Missing core should be tracked");
+        completeness = getEvidenceCompleteness(ecosystemRoot);
+        console.log(`Completeness Message: ${completeness.message}`);
+        // --- Benchmark 4: Extraction Respects Boundaries ---
+        console.log("\n--- 4. EXTRACTION BOUNDARY BENCHMARK ---");
+        const stats = performFullExtraction(ecosystemRoot);
+        console.log(`Extraction Status: ${stats.inspectionStatus}`);
+        if (stats.inspectionStatus !== "PARTIAL")
+            throw new Error("Extraction should bubble up PARTIAL 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/server.js

@@ -24,7 +24,7 @@ import { loadRequirement, saveRequirement, validateStateTransition, generateConf
 import { discoverTests, executeTests, ingestTestResults, loadTestResults, correlateTestFailure } from "./test_engine.js";
 import { loadPlan, savePlan, validatePlan } from "./implementation_plan.js";
 import { generateTestObligations, aggregateValidation } from "./validation_engine.js";
-import { recordExperience, loadExperience, getEngineeringExperience, validateExperience, getExperienceContext, findExperienceConflicts, findRepeatedOutcomes, markExperienceStale, retireExperience, linkExperience, getLearningFeedback } from "./experience_manager.js";
+import { recordExperience, getEngineeringExperience, validateExperience, getExperienceContext, findExperienceConflicts, findRepeatedOutcomes, markExperienceStale, retireExperience, linkExperience, getLearningFeedback } from "./experience_manager.js";
 import { loadTraceability, addTraceabilityLink, traceForward, traceReverse, findTraceabilityGaps } from "./traceability_engine.js";
 import { investigateEntity, investigateRelationship } from "./investigation_engine.js";
 import { buildGraph } from "./graph_builder.js";
@@ -33,6 +33,7 @@ import { parseApiEndpoints } from "./parsers/api.js";
 import { parseEventTopics } from "./parsers/events.js";
 import { inferPatterns } from "./parsers/patterns.js";
 import { parseFrontend } from "./parsers/frontend.js";
+import { inspectWorkspaceRepositories, getWorkspaceConfig, getEvidenceCompleteness } from "./workspace_intelligence.js";
 import { parseExtension } from "./parsers/extension.js";
 import { parseNodeApis } from "./parsers/backend-node.js";
 import { parseInfra } from "./parsers/infra.js";
@@ -3185,19 +3186,14 @@ export function performFullExtraction(ecosystemRoot) {
     catch (e) { }
     dna.graph = buildGraph(dna, spec);
     writeDna(ecosystemRoot, dna);
-    const hasBackend = (models.length > 0 || apis.length > 0 || nodeApis.length > 0);
     const hasFrontend = frontend.length > 0;
     const hasExtension = extension.length > 0;
-    const missing = [];
-    if (!hasBackend)
-        missing.push("backend");
-    if (!hasFrontend)
-        missing.push("frontend");
-    if (!hasExtension)
-        missing.push("snf-browser-extn");
-    const missingWarning = missing.length > 0 ? `\n\n[CRITICAL CORE CHECK] The following core components are missing from the DNA map: ${missing.join(', ')}. Please verify if this is expected.` : "";
+    const inspection = inspectWorkspaceRepositories(ecosystemRoot);
+    const missing = inspection.core_missing;
+    const missingWarning = missing.length > 0 ? `\n\n[CRITICAL CORE CHECK] The following core repositories are missing from the workspace: ${missing.join(', ')}. Evidence logic and planning will be blocked or degraded.` : "";
     return {
         missingWarning,
+        inspectionStatus: inspection.status,
         extensionCount: extension.length,
         modelsCount: models.length,
         apisCount: apis.length + nodeApis.length,
@@ -3862,18 +3858,6 @@ server.tool("get_learning_feedback", "Return bounded historical feedback relevan
         return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
     }
 });
-server.tool("get_engineering_experience", "Retrieves past engineering experiences and decisions.", {
-    workspace_root: z.string().describe("Root directory of the workspace")
-}, async ({ workspace_root }) => {
-    try {
-        const ecosystemRoot = getEcosystemRoot(workspace_root);
-        const exp = loadExperience(ecosystemRoot);
-        return { content: [{ type: "text", text: JSON.stringify(exp, null, 2) }] };
-    }
-    catch (e) {
-        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
-    }
-});
 server.tool("discover_tests", "Discover relevant tests for a given set of artifact IDs.", {
     workspace_root: z.string().describe("Root directory of the workspace"),
     artifacts: z.array(z.string()).describe("List of artifact IDs (e.g. CLASS:UserService)")
@@ -4158,5 +4142,30 @@ Confirm to the user when the watcher is active and which directory is being watc
         }]
 }));
 // ─────────────────────────────────────────────────────────────────────────────
+server.tool("discover_secufusion_workspace", "Determine the current SecuFusion workspace and return its configuration (core vs optional repositories).", { workspace_root: z.string().optional() }, async ({ workspace_root }) => {
+    const root = workspace_root || getWorkspaceRoot();
+    const config = getWorkspaceConfig(root);
+    return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
+});
+server.tool("inspect_workspace_repositories", "Inspect which repositories are actually present in the workspace, classifying them as core/optional.", { workspace_root: z.string().optional() }, async ({ workspace_root }) => {
+    const root = workspace_root || getWorkspaceRoot();
+    const result = inspectWorkspaceRepositories(root);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("refresh_repository_knowledge", "Refresh the deterministic knowledge graph from the current repository state.", { workspace_root: z.string().optional() }, async ({ workspace_root }) => {
+    const root = workspace_root || getWorkspaceRoot();
+    const stats = performFullExtraction(root);
+    return { content: [{ type: "text", text: JSON.stringify({ status: "REFRESHED", stats }, null, 2) }] };
+});
+server.tool("get_workspace_status", "Get the overall status of the workspace (READY, PARTIAL, BLOCKED, FAILED).", { workspace_root: z.string().optional() }, async ({ workspace_root }) => {
+    const root = workspace_root || getWorkspaceRoot();
+    const result = inspectWorkspaceRepositories(root);
+    return { content: [{ type: "text", text: result.status }] };
+});
+server.tool("get_evidence_completeness", "Retrieve evidence completeness context, exposing which core/optional repositories are missing.", { workspace_root: z.string().optional() }, async ({ workspace_root }) => {
+    const root = workspace_root || getWorkspaceRoot();
+    const completeness = getEvidenceCompleteness(root);
+    return { content: [{ type: "text", text: JSON.stringify(completeness, null, 2) }] };
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/mcp/dist/workspace_intelligence.js

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+export const DEFAULT_WORKSPACE_CONFIG = {
+    workspace: "SecuFusion",
+    coreRepositories: ["sfn-iam-api", "sfn-events-api", "sfn-tenants-api", "sfn-web-ui"],
+    optionalRepositories: [
+        "sfn-auth-api", "sfn-policy-api", "sfn-notification-api",
+        "sfn-packages-api", "sfn-rules", "sfn-browser-ext",
+        "sfn-edge-ai", "sfn-gateway-api", "sfn-eureka-api",
+        "sfn-devops-terraform", "sfn-k8s-apps-config", "sfn-seed-sql"
+    ]
+};
+export function getWorkspaceConfig(ecosystemRoot) {
+    const configPath = path.join(ecosystemRoot, ".secufusion", "workspace.json");
+    if (fs.existsSync(configPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch (e) {
+            console.error("Failed to parse workspace.json", e);
+        }
+    }
+    // Auto-generate if missing
+    fs.mkdirSync(path.join(ecosystemRoot, ".secufusion"), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(DEFAULT_WORKSPACE_CONFIG, null, 2), "utf-8");
+    return DEFAULT_WORKSPACE_CONFIG;
+}
+export function inspectWorkspaceRepositories(ecosystemRoot) {
+    const config = getWorkspaceConfig(ecosystemRoot);
+    const result = {
+        workspace_root: ecosystemRoot,
+        workspace_name: config.workspace,
+        core_found: [],
+        core_missing: [],
+        optional_found: [],
+        optional_missing: [],
+        unreadable: [],
+        status: "UNKNOWN",
+        snapshot_identity: new Date().toISOString()
+    };
+    const checkRepo = (repo, isCore) => {
+        const repoPath = path.join(ecosystemRoot, repo);
+        if (fs.existsSync(repoPath)) {
+            try {
+                fs.accessSync(repoPath, fs.constants.R_OK);
+                if (fs.statSync(repoPath).isDirectory()) {
+                    if (isCore)
+                        result.core_found.push(repo);
+                    else
+                        result.optional_found.push(repo);
+                }
+                else {
+                    result.unreadable.push(repo);
+                    if (isCore)
+                        result.core_missing.push(repo);
+                    else
+                        result.optional_missing.push(repo);
+                }
+            }
+            catch (e) {
+                result.unreadable.push(repo);
+                if (isCore)
+                    result.core_missing.push(repo);
+                else
+                    result.optional_missing.push(repo);
+            }
+        }
+        else {
+            if (isCore)
+                result.core_missing.push(repo);
+            else
+                result.optional_missing.push(repo);
+        }
+    };
+    config.coreRepositories.forEach(r => checkRepo(r, true));
+    config.optionalRepositories.forEach(r => checkRepo(r, false));
+    if (result.core_missing.length === 0) {
+        result.status = "READY";
+    }
+    else if (result.core_found.length > 0) {
+        result.status = "PARTIAL";
+    }
+    else {
+        result.status = "BLOCKED";
+    }
+    return result;
+}
+export function getEvidenceCompleteness(ecosystemRoot) {
+    const inspection = inspectWorkspaceRepositories(ecosystemRoot);
+    return {
+        completeness_status: inspection.status,
+        missing_core: inspection.core_missing,
+        missing_optional: inspection.optional_missing,
+        unreadable: inspection.unreadable,
+        message: inspection.status === "READY"
+            ? "Core repository evidence is complete."
+            : `Missing core evidence for: ${inspection.core_missing.join(', ')}. Reasoning may be blocked.`
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secufusion-mcp",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "description": "Project-level spec driven AI workflow tooling for SecuFusion, MCP server - developer workflow tooling with guardrails",
   "main": "mcp/dist/server.js",