@girardmedia/bootspring 2.5.0 → 2.5.2

package/generators/visual-doc-generator.js

@@ -1,910 +0,0 @@
-/**
- * Bootspring Visual Document Generator
- *
- * Generates visual documentation using Mermaid diagrams.
- * Creates architecture, data flow, dependency, and component diagrams.
- *
- * @package bootspring
- * @module generators/visual-doc-generator
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Diagram types supported by the generator
- */
-const DIAGRAM_TYPES = {
-  architecture: 'flowchart',
-  dataFlow: 'flowchart',
-  dependencies: 'flowchart',
-  components: 'flowchart',
-  sequence: 'sequenceDiagram',
-  state: 'stateDiagram-v2',
-  entityRelation: 'erDiagram',
-  classHierarchy: 'classDiagram',
-  mindmap: 'mindmap',
-  timeline: 'timeline'
-};
-
-/**
- * Default colors for diagram elements
- */
-const DIAGRAM_COLORS = {
-  primary: '#4A90D9',
-  secondary: '#50B83C',
-  accent: '#F49342',
-  warning: '#FFCC00',
-  error: '#DE3618',
-  neutral: '#637381',
-  background: '#F4F6F8'
-};
-
-/**
- * Layer styling for architecture diagrams
- */
-const LAYER_STYLES = {
-  presentation: { fill: '#E3F2FD', stroke: '#1976D2' },
-  api: { fill: '#E8F5E9', stroke: '#388E3C' },
-  service: { fill: '#FFF3E0', stroke: '#F57C00' },
-  domain: { fill: '#FCE4EC', stroke: '#C2185B' },
-  data: { fill: '#F3E5F5', stroke: '#7B1FA2' },
-  infrastructure: { fill: '#ECEFF1', stroke: '#546E7A' }
-};
-
-/**
- * Visual Document Generator
- * Creates Mermaid diagrams from codebase analysis
- */
-class VisualDocGenerator {
-  /**
-   * Create a new VisualDocGenerator
-   * @param {object} options - Configuration options
-   * @param {string} options.projectRoot - Project root directory
-   * @param {string} options.outputDir - Output directory for diagrams
-   * @param {string} options.theme - Mermaid theme (default, forest, dark, neutral)
-   */
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.outputDir = options.outputDir || path.join(this.projectRoot, 'docs', 'diagrams');
-    this.theme = options.theme || 'default';
-    this.includeStyles = options.includeStyles !== false;
-  }
-
-  /**
-   * Generate architecture diagram from analysis
-   * @param {object} analysis - Architecture analysis data
-   * @returns {string} Mermaid diagram code
-   */
-  generateArchitectureDiagram(analysis) {
-    const lines = ['flowchart TB'];
-
-    // Add theme directive
-    lines.unshift(`%%{init: {'theme': '${this.theme}'}}%%`);
-
-    // Add subgraphs for each layer
-    const layers = analysis.layers || this.detectLayers(analysis);
-
-    for (const [layerName, components] of Object.entries(layers)) {
-      if (components && components.length > 0) {
-        const style = LAYER_STYLES[layerName] || LAYER_STYLES.neutral;
-        lines.push(`    subgraph ${this.sanitizeId(layerName)}["${this.formatLayerName(layerName)}"]`);
-
-        for (const component of components) {
-          const nodeId = this.sanitizeId(component.name || component);
-          const nodeName = component.name || component;
-          lines.push(`        ${nodeId}["${nodeName}"]`);
-        }
-
-        lines.push('    end');
-        lines.push('');
-      }
-    }
-
-    // Add connections between layers
-    const connections = analysis.connections || this.inferConnections(layers);
-    for (const conn of connections) {
-      const fromId = this.sanitizeId(conn.from);
-      const toId = this.sanitizeId(conn.to);
-      const label = conn.label ? `|"${conn.label}"|` : '';
-      lines.push(`    ${fromId} -->${label} ${toId}`);
-    }
-
-    // Add styling
-    if (this.includeStyles) {
-      lines.push('');
-      for (const [layerName, style] of Object.entries(LAYER_STYLES)) {
-        const layerId = this.sanitizeId(layerName);
-        lines.push(`    style ${layerId} fill:${style.fill},stroke:${style.stroke}`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate data flow diagram
-   * @param {object} analysis - Data flow analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateDataFlowDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'flowchart LR'
-    ];
-
-    // Add data sources
-    if (analysis.sources) {
-      lines.push('    subgraph Sources["Data Sources"]');
-      for (const source of analysis.sources) {
-        const id = this.sanitizeId(source.name);
-        lines.push(`        ${id}[("${source.name}")]`);
-      }
-      lines.push('    end');
-      lines.push('');
-    }
-
-    // Add processors
-    if (analysis.processors) {
-      lines.push('    subgraph Processors["Data Processors"]');
-      for (const proc of analysis.processors) {
-        const id = this.sanitizeId(proc.name);
-        lines.push(`        ${id}["${proc.name}"]`);
-      }
-      lines.push('    end');
-      lines.push('');
-    }
-
-    // Add outputs
-    if (analysis.outputs) {
-      lines.push('    subgraph Outputs["Data Outputs"]');
-      for (const output of analysis.outputs) {
-        const id = this.sanitizeId(output.name);
-        const shape = output.type === 'api' ? `{{"${output.name}"}}` : `>"${output.name}"]`;
-        lines.push(`        ${id}${shape}`);
-      }
-      lines.push('    end');
-      lines.push('');
-    }
-
-    // Add flows
-    if (analysis.flows) {
-      for (const flow of analysis.flows) {
-        const fromId = this.sanitizeId(flow.from);
-        const toId = this.sanitizeId(flow.to);
-        const arrow = flow.async ? '-.->' : '-->';
-        const label = flow.data ? `|"${flow.data}"|` : '';
-        lines.push(`    ${fromId} ${arrow}${label} ${toId}`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate dependency diagram
-   * @param {object} analysis - Dependency analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateDependencyDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'flowchart TD'
-    ];
-
-    // Group modules by type
-    const moduleGroups = this.groupModulesByType(analysis.modules || []);
-
-    for (const [groupName, modules] of Object.entries(moduleGroups)) {
-      if (modules.length > 0) {
-        lines.push(`    subgraph ${this.sanitizeId(groupName)}["${groupName}"]`);
-
-        for (const mod of modules) {
-          const id = this.sanitizeId(mod.name);
-          const shape = mod.external ? `(("${mod.name}"))` : `["${mod.name}"]`;
-          lines.push(`        ${id}${shape}`);
-        }
-
-        lines.push('    end');
-        lines.push('');
-      }
-    }
-
-    // Add dependencies
-    if (analysis.dependencies) {
-      for (const dep of analysis.dependencies) {
-        const fromId = this.sanitizeId(dep.from);
-        const toId = this.sanitizeId(dep.to);
-        const style = dep.devOnly ? '-.->' : '-->';
-        lines.push(`    ${fromId} ${style} ${toId}`);
-      }
-    }
-
-    // Highlight circular dependencies
-    if (analysis.circular && analysis.circular.length > 0) {
-      lines.push('');
-      lines.push('    %% Circular Dependencies (highlighted in red)');
-      for (const circular of analysis.circular) {
-        const id1 = this.sanitizeId(circular[0]);
-        const id2 = this.sanitizeId(circular[1]);
-        lines.push(`    ${id1} <--> ${id2}`);
-        lines.push(`    linkStyle ${lines.length - 2} stroke:red,stroke-width:2px`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate component diagram
-   * @param {object} analysis - Component analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateComponentDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'flowchart TB'
-    ];
-
-    // Add components by category
-    const categories = analysis.categories || { components: analysis.components || [] };
-
-    for (const [category, components] of Object.entries(categories)) {
-      if (components && components.length > 0) {
-        lines.push(`    subgraph ${this.sanitizeId(category)}["${this.formatCategoryName(category)}"]`);
-
-        for (const comp of components) {
-          const id = this.sanitizeId(comp.name);
-          const props = comp.props ? ` (${comp.props.join(', ')})` : '';
-          lines.push(`        ${id}["${comp.name}${props}"]`);
-        }
-
-        lines.push('    end');
-        lines.push('');
-      }
-    }
-
-    // Add component relationships
-    if (analysis.relationships) {
-      for (const rel of analysis.relationships) {
-        const parentId = this.sanitizeId(rel.parent);
-        const childId = this.sanitizeId(rel.child);
-        const label = rel.type ? `|"${rel.type}"|` : '';
-        lines.push(`    ${parentId} -->${label} ${childId}`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate sequence diagram
-   * @param {object} analysis - Sequence analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateSequenceDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'sequenceDiagram'
-    ];
-
-    // Add participants
-    if (analysis.participants) {
-      for (const participant of analysis.participants) {
-        const type = participant.type === 'actor' ? 'actor' : 'participant';
-        lines.push(`    ${type} ${participant.name}`);
-      }
-      lines.push('');
-    }
-
-    // Add messages
-    if (analysis.messages) {
-      for (const msg of analysis.messages) {
-        const arrow = this.getSequenceArrow(msg.type);
-        lines.push(`    ${msg.from}${arrow}${msg.to}: ${msg.message}`);
-
-        // Add notes if present
-        if (msg.note) {
-          lines.push(`    Note over ${msg.from},${msg.to}: ${msg.note}`);
-        }
-      }
-    }
-
-    // Add loops/conditions
-    if (analysis.blocks) {
-      for (const block of analysis.blocks) {
-        if (block.type === 'loop') {
-          lines.push(`    loop ${block.condition}`);
-        } else if (block.type === 'alt') {
-          lines.push(`    alt ${block.condition}`);
-        } else if (block.type === 'opt') {
-          lines.push(`    opt ${block.condition}`);
-        }
-
-        for (const msg of block.messages || []) {
-          const arrow = this.getSequenceArrow(msg.type);
-          lines.push(`        ${msg.from}${arrow}${msg.to}: ${msg.message}`);
-        }
-
-        lines.push('    end');
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate entity-relationship diagram
-   * @param {object} analysis - Entity analysis (database schema)
-   * @returns {string} Mermaid diagram code
-   */
-  generateERDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'erDiagram'
-    ];
-
-    // Add entities
-    if (analysis.entities) {
-      for (const entity of analysis.entities) {
-        lines.push(`    ${entity.name} {`);
-
-        for (const field of entity.fields || []) {
-          const pk = field.primaryKey ? ' PK' : '';
-          const fk = field.foreignKey ? ' FK' : '';
-          lines.push(`        ${field.type} ${field.name}${pk}${fk}`);
-        }
-
-        lines.push('    }');
-        lines.push('');
-      }
-    }
-
-    // Add relationships
-    if (analysis.relationships) {
-      for (const rel of analysis.relationships) {
-        const cardinality = this.getERCardinality(rel.type);
-        const label = rel.label ? ` : "${rel.label}"` : '';
-        lines.push(`    ${rel.from} ${cardinality} ${rel.to}${label}`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate class diagram
-   * @param {object} analysis - Class hierarchy analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateClassDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'classDiagram'
-    ];
-
-    // Add classes
-    if (analysis.classes) {
-      for (const cls of analysis.classes) {
-        lines.push(`    class ${cls.name} {`);
-
-        // Add attributes
-        for (const attr of cls.attributes || []) {
-          const visibility = this.getVisibilitySymbol(attr.visibility);
-          lines.push(`        ${visibility}${attr.type} ${attr.name}`);
-        }
-
-        // Add methods
-        for (const method of cls.methods || []) {
-          const visibility = this.getVisibilitySymbol(method.visibility);
-          const params = method.params ? method.params.join(', ') : '';
-          const returnType = method.returns ? ` ${method.returns}` : '';
-          lines.push(`        ${visibility}${method.name}(${params})${returnType}`);
-        }
-
-        lines.push('    }');
-        lines.push('');
-      }
-    }
-
-    // Add relationships
-    if (analysis.relationships) {
-      for (const rel of analysis.relationships) {
-        const arrow = this.getClassRelationArrow(rel.type);
-        const label = rel.label ? ` : ${rel.label}` : '';
-        lines.push(`    ${rel.from} ${arrow} ${rel.to}${label}`);
-      }
-    }
-
-    // Add notes/annotations
-    if (analysis.notes) {
-      for (const note of analysis.notes) {
-        lines.push(`    note for ${note.class} "${note.text}"`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate state diagram
-   * @param {object} analysis - State machine analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateStateDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'stateDiagram-v2'
-    ];
-
-    // Add states
-    if (analysis.states) {
-      for (const state of analysis.states) {
-        if (state.type === 'composite') {
-          lines.push(`    state ${state.name} {`);
-          for (const substate of state.substates || []) {
-            lines.push(`        ${substate}`);
-          }
-          lines.push('    }');
-        } else if (state.description) {
-          lines.push(`    state "${state.description}" as ${state.name}`);
-        }
-      }
-      lines.push('');
-    }
-
-    // Add transitions
-    if (analysis.transitions) {
-      for (const trans of analysis.transitions) {
-        const from = trans.from === 'initial' ? '[*]' : trans.from;
-        const to = trans.to === 'final' ? '[*]' : trans.to;
-        const label = trans.event ? ` : ${trans.event}` : '';
-        lines.push(`    ${from} --> ${to}${label}`);
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate mindmap diagram
-   * @param {object} analysis - Hierarchical concept analysis
-   * @returns {string} Mermaid diagram code
-   */
-  generateMindmapDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'mindmap'
-    ];
-
-    // Build tree structure
-    if (analysis.root) {
-      this.addMindmapNode(lines, analysis.root, 2);
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Add mindmap node recursively
-   * @param {Array} lines - Output lines
-   * @param {object} node - Node to add
-   * @param {number} indent - Indentation level
-   */
-  addMindmapNode(lines, node, indent) {
-    const spaces = ' '.repeat(indent);
-    const shape = node.shape || '';
-    const text = node.name || node;
-
-    if (typeof text === 'string') {
-      lines.push(`${spaces}${shape}${text}`);
-    } else {
-      lines.push(`${spaces}${shape}${text.name}`);
-
-      if (text.children) {
-        for (const child of text.children) {
-          this.addMindmapNode(lines, child, indent + 2);
-        }
-      }
-    }
-  }
-
-  /**
-   * Generate timeline diagram
-   * @param {object} analysis - Timeline data
-   * @returns {string} Mermaid diagram code
-   */
-  generateTimelineDiagram(analysis) {
-    const lines = [
-      `%%{init: {'theme': '${this.theme}'}}%%`,
-      'timeline'
-    ];
-
-    // Add title
-    if (analysis.title) {
-      lines.push(`    title ${analysis.title}`);
-    }
-
-    // Add sections/periods
-    if (analysis.periods) {
-      for (const period of analysis.periods) {
-        lines.push(`    section ${period.name}`);
-
-        for (const event of period.events || []) {
-          lines.push(`        ${event.date} : ${event.description}`);
-        }
-      }
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Generate all diagrams from comprehensive analysis
-   * @param {object} analysis - Full codebase analysis
-   * @returns {object} Generated diagrams by type
-   */
-  generateAllDiagrams(analysis) {
-    const diagrams = {};
-
-    // Architecture diagram
-    if (analysis.architecture) {
-      diagrams.architecture = {
-        type: 'architecture',
-        title: 'System Architecture',
-        code: this.generateArchitectureDiagram(analysis.architecture),
-        filename: 'architecture.mmd'
-      };
-    }
-
-    // Data flow diagram
-    if (analysis.dataFlow) {
-      diagrams.dataFlow = {
-        type: 'dataFlow',
-        title: 'Data Flow',
-        code: this.generateDataFlowDiagram(analysis.dataFlow),
-        filename: 'data-flow.mmd'
-      };
-    }
-
-    // Dependency diagram
-    if (analysis.dependencies) {
-      diagrams.dependencies = {
-        type: 'dependencies',
-        title: 'Module Dependencies',
-        code: this.generateDependencyDiagram(analysis.dependencies),
-        filename: 'dependencies.mmd'
-      };
-    }
-
-    // Component diagram
-    if (analysis.components) {
-      diagrams.components = {
-        type: 'components',
-        title: 'Component Hierarchy',
-        code: this.generateComponentDiagram(analysis.components),
-        filename: 'components.mmd'
-      };
-    }
-
-    // ER diagram (if database schema present)
-    if (analysis.database) {
-      diagrams.database = {
-        type: 'entityRelation',
-        title: 'Database Schema',
-        code: this.generateERDiagram(analysis.database),
-        filename: 'database.mmd'
-      };
-    }
-
-    // Class diagram (if class hierarchy present)
-    if (analysis.classes) {
-      diagrams.classes = {
-        type: 'classHierarchy',
-        title: 'Class Hierarchy',
-        code: this.generateClassDiagram(analysis.classes),
-        filename: 'classes.mmd'
-      };
-    }
-
-    return diagrams;
-  }
-
-  /**
-   * Save diagrams to files
-   * @param {object} diagrams - Generated diagrams
-   * @returns {Array<object>} Saved file information
-   */
-  saveDiagrams(diagrams) {
-    // Ensure output directory exists
-    if (!fs.existsSync(this.outputDir)) {
-      fs.mkdirSync(this.outputDir, { recursive: true });
-    }
-
-    const saved = [];
-
-    for (const [type, diagram] of Object.entries(diagrams)) {
-      const filepath = path.join(this.outputDir, diagram.filename);
-
-      // Add header comment
-      const content = [
-        `%% ${diagram.title}`,
-        '%% Generated by Bootspring Visual Doc Generator',
-        `%% ${new Date().toISOString()}`,
-        '',
-        diagram.code
-      ].join('\n');
-
-      fs.writeFileSync(filepath, content, 'utf8');
-
-      saved.push({
-        type,
-        title: diagram.title,
-        filepath,
-        filename: diagram.filename,
-        size: content.length
-      });
-    }
-
-    return saved;
-  }
-
-  /**
-   * Generate markdown documentation with embedded diagrams
-   * @param {object} diagrams - Generated diagrams
-   * @param {object} options - Documentation options
-   * @returns {string} Markdown documentation
-   */
-  generateMarkdownDoc(diagrams, options = {}) {
-    const title = options.title || 'Visual Documentation';
-    const lines = [
-      `# ${title}`,
-      '',
-      `Generated: ${new Date().toISOString()}`,
-      '',
-      '---',
-      ''
-    ];
-
-    for (const [type, diagram] of Object.entries(diagrams)) {
-      lines.push(`## ${diagram.title}`);
-      lines.push('');
-      lines.push('```mermaid');
-      lines.push(diagram.code);
-      lines.push('```');
-      lines.push('');
-    }
-
-    return lines.join('\n');
-  }
-
-  // === Helper Methods ===
-
-  /**
-   * Sanitize string for use as Mermaid node ID
-   * @param {string} str - String to sanitize
-   * @returns {string} Sanitized ID
-   */
-  sanitizeId(str) {
-    return str
-      .replace(/[^a-zA-Z0-9_]/g, '_')
-      .replace(/^_+|_+$/g, '')
-      .replace(/_+/g, '_');
-  }
-
-  /**
-   * Format layer name for display
-   * @param {string} name - Layer name
-   * @returns {string} Formatted name
-   */
-  formatLayerName(name) {
-    return name.charAt(0).toUpperCase() + name.slice(1) + ' Layer';
-  }
-
-  /**
-   * Format category name for display
-   * @param {string} name - Category name
-   * @returns {string} Formatted name
-   */
-  formatCategoryName(name) {
-    return name
-      .split(/[-_]/)
-      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Detect layers from analysis
-   * @param {object} analysis - Analysis data
-   * @returns {object} Detected layers
-   */
-  detectLayers(analysis) {
-    const layers = {
-      presentation: [],
-      api: [],
-      service: [],
-      data: []
-    };
-
-    if (analysis.files) {
-      for (const file of analysis.files) {
-        const name = path.basename(file, path.extname(file));
-
-        if (/component|page|view|ui/i.test(file)) {
-          layers.presentation.push({ name });
-        } else if (/api|route|endpoint|controller/i.test(file)) {
-          layers.api.push({ name });
-        } else if (/service|handler|manager/i.test(file)) {
-          layers.service.push({ name });
-        } else if (/model|schema|repository|database/i.test(file)) {
-          layers.data.push({ name });
-        }
-      }
-    }
-
-    return layers;
-  }
-
-  /**
-   * Infer connections between layers
-   * @param {object} layers - Layer data
-   * @returns {Array<object>} Inferred connections
-   */
-  inferConnections(layers) {
-    const connections = [];
-    const layerOrder = ['presentation', 'api', 'service', 'data'];
-
-    for (let i = 0; i < layerOrder.length - 1; i++) {
-      const currentLayer = layerOrder[i];
-      const nextLayer = layerOrder[i + 1];
-
-      if (layers[currentLayer]?.length > 0 && layers[nextLayer]?.length > 0) {
-        connections.push({
-          from: this.sanitizeId(currentLayer),
-          to: this.sanitizeId(nextLayer)
-        });
-      }
-    }
-
-    return connections;
-  }
-
-  /**
-   * Group modules by type
-   * @param {Array} modules - Module list
-   * @returns {object} Grouped modules
-   */
-  groupModulesByType(modules) {
-    const groups = {
-      'Core Modules': [],
-      'External Dependencies': [],
-      'Dev Dependencies': [],
-      'Utilities': []
-    };
-
-    for (const mod of modules) {
-      if (mod.external) {
-        if (mod.devOnly) {
-          groups['Dev Dependencies'].push(mod);
-        } else {
-          groups['External Dependencies'].push(mod);
-        }
-      } else if (/util|helper|lib/i.test(mod.name)) {
-        groups['Utilities'].push(mod);
-      } else {
-        groups['Core Modules'].push(mod);
-      }
-    }
-
-    return groups;
-  }
-
-  /**
-   * Get sequence diagram arrow style
-   * @param {string} type - Message type
-   * @returns {string} Arrow string
-   */
-  getSequenceArrow(type) {
-    switch (type) {
-      case 'sync': return '->>';
-      case 'async': return '->>+';
-      case 'reply': return '-->>';
-      case 'self': return '->>+';
-      case 'create': return '->>+';
-      case 'destroy': return '-x';
-      default: return '->>';
-    }
-  }
-
-  /**
-   * Get ER diagram cardinality notation
-   * @param {string} type - Relationship type
-   * @returns {string} Cardinality string
-   */
-  getERCardinality(type) {
-    switch (type) {
-      case 'one-to-one': return '||--||';
-      case 'one-to-many': return '||--o{';
-      case 'many-to-one': return '}o--||';
-      case 'many-to-many': return '}o--o{';
-      case 'zero-or-one': return '|o--||';
-      case 'zero-or-many': return '}o--||';
-      default: return '||--||';
-    }
-  }
-
-  /**
-   * Get class diagram relationship arrow
-   * @param {string} type - Relationship type
-   * @returns {string} Arrow string
-   */
-  getClassRelationArrow(type) {
-    switch (type) {
-      case 'extends': return '<|--';
-      case 'implements': return '<|..';
-      case 'composition': return '*--';
-      case 'aggregation': return 'o--';
-      case 'association': return '-->';
-      case 'dependency': return '..>';
-      default: return '-->';
-    }
-  }
-
-  /**
-   * Get visibility symbol for class members
-   * @param {string} visibility - Visibility level
-   * @returns {string} Symbol
-   */
-  getVisibilitySymbol(visibility) {
-    switch (visibility) {
-      case 'public': return '+';
-      case 'private': return '-';
-      case 'protected': return '#';
-      case 'package': return '~';
-      default: return '+';
-    }
-  }
-}
-
-/**
- * Create a quick architecture diagram from simple config
- * @param {object} config - Simple architecture config
- * @returns {string} Mermaid diagram code
- */
-function quickArchitectureDiagram(config) {
-  const generator = new VisualDocGenerator();
-  return generator.generateArchitectureDiagram({
-    layers: config.layers || {},
-    connections: config.connections || []
-  });
-}
-
-/**
- * Create a quick dependency diagram
- * @param {Array} modules - Module list with dependencies
- * @returns {string} Mermaid diagram code
- */
-function quickDependencyDiagram(modules) {
-  const generator = new VisualDocGenerator();
-
-  const dependencies = [];
-  for (const mod of modules) {
-    for (const dep of mod.dependencies || []) {
-      dependencies.push({ from: mod.name, to: dep });
-    }
-  }
-
-  return generator.generateDependencyDiagram({
-    modules,
-    dependencies
-  });
-}
-
-module.exports = {
-  VisualDocGenerator,
-  quickArchitectureDiagram,
-  quickDependencyDiagram,
-  DIAGRAM_TYPES,
-  DIAGRAM_COLORS,
-  LAYER_STYLES
-};