vibe-coder-mcp/build/tools/code-map-generator/diagramGenerator.js

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import { extractMethodCallSequences, extractParticipants, generateSequenceDiagram, optimizeSequenceDiagram } from './sequenceDiagramGenerator.js';
function sanitizeMermaidLabel(label) {
    return label.replace(/["`]/g, "'").replace(/\n/g, ' ').substring(0, 80);
}
export function generateMermaidFileDependencyDiagram(nodes, edges) {
    if (edges.length === 0 && nodes.length === 0)
        return 'graph LR\n  subgraph "File Dependencies"\n    Empty["No dependencies found"]\n  end';
    let mermaidString = 'graph LR\n  subgraph "File Dependencies"\n';
    nodes.forEach(node => {
        const label = sanitizeMermaidLabel(node.label || node.id);
        mermaidString += `    ${node.id}["${label}"]\n`;
    });
    edges.forEach(edge => {
        mermaidString += `    ${edge.from} -->|${edge.label || 'depends'}| ${edge.to}\n`;
    });
    mermaidString += '  end';
    return mermaidString;
}
export function generateMermaidClassDiagram(nodes, edges, allClassInfos) {
    if (edges.length === 0 && nodes.length === 0)
        return 'classDiagram\n  class Empty~"No classes or inheritance found"~';
    let mermaidString = 'classDiagram\n';
    const classInfoMap = new Map();
    allClassInfos.forEach(ci => classInfoMap.set(ci.name, ci));
    nodes.filter(n => n.type === 'class').forEach(node => {
        const className = node.id.includes('::') ? node.id.split('::')[1] : node.id;
        const classInfo = classInfoMap.get(className);
        const label = sanitizeMermaidLabel(node.label || node.id);
        mermaidString += `  class ${node.id}["${label}"] {\n`;
        if (classInfo) {
            (classInfo.properties || []).forEach(prop => {
                const propComment = sanitizeMermaidLabel(prop.comment || prop.name);
                let accessModifier = '+';
                if (prop.accessModifier === 'private') {
                    accessModifier = '-';
                }
                else if (prop.accessModifier === 'protected') {
                    accessModifier = '#';
                }
                else if (prop.accessModifier === 'package-private') {
                    accessModifier = '~';
                }
                let propertyStr = `${accessModifier}${prop.name}`;
                if (prop.type) {
                    propertyStr += ` : ${prop.type}`;
                }
                if (prop.isStatic) {
                    propertyStr += '$';
                }
                mermaidString += `    ${propertyStr} : ${propComment}\n`;
            });
            classInfo.methods.forEach(method => {
                const methodComment = sanitizeMermaidLabel(method.comment || method.name);
                let accessModifier = '+';
                if (method.accessModifier === 'private') {
                    accessModifier = '-';
                }
                else if (method.accessModifier === 'protected') {
                    accessModifier = '#';
                }
                else if (method.accessModifier === 'package-private') {
                    accessModifier = '~';
                }
                const signature = method.signature ? method.signature.substring(method.name.length) : '()';
                let methodStr = `${accessModifier}${method.name}${signature}`;
                if (method.returnType) {
                    methodStr += ` : ${method.returnType}`;
                }
                if (method.isStatic) {
                    methodStr += '$';
                }
                mermaidString += `    ${methodStr} : ${methodComment}\n`;
            });
        }
        mermaidString += `  }\n`;
    });
    edges.forEach(edge => {
        mermaidString += `  ${edge.from} <|-- ${edge.to} : ${sanitizeMermaidLabel(edge.label || 'inherits')}\n`;
    });
    return mermaidString;
}
export function generateMermaidFunctionCallDiagram(nodes, edges) {
    if (edges.length === 0 && nodes.length === 0)
        return 'graph LR\n  subgraph "Function Calls (Heuristic)"\n    Empty["No calls detected or mapped"]\n  end';
    let mermaidString = 'graph LR\n  subgraph "Function Calls (Heuristic)"\n';
    nodes.filter(n => n.type === 'function' || n.type === 'method').forEach(node => {
        const label = sanitizeMermaidLabel(node.label || node.id);
        mermaidString += `    ${node.id}["${label}"]\n`;
    });
    edges.forEach(edge => {
        mermaidString += `    ${edge.from} -->|${edge.label || 'calls?'}| ${edge.to}\n`;
    });
    mermaidString += '  end';
    return mermaidString;
}
export function generateMermaidSequenceDiagram(nodes, edges, maxCalls = 20, maxParticipants = 10) {
    if (edges.length === 0 && nodes.length === 0) {
        return 'sequenceDiagram\n  Note over System: No method calls detected';
    }
    const methodCalls = extractMethodCallSequences(nodes, edges, maxCalls);
    if (methodCalls.length === 0) {
        return 'sequenceDiagram\n  Note over System: No method calls detected';
    }
    const participants = extractParticipants(methodCalls, nodes);
    const diagram = generateSequenceDiagram(methodCalls, participants);
    const optimizedDiagram = optimizeSequenceDiagram(diagram, maxParticipants);
    return optimizedDiagram;
}