@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/diagrams/generator.d.ts

@@ -0,0 +1,8 @@
+import type { ChangeMap } from "../mapping/types.js";
+import type { DiagramModel } from "./types.js";
+export declare function changeMapToDiagramModel(changeMap: ChangeMap): DiagramModel;
+export declare function diagramModelToPlantUML(model: DiagramModel): string;
+export declare function generateChangeImpactPuml(changeMap: ChangeMap): {
+    puml: string;
+    model: DiagramModel;
+};

package/build/mcp/tools/vibe_pm/diagrams/generator.js

@@ -0,0 +1,214 @@
+// PlantUML diagram generator
+// Converts ChangeMap → DiagramModel → PlantUML string
+import { LAYER_ORDER } from "./types.js";
+// ============================================================================
+// ChangeMap → DiagramModel conversion
+// ============================================================================
+export function changeMapToDiagramModel(changeMap) {
+    const nodesMap = new Map();
+    const unmappedFiles = [];
+    // Process mapped files → nodes
+    for (const m of changeMap.mapped) {
+        const nodeId = makeNodeId(m.domain_id, m.layer, m.owner_id);
+        if (nodesMap.has(nodeId)) {
+            const existing = nodesMap.get(nodeId);
+            existing.file_count += 1;
+            existing.confidence = (existing.confidence + m.confidence) / 2;
+        }
+        else {
+            nodesMap.set(nodeId, {
+                node_id: nodeId,
+                label: m.owner_id,
+                domain: m.domain_id,
+                layer: m.layer,
+                stereotype: ["CHANGED"],
+                file_count: 1,
+                confidence: m.confidence,
+            });
+        }
+    }
+    // Process unmapped files
+    for (const u of changeMap.unmapped) {
+        unmappedFiles.push(u.file);
+        // Create UNKNOWN node if there are unmapped files
+        const unknownNodeId = "Unknown.Unknown.unmapped";
+        if (!nodesMap.has(unknownNodeId)) {
+            nodesMap.set(unknownNodeId, {
+                node_id: unknownNodeId,
+                label: "unmapped",
+                domain: "Unknown",
+                layer: "UNKNOWN",
+                stereotype: ["UNKNOWN"],
+                file_count: 0,
+                confidence: 0,
+            });
+        }
+        nodesMap.get(unknownNodeId).file_count += 1;
+    }
+    // Mark nodes with violations as RISK
+    for (const v of changeMap.violations) {
+        for (const node of nodesMap.values()) {
+            // If violation file matches any file in this node's domain
+            if (v.severity === "BLOCK" && !node.stereotype.includes("RISK")) {
+                node.stereotype.push("RISK");
+            }
+        }
+    }
+    const nodes = Array.from(nodesMap.values());
+    const edges = synthesizeEdges(nodes, changeMap.violations);
+    return {
+        run_id: changeMap.run_id,
+        generated_at: new Date().toISOString(),
+        nodes,
+        edges,
+        unmapped_files: unmappedFiles,
+        violations: changeMap.violations,
+        summary: {
+            total_nodes: nodes.length,
+            total_edges: edges.length,
+            domains_touched: changeMap.summary.domains_touched,
+            layers_touched: changeMap.summary.layers_touched,
+            unmapped_count: unmappedFiles.length,
+            violation_count: changeMap.violations.length,
+        },
+    };
+}
+function makeNodeId(domain, layer, label) {
+    const safeDomain = domain.replace(/[^a-zA-Z0-9_]/g, "_");
+    const safeLayer = layer.replace(/[^a-zA-Z0-9_]/g, "_");
+    const safeLabel = label.replace(/[^a-zA-Z0-9_]/g, "_");
+    return `${safeDomain}.${safeLayer}.${safeLabel}`;
+}
+// ============================================================================
+// Edge synthesis (when ChangeMap doesn't include edges)
+// ============================================================================
+function synthesizeEdges(nodes, violations) {
+    const edges = [];
+    const edgeSet = new Set();
+    // Group nodes by domain
+    const domainNodes = new Map();
+    for (const node of nodes) {
+        if (!domainNodes.has(node.domain)) {
+            domainNodes.set(node.domain, []);
+        }
+        domainNodes.get(node.domain).push(node);
+    }
+    // Within each domain, connect adjacent layers
+    for (const [domain, domNodes] of domainNodes) {
+        const sorted = domNodes.sort((a, b) => {
+            const orderA = LAYER_ORDER[a.layer] ?? 99;
+            const orderB = LAYER_ORDER[b.layer] ?? 99;
+            return orderA - orderB;
+        });
+        for (let i = 0; i < sorted.length - 1; i++) {
+            const from = sorted[i];
+            const to = sorted[i + 1];
+            const edgeKey = `${from.node_id}->${to.node_id}`;
+            if (!edgeSet.has(edgeKey)) {
+                edgeSet.add(edgeKey);
+                edges.push({
+                    from_node_id: from.node_id,
+                    to_node_id: to.node_id,
+                    relation: "calls",
+                    stereotype: null,
+                });
+            }
+        }
+    }
+    // Cross-domain edges (if multiple domains touched)
+    const domains = Array.from(domainNodes.keys()).filter(d => d !== "Unknown");
+    if (domains.length > 1) {
+        // Simple heuristic: connect first node of each domain
+        for (let i = 0; i < domains.length - 1; i++) {
+            const fromNodes = domainNodes.get(domains[i]);
+            const toNodes = domainNodes.get(domains[i + 1]);
+            if (fromNodes.length > 0 && toNodes.length > 0) {
+                const from = fromNodes[0];
+                const to = toNodes[0];
+                const edgeKey = `${from.node_id}->${to.node_id}`;
+                if (!edgeSet.has(edgeKey)) {
+                    edgeSet.add(edgeKey);
+                    edges.push({
+                        from_node_id: from.node_id,
+                        to_node_id: to.node_id,
+                        relation: "uses",
+                        stereotype: "CROSS_DOMAIN",
+                    });
+                }
+            }
+        }
+    }
+    return edges;
+}
+// ============================================================================
+// DiagramModel → PlantUML string
+// ============================================================================
+export function diagramModelToPlantUML(model) {
+    const lines = [];
+    lines.push("@startuml change_impact");
+    lines.push("");
+    lines.push("' Generated by Vibe PM Diagram Generator");
+    lines.push(`' Run ID: ${model.run_id}`);
+    lines.push(`' Generated at: ${model.generated_at}`);
+    lines.push("");
+    // Styling
+    lines.push("skinparam backgroundColor #FEFEFE");
+    lines.push("skinparam component {");
+    lines.push("  BackgroundColor<<CHANGED>> #E3F2FD");
+    lines.push("  BorderColor<<CHANGED>> #1976D2");
+    lines.push("  BackgroundColor<<RISK>> #FFEBEE");
+    lines.push("  BorderColor<<RISK>> #D32F2F");
+    lines.push("  BackgroundColor<<UNKNOWN>> #FFF3E0");
+    lines.push("  BorderColor<<UNKNOWN>> #F57C00");
+    lines.push("  BackgroundColor<<FORBIDDEN>> #F3E5F5");
+    lines.push("  BorderColor<<FORBIDDEN>> #7B1FA2");
+    lines.push("}");
+    lines.push("");
+    // Group nodes by domain
+    const domainNodes = new Map();
+    for (const node of model.nodes) {
+        if (!domainNodes.has(node.domain)) {
+            domainNodes.set(node.domain, []);
+        }
+        domainNodes.get(node.domain).push(node);
+    }
+    // Render packages (domains) and components (nodes)
+    for (const [domain, nodes] of domainNodes) {
+        lines.push(`package "${domain}" {`);
+        for (const node of nodes) {
+            const stereotypes = node.stereotype.map(s => `<<${s}>>`).join(" ");
+            const fileNote = node.file_count > 1 ? ` (+${node.file_count} files)` : "";
+            lines.push(`  component "${node.label}${fileNote}" as ${node.node_id} ${stereotypes}`);
+        }
+        lines.push("}");
+        lines.push("");
+    }
+    // Render edges
+    if (model.edges.length > 0) {
+        lines.push("' Relationships");
+        for (const edge of model.edges) {
+            const stereotype = edge.stereotype ? ` <<${edge.stereotype}>>` : "";
+            const arrow = edge.stereotype === "CROSS_DOMAIN" ? "..>" : "-->";
+            lines.push(`${edge.from_node_id} ${arrow} ${edge.to_node_id} : ${edge.relation}${stereotype}`);
+        }
+        lines.push("");
+    }
+    // Summary note
+    lines.push("note bottom");
+    lines.push(`  Domains: ${model.summary.domains_touched.join(", ") || "none"}`);
+    lines.push(`  Layers: ${model.summary.layers_touched.join(", ") || "none"}`);
+    lines.push(`  Unmapped: ${model.summary.unmapped_count} files`);
+    lines.push(`  Violations: ${model.summary.violation_count}`);
+    lines.push("end note");
+    lines.push("");
+    lines.push("@enduml");
+    return lines.join("\n");
+}
+// ============================================================================
+// High-level API
+// ============================================================================
+export function generateChangeImpactPuml(changeMap) {
+    const model = changeMapToDiagramModel(changeMap);
+    const puml = diagramModelToPlantUML(model);
+    return { puml, model };
+}

package/build/mcp/tools/vibe_pm/diagrams/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./generator.js";
+export * from "./manifest.js";
+export * from "./renderer.js";
+export * from "./animator.js";
+export * from "./gate_engine.js";
+export * from "./mermaid_generator.js";

package/build/mcp/tools/vibe_pm/diagrams/index.js

@@ -0,0 +1,9 @@
+// Diagram module exports
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./generator.js";
+export * from "./manifest.js";
+export * from "./renderer.js";
+export * from "./animator.js";
+export * from "./gate_engine.js";
+export * from "./mermaid_generator.js";

package/build/mcp/tools/vibe_pm/diagrams/manifest.d.ts

@@ -0,0 +1,37 @@
+import type { DiagramManifest, DiagramModel, DiagramGateVerdict } from "./types.js";
+import { type RenderResult } from "./renderer.js";
+export declare function getDiagramsDir(runDir: string): string;
+export declare function getChangeImpactPumlPath(runDir: string): string;
+export declare function getChangeImpactSvgPath(runDir: string): string;
+export declare function getDiagramManifestPath(runDir: string): string;
+export declare function getDiagramGateVerdictPath(runDir: string): string;
+export declare function createManifest(args: {
+    runId: string;
+    changeMapPath: string;
+    changeMapContent: string;
+    model: DiagramModel;
+    pumlPath: string;
+    svgPath: string | null;
+    annotationsPath: string | null;
+}): DiagramManifest;
+export declare function computeGateVerdict(model: DiagramModel, totalFiles: number): DiagramGateVerdict;
+export declare function writeDiagramArtifacts(args: {
+    runDir: string;
+    runId: string;
+    changeMapPath: string;
+    changeMapContent: string;
+    puml: string;
+    model: DiagramModel;
+    totalFiles: number;
+    renderSvg?: boolean;
+}): Promise<{
+    manifest: DiagramManifest;
+    gateVerdict: DiagramGateVerdict;
+    renderResult: RenderResult | null;
+    paths: {
+        puml: string;
+        manifest: string;
+        gateVerdict: string;
+        svg: string | null;
+    };
+}>;

package/build/mcp/tools/vibe_pm/diagrams/manifest.js

@@ -0,0 +1,151 @@
+// Diagram manifest and file operations
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { renderDiagramToSvg } from "./renderer.js";
+const GENERATOR_VERSION = "1.0.0";
+// ============================================================================
+// Path helpers
+// ============================================================================
+export function getDiagramsDir(runDir) {
+    return path.join(runDir, "diagrams");
+}
+export function getChangeImpactPumlPath(runDir) {
+    return path.join(getDiagramsDir(runDir), "change_impact.puml");
+}
+export function getChangeImpactSvgPath(runDir) {
+    return path.join(getDiagramsDir(runDir), "change_impact.svg");
+}
+export function getDiagramManifestPath(runDir) {
+    return path.join(getDiagramsDir(runDir), "diagram_manifest.json");
+}
+export function getDiagramGateVerdictPath(runDir) {
+    return path.join(getDiagramsDir(runDir), "diagram_gate_verdict.json");
+}
+// ============================================================================
+// Manifest creation
+// ============================================================================
+export function createManifest(args) {
+    const hash = crypto.createHash("sha256").update(args.changeMapContent).digest("hex");
+    return {
+        schema_version: "diagram.manifest.v1",
+        run_id: args.runId,
+        generated_at: new Date().toISOString(),
+        generator_version: GENERATOR_VERSION,
+        input: {
+            change_map_path: args.changeMapPath,
+            change_map_hash: hash,
+        },
+        outputs: {
+            puml_path: args.pumlPath,
+            svg_path: args.svgPath,
+            annotations_path: args.annotationsPath,
+        },
+        stats: {
+            nodes: args.model.summary.total_nodes,
+            edges: args.model.summary.total_edges,
+            unmapped_files: args.model.summary.unmapped_count,
+        },
+    };
+}
+// ============================================================================
+// Gate verdict computation
+// ============================================================================
+export function computeGateVerdict(model, totalFiles) {
+    const unknownRate = totalFiles > 0 ? model.summary.unmapped_count / totalFiles : 0;
+    const crossDomainEdges = model.edges.filter(e => e.stereotype === "CROSS_DOMAIN").length;
+    const violationCount = model.summary.violation_count;
+    // Collect issues then determine verdict
+    const reasons = [];
+    let hasBlock = false;
+    let hasWarn = false;
+    if (unknownRate > 0.5) {
+        hasBlock = true;
+        reasons.push(`High unknown rate: ${(unknownRate * 100).toFixed(1)}% of files unmapped`);
+    }
+    else if (unknownRate > 0.2) {
+        hasWarn = true;
+        reasons.push(`Elevated unknown rate: ${(unknownRate * 100).toFixed(1)}% of files unmapped`);
+    }
+    if (crossDomainEdges > 3) {
+        hasWarn = true;
+        reasons.push(`Multiple cross-domain edges: ${crossDomainEdges} boundaries crossed`);
+    }
+    if (violationCount > 0) {
+        const blockingViolation = model.violations.some(v => v.severity === "BLOCK");
+        if (blockingViolation) {
+            hasBlock = true;
+            reasons.push(`Blocking violations: ${violationCount} total`);
+        }
+        else {
+            hasWarn = true;
+            reasons.push(`Violations found: ${violationCount} total`);
+        }
+    }
+    if (reasons.length === 0) {
+        reasons.push("All checks passed");
+    }
+    const verdict = hasBlock ? "BLOCK" : hasWarn ? "WARN" : "GO";
+    return {
+        schema_version: "diagram.gate.v1",
+        run_id: model.run_id,
+        generated_at: new Date().toISOString(),
+        metrics: {
+            unknown_rate: unknownRate,
+            cross_domain_edges: crossDomainEdges,
+            violation_count: violationCount,
+        },
+        verdict,
+        reasons,
+    };
+}
+// ============================================================================
+// File operations
+// ============================================================================
+export async function writeDiagramArtifacts(args) {
+    const diagramsDir = getDiagramsDir(args.runDir);
+    await fs.mkdir(diagramsDir, { recursive: true });
+    const pumlPath = getChangeImpactPumlPath(args.runDir);
+    const manifestPath = getDiagramManifestPath(args.runDir);
+    const gateVerdictPath = getDiagramGateVerdictPath(args.runDir);
+    // Write PUML
+    await fs.writeFile(pumlPath, args.puml, "utf-8");
+    // Optional: Render SVG (fail-open)
+    let renderResult = null;
+    let svgPath = null;
+    if (args.renderSvg) {
+        renderResult = await renderDiagramToSvg(pumlPath);
+        if (renderResult.success) {
+            svgPath = renderResult.svgPath;
+        }
+        else {
+            // Fail-open: log warning but continue
+            console.warn(`[diagram] SVG render failed (continuing): ${renderResult.error}`);
+        }
+    }
+    // Create and write manifest
+    const manifest = createManifest({
+        runId: args.runId,
+        changeMapPath: args.changeMapPath,
+        changeMapContent: args.changeMapContent,
+        model: args.model,
+        pumlPath,
+        svgPath,
+        annotationsPath: null,
+    });
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    // Compute and write gate verdict
+    const gateVerdict = computeGateVerdict(args.model, args.totalFiles);
+    await fs.writeFile(gateVerdictPath, JSON.stringify(gateVerdict, null, 2), "utf-8");
+    return {
+        manifest,
+        gateVerdict,
+        renderResult,
+        paths: {
+            puml: pumlPath,
+            manifest: manifestPath,
+            gateVerdict: gateVerdictPath,
+            svg: svgPath,
+        },
+    };
+}

package/build/mcp/tools/vibe_pm/diagrams/mermaid_generator.d.ts

@@ -0,0 +1,70 @@
+import type { DiagramModel, DiagramNode, DiagramEdge, DiagramStereotype } from "./types.js";
+export type MermaidDirection = "TB" | "LR" | "BT" | "RL";
+export type MermaidTheme = "default" | "dark" | "forest" | "neutral";
+export interface MermaidOptions {
+    direction?: MermaidDirection;
+    theme?: MermaidTheme;
+    animate?: boolean;
+    includeUnknownNodes?: boolean;
+}
+export interface MermaidResult {
+    content: string;
+    nodeCount: number;
+    edgeCount: number;
+    subgraphCount: number;
+}
+/**
+ * Sanitize node ID for Mermaid compatibility
+ * Mermaid IDs can only contain alphanumeric and underscores
+ */
+export declare function sanitizeMermaidId(id: string): string;
+/**
+ * Escape label text for Mermaid
+ * Double quotes and special chars need escaping
+ */
+export declare function escapeMermaidLabel(label: string): string;
+/**
+ * Group nodes by domain for subgraph generation
+ */
+export declare function groupNodesByDomain(nodes: DiagramNode[]): Record<string, DiagramNode[]>;
+/**
+ * Get node shape based on layer
+ * - API: Stadium shape ([...])
+ * - Service: Subroutine shape [[...]]
+ * - Data/Infra: Cylinder shape [(...)]]
+ * - Default: Rectangle [...]
+ */
+export declare function getNodeShape(layer: string): {
+    open: string;
+    close: string;
+};
+/**
+ * Get CSS class from node stereotypes
+ * Priority: FORBIDDEN > RISK > UNKNOWN > CHANGED
+ */
+export declare function getNodeClass(stereotypes: DiagramStereotype[]): string | null;
+/**
+ * Get edge arrow style based on relation
+ */
+export declare function getEdgeArrow(relation: DiagramEdge["relation"]): string;
+/**
+ * Get edge label prefix for cross-domain edges
+ */
+export declare function getEdgeLabel(edge: DiagramEdge): string | null;
+/**
+ * Convert DiagramModel to Mermaid flowchart syntax
+ */
+export declare function diagramModelToMermaid(model: DiagramModel, options?: MermaidOptions): MermaidResult;
+/**
+ * Wrap Mermaid content in a GitHub-compatible code fence
+ */
+export declare function wrapInMermaidCodeBlock(content: string): string;
+/**
+ * Generate a complete Mermaid diagram from DiagramModel
+ * Returns both raw content and GitHub-wrapped version
+ */
+export declare function generateMermaidDiagram(model: DiagramModel, options?: MermaidOptions): {
+    result: MermaidResult;
+    raw: string;
+    github: string;
+};