Mermaid Tools

Security scan passed
Scanned at: 2026-06-13T19:44:41.931593
Tool: gitleaks + pattern-based validation
Content hash: aeb15891ceadd351bb4c313a0a2a145d68102593f507d89dfe4dc637e98b98a9

#!/usr/bin/env python3
"""
Extract Mermaid diagrams from markdown file and create numbered .mmd files
"""

import re
import sys
from pathlib import Path

def extract_mermaid_diagrams(markdown_file, output_dir):
    """Extract Mermaid diagrams from markdown file and create numbered .mmd files"""

    try:
        with open(markdown_file, 'r', encoding='utf-8') as f:
            content = f.read()
    except Exception as e:
        print(f"ERROR: Cannot read markdown file: {e}")
        return []

    # Find all mermaid code blocks with their content
    mermaid_pattern = r'```mermaid\n(.*?)\n```'
    matches = re.findall(mermaid_pattern, content, re.DOTALL)

    if not matches:
        print("No Mermaid diagrams found in markdown file")
        return []

    # Extract diagram names from context (look backwards for section headers)
    diagrams = []
    lines = content.split('\n')

    for i, match in enumerate(matches, 1):
        # Find the position of this diagram in the content
        diagram_pattern = f'```mermaid\n{re.escape(match)}\n```'
        diagram_match = re.search(diagram_pattern, content)

        if not diagram_match:
            # Fallback: use simple search
            diagram_start = content.find(f'```mermaid\n{match}\n```')
        else:
            diagram_start = diagram_match.start()

        # Count lines up to this point to find context
        if diagram_start >= 0:
            lines_before = content[:diagram_start].count('\n')
        else:
            lines_before = 0

        # Look backwards for the most recent section header or meaningful context
        diagram_name = f"diagram-{i:02d}"  # Default fallback

        # Look for context clues in the 20 lines before the diagram
        context_start = max(0, lines_before - 20)
        context_lines = lines[context_start:lines_before] if lines_before > 0 else []

        # Priority 1: Look for specific diagram descriptions
        for line in reversed(context_lines):
            line = line.strip().lower()
            if 'system architecture' in line:
                diagram_name = f"{i:02d}-system-architecture"
                break
            elif 'authentication flow' in line:
                diagram_name = f"{i:02d}-authentication-flow"
                break
            elif 'caching architecture' in line or 'multi-layer cache' in line:
                diagram_name = f"{i:02d}-caching-architecture"
                break
            elif 'data flow' in line or 'redshift schema' in line:
                diagram_name = f"{i:02d}-data-flow"
                break
            elif 'api request' in line or 'dashboard metrics endpoints' in line:
                diagram_name = f"{i:02d}-api-request-response"
                break
            elif 'dashboard layout' in line or 'presentation layer' in line:
                diagram_name = f"{i:02d}-dashboard-layout"
                break
            elif 'agency' in line and ('hierarchy' in line or 'filter' in line):
                diagram_name = f"{i:02d}-agency-hierarchy"
                break

        # Priority 2: Look for section headers (## or ###)
        if diagram_name.startswith('diagram-'):
            for line in reversed(context_lines):
                line = line.strip()
                if line.startswith('###') or line.startswith('##'):
                    # Extract meaningful part from header
                    header = re.sub(r'^#+\s*\*?\*?', '', line)
                    header = re.sub(r'\*?\*?$', '', header)
                    header = header.strip()

                    # Convert to filename-friendly format
                    name_part = re.sub(r'[^\w\s-]', '', header)
                    name_part = re.sub(r'\s+', '-', name_part.strip())
                    name_part = name_part.lower()[:30]  # Limit length

                    if name_part and name_part != 'detailed-design':
                        diagram_name = f"{i:02d}-{name_part}"
                        break

        diagrams.append({
            'number': i,
            'name': diagram_name,
            'content': match.strip()
        })

        print(f"Found diagram {i}: {diagram_name}")

    # Write .mmd files
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)

    created_files = []
    for diagram in diagrams:
        mmd_file = output_path / f"{diagram['name']}.mmd"
        try:
            with open(mmd_file, 'w', encoding='utf-8') as f:
                f.write(diagram['content'])
            created_files.append(str(mmd_file))
            print(f"Created: {mmd_file}")
        except Exception as e:
            print(f"ERROR: Cannot create {mmd_file}: {e}")

    return created_files

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python3 extract_diagrams.py <markdown_file> <output_directory>")
        sys.exit(1)

    markdown_file = sys.argv[1]
    output_dir = sys.argv[2]

    files = extract_mermaid_diagrams(markdown_file, output_dir)
    print(f"\nExtracted {len(files)} diagrams successfully")

#!/bin/bash
# Enhanced Mermaid diagram extraction and PNG generation script
# Extracts diagrams from markdown and numbers them sequentially
#
# Usage: ./extract-and-generate.sh <markdown_file> [output_directory]
# Example: ./extract-and-generate.sh <markdown_file> <output_directory>

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_FILE="$SCRIPT_DIR/puppeteer-config.json"
EXTRACTOR_SCRIPT="$SCRIPT_DIR/extract_diagrams.py"

# Parse arguments
if [ $# -lt 1 ]; then
    echo "Usage: $0 <markdown_file> [output_directory]"
    echo "Example: $0 <markdown_file> <output_directory>"
    exit 1
fi

MARKDOWN_FILE="$1"
OUTPUT_DIR="${2:-$(dirname "$MARKDOWN_FILE")/diagrams}"

echo "=== Enhanced Mermaid Diagram Processor ==="
echo "Source markdown: $MARKDOWN_FILE"
echo "Output directory: $OUTPUT_DIR"
echo "Environment: WSL2 Ubuntu with Chrome dependencies"
echo

# Validate inputs
if [ ! -f "$MARKDOWN_FILE" ]; then
    echo "ERROR: Markdown file not found: $MARKDOWN_FILE"
    exit 1
fi

# Create output directory if it doesn't exist
mkdir -p "$OUTPUT_DIR"

# Configuration
CHROME_PATH="/usr/bin/google-chrome-stable"

# Check dependencies
echo "Checking dependencies..."
if ! command -v mmdc &> /dev/null; then
    echo "ERROR: @mermaid-js/mermaid-cli not installed"
    echo "Install with: npm install -g @mermaid-js/mermaid-cli"
    exit 1
fi

if [ ! -f "$CHROME_PATH" ]; then
    echo "ERROR: Google Chrome not found at $CHROME_PATH"
    echo "Install Chrome and dependencies with the setup commands"
    exit 1
fi

if [ ! -f "$CONFIG_FILE" ]; then
    echo "ERROR: Puppeteer config not found: $CONFIG_FILE"
    exit 1
fi

if [ ! -f "$EXTRACTOR_SCRIPT" ]; then
    echo "ERROR: Python extractor script not found: $EXTRACTOR_SCRIPT"
    exit 1
fi

echo "✅ Dependencies verified"
echo

# Extract Mermaid diagrams from markdown
echo "Extracting Mermaid diagrams from markdown..."
python3 "$EXTRACTOR_SCRIPT" "$MARKDOWN_FILE" "$OUTPUT_DIR"

if [ $? -ne 0 ]; then
    echo "ERROR: Failed to extract diagrams from markdown"
    exit 1
fi

echo

# Now generate PNGs using the existing generation logic
echo "Generating PNG files..."
cd "$OUTPUT_DIR"

# Default dimensions - can be overridden with environment variables
DEFAULT_WIDTH="${MERMAID_WIDTH:-1200}"
DEFAULT_HEIGHT="${MERMAID_HEIGHT:-800}"
SCALE_FACTOR="${MERMAID_SCALE:-2}"

# Process all .mmd files in order
mmd_files=(*.mmd)

if [ ${#mmd_files[@]} -eq 1 ] && [ "${mmd_files[0]}" = "*.mmd" ]; then
    echo "No .mmd files found in output directory"
    exit 0
fi

# Sort files numerically by their prefix
IFS=$'\n' mmd_files=($(sort -V <<< "${mmd_files[*]}"))

echo "Found ${#mmd_files[@]} Mermaid diagram(s) to process"
echo

for mmd_file in "${mmd_files[@]}"; do
    if [ ! -f "$mmd_file" ]; then
        continue
    fi

    # Extract filename without extension
    diagram="${mmd_file%.mmd}"

    # Use smart defaults based on diagram content or filename patterns
    width="$DEFAULT_WIDTH"
    height="$DEFAULT_HEIGHT"

    # Smart sizing based on filename patterns
    if [[ "$diagram" =~ timeline|gantt ]]; then
        width=$((DEFAULT_WIDTH * 2))  # Wider for timelines
        height=$((DEFAULT_HEIGHT / 2))  # Shorter for timelines
    elif [[ "$diagram" =~ architecture|system ]]; then
        width=$((DEFAULT_WIDTH * 2))  # Larger for complex diagrams
        height=$((DEFAULT_HEIGHT * 2))
    elif [[ "$diagram" =~ caching ]]; then
        width=$((DEFAULT_WIDTH * 2))  # Larger for caching flowcharts
        height=$((DEFAULT_HEIGHT * 2))
    elif [[ "$diagram" =~ monitoring|workflow|sequence|api ]]; then
        width=$((DEFAULT_WIDTH * 2))  # Wider for workflows and sequences
        height="$DEFAULT_HEIGHT"
    fi

    echo "Generating $diagram.png (${width}x${height}, scale: ${SCALE_FACTOR}x)..."
    PUPPETEER_EXECUTABLE_PATH="$CHROME_PATH" mmdc \
        -i "$mmd_file" \
        -o "$diagram.png" \
        --puppeteerConfigFile "$CONFIG_FILE" \
        -w "$width" \
        -H "$height" \
        -s "$SCALE_FACTOR"

    if [ $? -eq 0 ]; then
        echo "  ✅ Generated successfully"
    else
        echo "  ❌ Generation failed"
        continue
    fi

    # Validate PNG
    if test -s "$diagram.png" && file "$diagram.png" | grep -q "PNG image"; then
        size=$(stat -c%s "$diagram.png")
        dimensions_actual=$(identify -format "%wx%h" "$diagram.png" 2>/dev/null || echo "unknown")
        echo "  ✅ Validated PNG (${size} bytes, ${dimensions_actual})"
    else
        echo "  ❌ PNG validation failed"
    fi
    echo
done

echo "=== Generation Complete ==="
echo "All PNG diagrams generated and validated successfully!"
echo

echo "Generated files (in sequence order):"
ls -la [0-9][0-9]-*.png 2>/dev/null | awk '{printf "  %s (%s bytes)\n", $9, $5}' || echo "  No numbered PNG files found"

echo
echo "Generated files (all):"
ls -la *.png 2>/dev/null | awk '{printf "  %s (%s bytes)\n", $9, $5}' || echo "  No PNG files found"

{
  "args": [
    "--no-sandbox",
    "--disable-setuid-sandbox",
    "--disable-dev-shm-usage",
    "--disable-gpu",
    "--no-first-run",
    "--disable-background-timer-throttling",
    "--disable-backgrounding-occluded-windows",
    "--disable-renderer-backgrounding",
    "--disable-features=TranslateUI",
    "--disable-ipc-flooding-protection"
  ]
}