init

cmd/demo-all/main.go

@@ -10,7 +10,7 @@ import (
 )
 
 func main() {
-	fmt.Println("=== Mermaid-Go Comprehensive Demo ===\n")
+	fmt.Println("=== Mermaid-Go Comprehensive Demo ===")
 
 	// Test flowchart
 	testFlowchart()
@@ -36,6 +36,30 @@ func main() {
 	testERDiagram()
 	fmt.Println()
 
+	// Test Gantt chart
+	testGanttChart()
+	fmt.Println()
+
+	// Test Timeline
+	testTimeline()
+	fmt.Println()
+
+	// Test User Journey
+	testUserJourney()
+	fmt.Println()
+
+	// Test Architecture
+	testArchitecture()
+	fmt.Println()
+
+	// Test Organization Chart
+	testOrganizationChart()
+	fmt.Println()
+
+	// Test BPMN
+	testBPMN()
+	fmt.Println()
+
 	fmt.Println("=== Demo Complete ===")
 }
 
@@ -205,3 +229,187 @@ func testERDiagram() {
 	fmt.Printf("Input:\n%s\n", input)
 	fmt.Printf("Parsed and rendered:\n%s", output)
 }
+func testGanttChart() {
+	fmt.Println("--- Testing Gantt Chart ---")
+
+	input := `gantt
+    title Project Timeline
+    dateFormat YYYY-MM-DD
+    section Planning
+    Research : 2024-01-01, 5d
+    Design : 2024-01-06, 3d
+    section Development
+    Backend : 2024-01-09, 10d
+    Frontend : 2024-01-15, 8d`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse Gantt chart: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render Gantt chart: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}
+
+func testTimeline() {
+	fmt.Println("--- Testing Timeline ---")
+
+	input := `timeline
+    title History of Computing
+    section Early Era
+    : 1940s : First computers
+    : 1950s : Programming languages
+    section Modern Era
+    : 1970s : Personal computers
+    : 1990s : Internet boom`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse Timeline: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render Timeline: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}
+
+func testUserJourney() {
+	fmt.Println("--- Testing User Journey ---")
+
+	input := `journey
+    title User Shopping Journey
+    section Discovery
+    Search for product : 5 : User
+    Read reviews : 3 : User
+    section Purchase
+    Add to cart : 5 : User
+    Checkout : 2 : User, System`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse User Journey: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render User Journey: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}
+
+func testArchitecture() {
+	fmt.Println("--- Testing Architecture ---")
+
+	input := `architecture
+    title System Architecture
+    group api[API Layer]
+    service web[Web Server] in api
+    service db[Database]
+    web L--R db : queries`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse Architecture: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render Architecture: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}
+
+func testOrganizationChart() {
+	fmt.Println("--- Testing Organization Chart ---")
+
+	input := `organization
+    title Company Structure
+    CEO[Chief Executive Officer]
+    CEO --> CTO[Chief Technology Officer]
+    CEO --> CFO[Chief Financial Officer]
+    CTO --> DevManager[Development Manager]
+    CTO --> QAManager[QA Manager]
+    DevManager --> Developer1[Senior Developer]
+    DevManager --> Developer2[Junior Developer]`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse Organization Chart: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render Organization Chart: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}
+
+func testBPMN() {
+	fmt.Println("--- Testing BPMN ---")
+
+	input := `bpmn
+    title Order Processing
+    pool customer[Customer]
+    pool system[Order System]
+    
+    startEvent[Order Request](startEvent)
+    validateTask[Validate Order](userTask)
+    processTask[Process Payment](serviceTask)
+    endEvent[Order Complete](endEvent)
+    
+    startEvent --> validateTask : submit order
+    validateTask --> processTask : valid
+    processTask --> endEvent : completed`
+
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
+	if err != nil {
+		log.Printf("Failed to parse BPMN: %v", err)
+		return
+	}
+
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	if err != nil {
+		log.Printf("Failed to render BPMN: %v", err)
+		return
+	}
+
+	fmt.Printf("Input:\n%s\n", input)
+	fmt.Printf("Parsed and rendered:\n%s", output)
+}

debug_tokens.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"mermaid-go/pkg/lexer"
-)
-
-func main() {
-	fmt.Println("Debug tokenization of annotations:")
-
-	input := `classDiagram
-    class Shape {
-        <<interface>>
-        +area() double
-    }`
-
-	l := lexer.NewLexer(input)
-	tokens, err := l.Tokenize()
-	if err != nil {
-		log.Printf("Failed to tokenize: %v", err)
-		return
-	}
-
-	fmt.Printf("Tokens:\n")
-	for i, token := range tokens {
-		fmt.Printf("%d: %s\n", i, token.String())
-	}
-}

pkg/ast/flowchart.go

@@ -18,6 +18,10 @@ const (
 	DiagramTypePie          DiagramType = "pie"
 	DiagramTypeQuadrant     DiagramType = "quadrantChart"
 	DiagramTypeRequirement  DiagramType = "requirementDiagram"
+	DiagramTypeArchitecture DiagramType = "architecture"
+	DiagramTypeNetwork      DiagramType = "network"
+	DiagramTypeBPMN         DiagramType = "bpmn"
+	DiagramTypeOrganization DiagramType = "organization"
 )
 
 // Diagram is the base interface for all mermaid diagrams

pkg/lexer/lexer.go

@@ -109,7 +109,15 @@ type Token struct {
 // String returns a string representation of the token
 func (t Token) String() string {
 	return fmt.Sprintf("Token{Type: %s, Value: %q, Line: %d, Col: %d}",
-		tokenTypeNames[t.Type], t.Value, t.Line, t.Column)
+		t.Type.String(), t.Value, t.Line, t.Column)
+}
+
+// String returns the string representation of TokenType
+func (tt TokenType) String() string {
+	if name, exists := tokenTypeNames[tt]; exists {
+		return name
+	}
+	return fmt.Sprintf("TokenType(%d)", int(tt))
 }
 
 var tokenTypeNames = map[TokenType]string{

pkg/parser/class.go

@@ -511,7 +511,7 @@ func (p *ClassParser) checkVisibility() bool {
 	token := p.peek()
 	return (token.Value == "+" || token.Value == "-" || token.Value == "#" || token.Value == "~") ||
 		(token.Type == lexer.TokenPlus || token.Type == lexer.TokenMinus ||
-		 token.Type == lexer.TokenHash || token.Type == lexer.TokenTilde)
+			token.Type == lexer.TokenHash || token.Type == lexer.TokenTilde)
 }
 
 func (p *ClassParser) checkRelation() bool {
@@ -550,7 +550,7 @@ func (p *ClassParser) previous() lexer.Token {
 func (p *ClassParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }
 
 func (p *ClassParser) skipToNextStatement() error {

pkg/parser/er.go

@@ -398,5 +398,5 @@ func (p *ERParser) previous() lexer.Token {
 func (p *ERParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }

pkg/parser/flowchart.go

@@ -822,7 +822,7 @@ func (p *Parser) previous() lexer.Token {
 func (p *Parser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }
 
 // skipToNextStatement skips tokens until next statement

pkg/parser/mermaid.go

@@ -40,6 +40,24 @@ func (p *MermaidParser) Parse(input string) (ast.Diagram, error) {
 	case ast.DiagramTypeERDiagram:
 		parser := NewERParser()
 		return parser.Parse(input)
+	case ast.DiagramTypeGantt:
+		parser := NewGanttParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeTimeline:
+		parser := NewTimelineParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeUserJourney:
+		parser := NewJourneyParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeArchitecture:
+		parser := NewArchitectureParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeOrganization:
+		parser := NewOrganizationParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeBPMN:
+		parser := NewBPMNParser()
+		return parser.Parse(input)
 	default:
 		return nil, fmt.Errorf("unsupported diagram type: %s", diagramType)
 	}
@@ -96,6 +114,15 @@ func (p *MermaidParser) detectDiagramType(input string) ast.DiagramType {
 		if strings.HasPrefix(lowerLine, "block") {
 			return ast.DiagramTypeBlock
 		}
+		if strings.HasPrefix(lowerLine, "architecture") {
+			return ast.DiagramTypeArchitecture
+		}
+		if strings.HasPrefix(lowerLine, "organization") || strings.HasPrefix(lowerLine, "orgchart") {
+			return ast.DiagramTypeOrganization
+		}
+		if strings.HasPrefix(lowerLine, "bpmn") {
+			return ast.DiagramTypeBPMN
+		}
 
 		// If no explicit type found, try to infer from content
 		// This is a fallback for diagrams without explicit type declarations
@@ -151,6 +178,24 @@ func (p *MermaidParser) ParseWithType(input string, diagramType ast.DiagramType)
 	case ast.DiagramTypeERDiagram:
 		parser := NewERParser()
 		return parser.Parse(input)
+	case ast.DiagramTypeGantt:
+		parser := NewGanttParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeTimeline:
+		parser := NewTimelineParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeUserJourney:
+		parser := NewJourneyParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeArchitecture:
+		parser := NewArchitectureParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeOrganization:
+		parser := NewOrganizationParser()
+		return parser.Parse(input)
+	case ast.DiagramTypeBPMN:
+		parser := NewBPMNParser()
+		return parser.Parse(input)
 	default:
 		return nil, fmt.Errorf("unsupported diagram type: %s", diagramType)
 	}

pkg/parser/pie.go

@@ -239,5 +239,5 @@ func (p *PieParser) previous() lexer.Token {
 func (p *PieParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }

pkg/parser/sequence.go

@@ -598,7 +598,7 @@ func (p *SequenceParser) previous() lexer.Token {
 func (p *SequenceParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }
 
 func (p *SequenceParser) skipToEnd(endKeyword string) error {

pkg/parser/state.go

@@ -442,7 +442,7 @@ func (p *StateParser) previous() lexer.Token {
 func (p *StateParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
-		token.Line, token.Column, message, token.Type)
+		token.Line, token.Column, message, token.Type.String())
 }
 
 func (p *StateParser) skipToNextStatement() error {

pkg/renderer/mermaid.go

@@ -37,11 +37,23 @@ func (r *MermaidRenderer) Render(diagram ast.Diagram) (string, error) {
 		renderer := NewERRenderer()
 		return renderer.Render(d)
 	case *ast.GanttDiagram:
-		return r.renderGanttDiagram(d)
+		renderer := NewGanttRenderer()
+		return renderer.Render(d)
 	case *ast.TimelineDiagram:
-		return r.renderTimelineDiagram(d)
+		renderer := NewTimelineRenderer()
+		return renderer.Render(d)
 	case *ast.UserJourneyDiagram:
-		return r.renderUserJourneyDiagram(d)
+		renderer := NewJourneyRenderer()
+		return renderer.Render(d)
+	case *ast.ArchitectureDiagram:
+		renderer := NewArchitectureRenderer()
+		return renderer.Render(d)
+	case *ast.OrganizationDiagram:
+		renderer := NewOrganizationRenderer()
+		return renderer.Render(d)
+	case *ast.BPMNDiagram:
+		renderer := NewBPMNRenderer()
+		return renderer.Render(d)
 	case *ast.QuadrantChart:
 		return r.renderQuadrantChart(d)
 	case *ast.RequirementDiagram:
@@ -51,26 +63,7 @@ func (r *MermaidRenderer) Render(diagram ast.Diagram) (string, error) {
 	}
 }
 
-// Placeholder implementations for other diagram types
-func (r *MermaidRenderer) renderERDiagram(diagram *ast.ERDiagram) (string, error) {
-	return "erDiagram\n    %% ER diagram rendering not yet implemented\n", nil
-}
-
-func (r *MermaidRenderer) renderGanttDiagram(diagram *ast.GanttDiagram) (string, error) {
-	return "gantt\n    %% Gantt diagram rendering not yet implemented\n", nil
-}
-
-func (r *MermaidRenderer) renderPieChart(diagram *ast.PieChart) (string, error) {
-	return "pie\n    %% Pie chart rendering not yet implemented\n", nil
-}
-
-func (r *MermaidRenderer) renderTimelineDiagram(diagram *ast.TimelineDiagram) (string, error) {
-	return "timeline\n    %% Timeline diagram rendering not yet implemented\n", nil
-}
-
-func (r *MermaidRenderer) renderUserJourneyDiagram(diagram *ast.UserJourneyDiagram) (string, error) {
-	return "journey\n    %% User journey diagram rendering not yet implemented\n", nil
-}
+// Placeholder implementations for remaining diagram types
 
 func (r *MermaidRenderer) renderQuadrantChart(diagram *ast.QuadrantChart) (string, error) {
 	return "quadrantChart\n    %% Quadrant chart rendering not yet implemented\n", nil

simple_annotation.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"mermaid-go/pkg/parser"
-	"mermaid-go/pkg/renderer"
-)
-
-func main() {
-	fmt.Println("Simple annotation test:")
-
-	input := `classDiagram
-    class Shape {
-        <<interface>>
-        +area() double
-    }`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}

test_class.go

@@ -1,115 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"mermaid-go/pkg/parser"
-	"mermaid-go/pkg/renderer"
-)
-
-func main() {
-	fmt.Println("Testing Enhanced Class Diagram Features:")
-
-	// Test 1: Interface types
-	testInterface()
-	fmt.Println()
-
-	// Test 2: Abstract classes
-	testAbstractClass()
-	fmt.Println()
-
-	// Test 3: Method parameters and return types
-	testMethodsAndParameters()
-	fmt.Println()
-}
-
-func testInterface() {
-	fmt.Println("--- Testing Interface ---")
-
-	input := `classDiagram
-    class Shape {
-        <<interface>>
-        +area() double
-        +perimeter() double
-    }
-
-    Shape <|.. Circle
-    Shape <|.. Rectangle`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testAbstractClass() {
-	fmt.Println("--- Testing Abstract Class ---")
-
-	input := `classDiagram
-    class Animal {
-        <<abstract>>
-        +name String
-        +age int
-        +makeSound()* void
-        +move() void
-    }`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testMethodsAndParameters() {
-	fmt.Println("--- Testing Methods with Parameters ---")
-
-	input := `classDiagram
-    class Calculator {
-        +add(a int, b int) int
-        +subtract(a int, b int) int
-        +multiply(a int, b int) int
-        +divide(a int, b int) float
-        -validateInput(value int) bool
-    }`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}

test_class_advanced.go

@@ -1,116 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"mermaid-go/pkg/parser"
-	"mermaid-go/pkg/renderer"
-)
-
-func main() {
-	fmt.Println("Testing Advanced Class Diagram Features:")
-
-	// Test 1: Comments and Notes
-	testCommentsAndNotes()
-	fmt.Println()
-
-	// Test 2: Enhanced Annotations
-	testEnhancedAnnotations()
-	fmt.Println()
-
-	// Test 3: Direction control
-	testDirection()
-	fmt.Println()
-}
-
-func testCommentsAndNotes() {
-	fmt.Println("--- Testing Comments and Notes ---")
-
-	input := `classDiagram
-    %% This is a comment
-    class Animal {
-        +name String
-        +age int
-    }
-
-    note "This is a general note"
-    note for Animal "This is a note for Animal class"`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testEnhancedAnnotations() {
-	fmt.Println("--- Testing Enhanced Annotations ---")
-
-	input := `classDiagram
-    class Shape {
-        <<interface>>
-        +area() double
-        +perimeter() double
-    }
-
-    class Animal {
-        <<abstract>>
-        +name String
-        +makeSound()* void
-    }`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testDirection() {
-	fmt.Println("--- Testing Direction Control ---")
-
-	input := `classDiagram
-    direction TB
-    class A
-    class B
-    A --> B`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse class diagram: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render class diagram: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}

test_flowchart_advanced.go

@@ -1,117 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"mermaid-go/pkg/parser"
-	"mermaid-go/pkg/renderer"
-)
-
-func main() {
-	fmt.Println("Testing Advanced Flowchart Features:")
-
-	// Test 1: Click events
-	testClickEvents()
-	fmt.Println()
-
-	// Test 2: Advanced subgraphs with styling
-	testAdvancedSubgraphs()
-	fmt.Println()
-
-	// Test 3: Complex node shapes
-	testComplexShapes()
-	fmt.Println()
-}
-
-func testClickEvents() {
-	fmt.Println("--- Testing Click Events ---")
-
-	input := `flowchart TD
-    A[Start] --> B[Process]
-    B --> C[End]
-
-    click A "https://example.com" "_blank"
-    click B callback
-    click C "https://mermaid.js.org"`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse flowchart: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render flowchart: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testAdvancedSubgraphs() {
-	fmt.Println("--- Testing Advanced Subgraphs ---")
-
-	input := `flowchart TB
-    subgraph TOP["Top Level"]
-        direction TB
-        A[Input] --> B[Process]
-    end
-
-    subgraph BOTTOM[Bottom Level]
-        direction LR
-        C[Review] --> D[Output]
-    end
-
-    TOP --> BOTTOM
-    classDef processClass fill:#f9f,stroke:#333,stroke-width:2px`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse flowchart: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render flowchart: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}
-
-func testComplexShapes() {
-	fmt.Println("--- Testing Complex Shapes ---")
-
-	input := `flowchart LR
-    A([Start]) --> B{Decision}
-    B --> C[/Process/]
-    B --> D[\Alternative\]
-    C --> E>Flag Shape]
-    D --> E
-    E --> F((End))`
-
-	mermaidParser := parser.NewMermaidParser()
-	diagram, err := mermaidParser.Parse(input)
-	if err != nil {
-		log.Printf("Failed to parse flowchart: %v", err)
-		return
-	}
-
-	mermaidRenderer := renderer.NewMermaidRenderer()
-	output, err := mermaidRenderer.Render(diagram)
-	if err != nil {
-		log.Printf("Failed to render flowchart: %v", err)
-		return
-	}
-
-	fmt.Printf("Input:\n%s\n", input)
-	fmt.Printf("Parsed and rendered:\n%s", output)
-}

tests/integration_test.go

@@ -6,7 +6,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"mermaid-go/pkg/ast"
-	"mermaid-go/pkg/mermaid"
+	"mermaid-go/pkg/parser"
+	"mermaid-go/pkg/renderer"
 )
 
 func TestMermaid_ParseAndRender_RoundTrip(t *testing.T) {
@@ -42,11 +43,11 @@ func TestMermaid_ParseAndRender_RoundTrip(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			parser := mermaid.NewParser()
-			renderer := mermaid.NewRenderer()
+			mermaidParser := parser.NewMermaidParser()
+			mermaidRenderer := renderer.NewMermaidRenderer()
 
 			// Parse
-			diagram, err := parser.Parse(tc.input)
+			diagram, err := mermaidParser.Parse(tc.input)
 			require.NoError(t, err)
 			require.NotNil(t, diagram)
 
@@ -55,14 +56,15 @@ func TestMermaid_ParseAndRender_RoundTrip(t *testing.T) {
 			require.NoError(t, err)
 
 			// Render
-			output := renderer.Render(diagram)
+			output, err := mermaidRenderer.Render(diagram)
+			require.NoError(t, err)
 			require.NotEmpty(t, output)
 
 			// Verify it starts with graph declaration
 			assert.Contains(t, output, "graph")
 
 			// Parse the rendered output again to ensure it's valid
-			diagram2, err := parser.Parse(output)
+			diagram2, err := mermaidParser.Parse(output)
 			require.NoError(t, err)
 			require.NotNil(t, diagram2)
 
@@ -81,8 +83,8 @@ func TestMermaid_ComplexFlowchart(t *testing.T) {
     C -.->|Two| E[iPhone]
     C -.->|Three| F[Car]`
 
-	parser := mermaid.NewParser()
-	diagram, err := parser.Parse(input)
+	mermaidParser := parser.NewMermaidParser()
+	diagram, err := mermaidParser.Parse(input)
 	require.NoError(t, err)
 
 	flowchart := diagram.(*ast.Flowchart)
@@ -107,8 +109,9 @@ func TestMermaid_ComplexFlowchart(t *testing.T) {
 	assert.Equal(t, "Go shopping", *vertexB.Text)
 
 	// Render and verify
-	renderer := mermaid.NewRenderer()
-	output := renderer.Render(diagram)
+	mermaidRenderer := renderer.NewMermaidRenderer()
+	output, err := mermaidRenderer.Render(diagram)
+	require.NoError(t, err)
 
 	assert.Contains(t, output, "graph TD")
 	assert.Contains(t, output, "Christmas")