secufusion-mcp 1.2.7 → 2.0.0

package/mcp/dist/parsers/database.js

@@ -0,0 +1,40 @@
+export function parseDatabase(filePath, fileContent, repository) {
+    const entities = [];
+    if (filePath.endsWith('.sql')) {
+        const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s\(]+)/gi;
+        let match;
+        while ((match = tableRegex.exec(fileContent)) !== null) {
+            entities.push({
+                tableName: match[1],
+                filePath,
+                repository,
+                schemaType: 'SQL'
+            });
+        }
+    }
+    else if (filePath.endsWith('.prisma')) {
+        const modelRegex = /model\s+(\w+)\s+\{/g;
+        let match;
+        while ((match = modelRegex.exec(fileContent)) !== null) {
+            entities.push({
+                tableName: match[1],
+                filePath,
+                repository,
+                schemaType: 'Prisma'
+            });
+        }
+    }
+    else if (fileContent.includes('new mongoose.Schema')) {
+        const modelRegex = /mongoose\.model\s*\(\s*['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = modelRegex.exec(fileContent)) !== null) {
+            entities.push({
+                tableName: match[1],
+                filePath,
+                repository,
+                schemaType: 'Mongoose'
+            });
+        }
+    }
+    return entities;
+}

package/mcp/dist/parsers/domain.js

@@ -0,0 +1,21 @@
+export function parseDomainModels(filePath, fileContent, repository) {
+    const models = [];
+    const classMatch = fileContent.match(/public\s+class\s+(\w+)/);
+    if (!classMatch)
+        return models;
+    const className = classMatch[1];
+    const violations = [];
+    if (fileContent.includes("@Entity")) {
+        if (!fileContent.includes("tenantId") && !fileContent.includes("TenantId")) {
+            violations.push("P1 Violation: Entity is missing 'tenantId' field for tenant isolation.");
+        }
+        models.push({ name: className, type: "Entity", filePath, repository, violations });
+    }
+    if (className.endsWith("DTO") || className.endsWith("Dto") || className.endsWith("Request") || className.endsWith("Response")) {
+        if (!fileContent.includes("@Data") || !fileContent.includes("@Builder")) {
+            violations.push("Warning: DTO is missing @Data or @Builder Lombok annotations.");
+        }
+        models.push({ name: className, type: "DTO", filePath, repository, violations });
+    }
+    return models;
+}

package/mcp/dist/parsers/events.js

@@ -0,0 +1,36 @@
+export function parseEventTopics(filePath, fileContent, repository) {
+    const events = [];
+    const classMatch = fileContent.match(/public\s+class\s+(\w+)/);
+    if (!classMatch)
+        return events;
+    const className = classMatch[1];
+    const topicsConsumed = [];
+    const topicsProduced = [];
+    const violations = [];
+    const listenerRegex = /@KafkaListener\s*\(\s*topics\s*=\s*["']([^"']+)["']/g;
+    let match;
+    while ((match = listenerRegex.exec(fileContent)) !== null) {
+        topicsConsumed.push(match[1]);
+    }
+    const producerRegex = /KafkaTemplate.*\.send\(\s*["']([^"']+)["']/g;
+    while ((match = producerRegex.exec(fileContent)) !== null) {
+        topicsProduced.push(match[1]);
+    }
+    if (topicsConsumed.length === 0 && topicsProduced.length === 0) {
+        return events;
+    }
+    if (topicsConsumed.length > 0) {
+        if (fileContent.includes("RestTemplate") || fileContent.includes("FeignClient") || fileContent.includes("HttpClient")) {
+            violations.push("P4 Violation (KAFKA_SYNC): Potential synchronous blocking call detected inside or near @KafkaListener.");
+        }
+    }
+    events.push({
+        className,
+        topicsConsumed,
+        topicsProduced,
+        filePath,
+        repository,
+        violations
+    });
+    return events;
+}

package/mcp/dist/parsers/frontend.js

@@ -0,0 +1,34 @@
+export function parseFrontend(filePath, fileContent, repository) {
+    const components = [];
+    if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx')) {
+        const match = fileContent.match(/(?:export\s+)?(?:default\s+)?(?:function|const)\s+([A-Z]\w+)/);
+        if (match) {
+            components.push({
+                componentName: match[1],
+                type: 'React',
+                filePath,
+                repository
+            });
+        }
+    }
+    else if (filePath.endsWith('.vue')) {
+        components.push({
+            componentName: filePath.split('/').pop()?.replace('.vue', '') || 'VueComponent',
+            type: 'Vue',
+            filePath,
+            repository
+        });
+    }
+    else if (filePath.endsWith('.ts') && fileContent.includes('@Component')) {
+        const match = fileContent.match(/export\s+class\s+(\w+Component)/);
+        if (match) {
+            components.push({
+                componentName: match[1],
+                type: 'Angular',
+                filePath,
+                repository
+            });
+        }
+    }
+    return components;
+}

package/mcp/dist/parsers/infra.js

@@ -0,0 +1,42 @@
+export function parseInfra(filePath, fileContent, repository) {
+    const resources = [];
+    if (filePath.endsWith('docker-compose.yml') || filePath.endsWith('docker-compose.yaml')) {
+        const servicesRegex = /services:\s*\n((\s+[\w-]+:\s*\n)+)/;
+        const match = fileContent.match(servicesRegex);
+        if (match) {
+            resources.push({
+                type: 'DockerCompose',
+                name: 'Compose-Services',
+                filePath,
+                repository
+            });
+        }
+    }
+    else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+        if (fileContent.includes('apiVersion:') && fileContent.includes('kind:')) {
+            const kindMatch = fileContent.match(/kind:\s*(\w+)/);
+            const nameMatch = fileContent.match(/name:\s*([^\n]+)/);
+            if (kindMatch && nameMatch) {
+                resources.push({
+                    type: `Kubernetes-${kindMatch[1]}`,
+                    name: nameMatch[1],
+                    filePath,
+                    repository
+                });
+            }
+        }
+    }
+    else if (filePath.endsWith('.tf')) {
+        const resourceRegex = /resource\s+"([^"]+)"\s+"([^"]+)"/g;
+        let match;
+        while ((match = resourceRegex.exec(fileContent)) !== null) {
+            resources.push({
+                type: `Terraform-${match[1]}`,
+                name: match[2],
+                filePath,
+                repository
+            });
+        }
+    }
+    return resources;
+}

package/mcp/dist/parsers/patterns.js

@@ -0,0 +1,49 @@
+export function inferPatterns(dna) {
+    const inferredPatterns = [];
+    // Infer DTO naming patterns
+    const domains = dna.domains || [];
+    if (domains.length > 0) {
+        const dtos = domains.filter((d) => d.type === "DTO");
+        if (dtos.length > 0) {
+            let suffixDTO = 0;
+            let suffixRequest = 0;
+            let suffixResponse = 0;
+            dtos.forEach((d) => {
+                if (d.name.endsWith("DTO"))
+                    suffixDTO++;
+                else if (d.name.endsWith("Request"))
+                    suffixRequest++;
+                else if (d.name.endsWith("Response"))
+                    suffixResponse++;
+            });
+            const max = Math.max(suffixDTO, suffixRequest, suffixResponse);
+            const total = dtos.length;
+            if (max / total > 0.7) {
+                if (max === suffixDTO)
+                    inferredPatterns.push("Inferred Pattern: 70%+ of data models use 'DTO' suffix.");
+                if (max === suffixRequest)
+                    inferredPatterns.push("Inferred Pattern: 70%+ of data models use 'Request' suffix.");
+                if (max === suffixResponse)
+                    inferredPatterns.push("Inferred Pattern: 70%+ of data models use 'Response' suffix.");
+            }
+        }
+    }
+    // Infer API Path Versioning
+    const apis = dna.apis || [];
+    if (apis.length > 0) {
+        let versioned = 0;
+        apis.forEach((a) => {
+            const paths = a.endpoints.join(" ");
+            if (paths.includes("/v1/") || paths.includes("/v2/")) {
+                versioned++;
+            }
+        });
+        if (versioned / apis.length < 0.1) {
+            inferredPatterns.push("Inferred Pattern: Codebase does not heavily use URL path versioning (e.g., /v1/).");
+        }
+        else if (versioned / apis.length > 0.8) {
+            inferredPatterns.push("Inferred Pattern: Codebase strictly enforces URL path versioning (e.g., /v1/).");
+        }
+    }
+    return inferredPatterns;
+}

package/mcp/dist/parsers/security.js

@@ -0,0 +1,16 @@
+export function parseSecurity(filePath, fileContent, repository) {
+    const contexts = [];
+    if (fileContent.includes('KeycloakWebSecurityConfigurerAdapter') || fileContent.includes('keycloak.json')) {
+        contexts.push({ authType: 'Keycloak', filePath, repository });
+    }
+    if (fileContent.includes('@PreAuthorize') || fileContent.includes('@RolesAllowed')) {
+        contexts.push({ authType: 'SpringSecurity-RBAC', filePath, repository });
+    }
+    if (fileContent.includes('jwt') || fileContent.includes('jsonwebtoken') || fileContent.includes('JwtDecoder')) {
+        contexts.push({ authType: 'JWT', filePath, repository });
+    }
+    if (fileContent.includes('passport.use')) {
+        contexts.push({ authType: 'PassportJS', filePath, repository });
+    }
+    return contexts;
+}