init

EXPORT_GUIDE.md

@@ -0,0 +1,466 @@
+# 🖼️ Mermaid-Go SVG导出指南
+
+## 📋 概述
+
+mermaid-go 现在支持将解析的图表结构导出为高质量的SVG格式图片。这个功能让你可以：
+
+- 📊 将Mermaid图表转换为矢量图形
+- 🎨 支持SVG格式（矢量图形，无损缩放）
+- ⚙️ 自定义尺寸和主题
+- 🛠️ 提供编程接口和命令行工具
+
+## 🚀 快速开始
+
+### 基本用法
+
+```go
+package main
+
+import (
+    "mermaid-go/pkg/parser"
+    "mermaid-go/pkg/exporter"
+)
+
+func main() {
+    // 解析Mermaid图表
+    input := `pie showData
+        title Market Share
+        "Company A" : 45
+        "Company B" : 30
+        "Others" : 25`
+    
+    parser := parser.NewMermaidParser()
+    diagram, _ := parser.Parse(input)
+    
+    // 导出为SVG
+    exporter := exporter.NewDiagramExporter()
+    options := &exporter.ExportOptions{
+        Format: exporter.FormatSVG,
+        Width:  800,
+        Height: 600,
+        Theme:  "default",
+    }
+    
+    err := exporter.ExportToFile(diagram, "chart.png", options)
+    if err != nil {
+        panic(err)
+    }
+}
+```
+
+### 命令行工具
+
+```bash
+# 基本导出
+go run cmd/mermaid-export/main.go -input diagram.mmd -output chart.svg
+
+# 自定义尺寸
+go run cmd/mermaid-export/main.go \
+    -input diagram.mmd \
+    -width 1200 \
+    -height 800 \
+    -output chart.svg
+
+# 自定义主题
+go run cmd/mermaid-export/main.go \
+    -input diagram.mmd \
+    -theme dark \
+    -output chart.svg
+```
+
+## 📊 支持的图表类型
+
+| 图表类型 | SVG支持 | 质量 | 说明 |
+|---------|---------|------|------|
+| **Pie Chart** | ✅ 完整 | ⭐⭐⭐⭐⭐ | 基于mermaid.js实现，高质量渲染 |
+| **Organization Chart** | ✅ 完整 | ⭐⭐⭐⭐⭐ | 层次结构清晰，支持多层级 |
+| **Sequence Diagram** | ✅ 基础 | ⭐⭐⭐⭐ | 参与者和消息流 |
+| **Gantt Chart** | ✅ 基础 | ⭐⭐⭐⭐ | 项目时间线和任务 |
+| **Flowchart** | ✅ 基础 | ⭐⭐⭐ | 基本节点和连接 |
+| **Class Diagram** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **State Diagram** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **ER Diagram** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **Timeline** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **User Journey** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **Architecture** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+| **BPMN** | ⚠️ 占位符 | ⭐⭐ | 开发中 |
+
+## 🎨 导出选项
+
+### ExportOptions 结构
+
+```go
+type ExportOptions struct {
+    Format ExportFormat  // 输出格式: FormatPNG, FormatSVG, FormatJPEG
+    Width  int          // 宽度（像素）
+    Height int          // 高度（像素）
+    DPI    int          // DPI（仅PNG）
+    Theme  string       // 主题（仅SVG）
+}
+```
+
+### 预设选项
+
+```go
+// 默认选项
+options := exporter.DefaultExportOptions()
+
+// 高分辨率PNG
+options := &exporter.ExportOptions{
+    Format: exporter.FormatPNG,
+    Width:  1600,
+    Height: 1200,
+    DPI:    300,
+}
+
+// 大尺寸SVG
+options := &exporter.ExportOptions{
+    Format: exporter.FormatSVG,
+    Width:  1200,
+    Height: 900,
+    Theme:  "default",
+}
+```
+
+## 🛠️ API 参考
+
+### DiagramExporter
+
+```go
+// 创建导出器
+exporter := exporter.NewDiagramExporter()
+
+// 导出到字节数组
+data, err := exporter.Export(diagram, options)
+
+// 导出到文件
+err := exporter.ExportToFile(diagram, "output.png", options)
+
+// 导出到Writer
+err := exporter.ExportToWriter(diagram, writer, options)
+
+// 检查支持的格式
+formats := exporter.GetSupportedFormats()
+diagramTypes := exporter.GetSupportedDiagramTypes()
+
+// 检查兼容性
+isSupported := exporter.IsFormatSupported(exporter.FormatPNG)
+isDiagramSupported := exporter.IsDiagramTypeSupported(ast.DiagramTypePie)
+```
+
+### SVGExporter
+
+```go
+// 创建SVG导出器
+svgExporter := exporter.NewSVGExporter()
+
+// 设置选项
+svgExporter.SetSize(800, 600).SetTheme("default")
+
+// 导出SVG
+svgContent, err := svgExporter.ExportToSVG(diagram)
+```
+
+### PNGExporter
+
+```go
+// 创建PNG导出器
+pngExporter := exporter.NewPNGExporter()
+
+// 设置选项
+pngExporter.SetSize(800, 600).SetDPI(96)
+
+// 导出PNG
+pngData, err := pngExporter.ExportToPNG(diagram)
+```
+
+## 📝 使用示例
+
+### 示例1：批量导出
+
+```go
+func exportAllDiagrams() {
+    diagrams := map[string]string{
+        "pie": `pie showData
+            title Sales Data
+            "Q1" : 25
+            "Q2" : 30
+            "Q3" : 25
+            "Q4" : 20`,
+        "org": `organization
+            title Team Structure
+            CEO --> CTO
+            CEO --> CFO
+            CTO --> DevManager`,
+    }
+    
+    parser := parser.NewMermaidParser()
+    exporter := exporter.NewDiagramExporter()
+    
+    for name, input := range diagrams {
+        diagram, _ := parser.Parse(input)
+        
+        // PNG导出
+        pngOptions := &exporter.ExportOptions{
+            Format: exporter.FormatPNG,
+            Width:  800,
+            Height: 600,
+        }
+        exporter.ExportToFile(diagram, name+".png", pngOptions)
+        
+        // SVG导出
+        svgOptions := &exporter.ExportOptions{
+            Format: exporter.FormatSVG,
+            Width:  800,
+            Height: 600,
+        }
+        exporter.ExportToFile(diagram, name+".svg", svgOptions)
+    }
+}
+```
+
+### 示例2：Web服务集成
+
+```go
+func diagramHandler(w http.ResponseWriter, r *http.Request) {
+    // 从请求获取Mermaid代码
+    mermaidCode := r.FormValue("diagram")
+    format := r.FormValue("format") // png 或 svg
+    
+    // 解析图表
+    parser := parser.NewMermaidParser()
+    diagram, err := parser.Parse(mermaidCode)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusBadRequest)
+        return
+    }
+    
+    // 导出
+    exporter := exporter.NewDiagramExporter()
+    var exportFormat exporter.ExportFormat
+    var contentType string
+    
+    if format == "svg" {
+        exportFormat = exporter.FormatSVG
+        contentType = "image/svg+xml"
+    } else {
+        exportFormat = exporter.FormatPNG
+        contentType = "image/png"
+    }
+    
+    options := &exporter.ExportOptions{
+        Format: exportFormat,
+        Width:  800,
+        Height: 600,
+    }
+    
+    data, err := exporter.Export(diagram, options)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+    
+    w.Header().Set("Content-Type", contentType)
+    w.Write(data)
+}
+```
+
+### 示例3：不同尺寸导出
+
+```go
+func exportMultipleSizes(diagram ast.Diagram, baseName string) {
+    exporter := exporter.NewDiagramExporter()
+    
+    sizes := []struct{
+        name string
+        width, height int
+        dpi int
+    }{
+        {"thumbnail", 200, 150, 72},
+        {"medium", 800, 600, 96},
+        {"large", 1600, 1200, 150},
+        {"print", 2400, 1800, 300},
+    }
+    
+    for _, size := range sizes {
+        options := &exporter.ExportOptions{
+            Format: exporter.FormatPNG,
+            Width:  size.width,
+            Height: size.height,
+            DPI:    size.dpi,
+        }
+        
+        filename := fmt.Sprintf("%s_%s.png", baseName, size.name)
+        exporter.ExportToFile(diagram, filename, options)
+    }
+}
+```
+
+## 🔧 高级功能
+
+### 外部工具集成
+
+对于更高质量的输出，可以使用 `AdvancedExporter`：
+
+```go
+// 创建高级导出器
+advancedExporter := exporter.NewAdvancedExporter()
+
+// 检查可用的转换工具
+converters := advancedExporter.GetAvailableConverters()
+fmt.Printf("Available converters: %v\n", converters)
+
+// 使用外部工具导出
+err := advancedExporter.ExportWithExternalTool(diagram, "output.png", options)
+
+// 获取安装指南
+guide := advancedExporter.InstallationGuide()
+fmt.Println(guide["Inkscape"])
+```
+
+### 推荐的外部工具
+
+1. **Inkscape** - 最佳SVG到PNG转换质量
+   ```bash
+   # macOS
+   brew install inkscape
+   
+   # Ubuntu/Debian
+   sudo apt-get install inkscape
+   ```
+
+2. **ImageMagick** - 通用图像处理
+   ```bash
+   # macOS
+   brew install imagemagick
+   
+   # Ubuntu/Debian
+   sudo apt-get install imagemagick
+   ```
+
+3. **rsvg-convert** - 轻量级SVG转换
+   ```bash
+   # macOS
+   brew install librsvg
+   
+   # Ubuntu/Debian
+   sudo apt-get install librsvg2-bin
+   ```
+
+## 🎯 最佳实践
+
+### 1. 选择合适的格式
+
+- **SVG**: 矢量图形，适合网页显示和打印
+- **PNG**: 位图，适合嵌入文档和演示
+- **高DPI PNG**: 适合高分辨率显示和打印
+
+### 2. 尺寸建议
+
+```go
+// 网页显示
+options := &exporter.ExportOptions{
+    Width: 800, Height: 600, DPI: 96,
+}
+
+// 演示文稿
+options := &exporter.ExportOptions{
+    Width: 1200, Height: 900, DPI: 150,
+}
+
+// 打印质量
+options := &exporter.ExportOptions{
+    Width: 2400, Height: 1800, DPI: 300,
+}
+```
+
+### 3. 性能优化
+
+```go
+// 批量导出时重用导出器
+exporter := exporter.NewDiagramExporter()
+
+// 预设选项避免重复创建
+webOptions := &exporter.ExportOptions{
+    Format: exporter.FormatPNG,
+    Width: 800, Height: 600, DPI: 96,
+}
+
+// 并发导出（注意线程安全）
+var wg sync.WaitGroup
+for _, diagram := range diagrams {
+    wg.Add(1)
+    go func(d ast.Diagram, name string) {
+        defer wg.Done()
+        exporter.ExportToFile(d, name+".png", webOptions)
+    }(diagram, name)
+}
+wg.Wait()
+```
+
+## 🐛 故障排除
+
+### 常见问题
+
+1. **导出失败**
+   ```go
+   // 检查图表类型支持
+   if !exporter.IsDiagramTypeSupported(diagram.Type()) {
+       log.Printf("Diagram type %s may have limited support", diagram.Type())
+   }
+   
+   // 检查格式支持
+   if !exporter.IsFormatSupported(options.Format) {
+       return fmt.Errorf("Format %s not supported", options.Format)
+   }
+   ```
+
+2. **图片质量问题**
+   - 增加DPI设置
+   - 使用更大的尺寸
+   - 考虑使用SVG格式
+   - 尝试外部工具转换
+
+3. **内存使用过高**
+   - 减少图片尺寸
+   - 批量处理时控制并发数
+   - 及时释放大图片资源
+
+### 调试技巧
+
+```go
+// 启用详细日志
+import "log"
+
+// 检查导出能力
+log.Printf("Supported formats: %v", exporter.GetSupportedFormats())
+log.Printf("Supported diagrams: %v", exporter.GetSupportedDiagramTypes())
+
+// 验证图表
+if err := diagram.Validate(); err != nil {
+    log.Printf("Diagram validation warning: %v", err)
+}
+
+// 检查文件大小
+if info, err := os.Stat(outputFile); err == nil {
+    log.Printf("Output file size: %d bytes", info.Size())
+}
+```
+
+## 🔮 未来计划
+
+### 短期改进
+- [ ] 完善所有图表类型的渲染质量
+- [ ] 添加更多主题支持
+- [ ] 优化PNG渲染算法
+- [ ] 添加JPEG格式支持
+
+### 长期目标
+- [ ] 集成专业字体渲染
+- [ ] 支持动画SVG导出
+- [ ] 添加PDF格式支持
+- [ ] 云端渲染服务集成
+
+---
+
+**导出功能现在已经完全集成到mermaid-go中，为你的图表可视化需求提供了强大的支持！** 🎉

README.md

@@ -39,19 +39,27 @@ Mermaid-Go aims to provide a native Go alternative to Mermaid.js with:
 
 ### 🔄 Partially Supported
 
-#### **State Diagrams** (~30% Feature Complete)
+#### **State Diagrams** (~75% Feature Complete)
 - ✅ Basic state definitions and transitions
 - ✅ Start/end states
-- ❌ Composite states
-- ❌ Parallel states
-- ❌ State actions and guards
-
-#### **Sequence Diagrams** (~25% Feature Complete)
+- ✅ State actions (entry, exit, do)
+- ✅ Transition guards and actions
+- ✅ Notes and annotations
+- ✅ Special states (choice, fork, join, history)
+- ⚠️ Composite states (framework ready)
+- ⚠️ Parallel states (framework ready)
+
+#### **Sequence Diagrams** (~80% Feature Complete)
 - ✅ Basic actor interactions
 - ✅ Simple message flows
-- ❌ Activation boxes
-- ❌ Loops and alternatives
-- ❌ Notes and comments
+- ✅ Multiple arrow types (->, -->, ->>, -->>, -x, --x, -), --), <->)
+- ✅ Activation boxes (activate/deactivate)
+- ✅ Loops and alternatives (loop, alt, opt)
+- ✅ Parallel sections (par)
+- ✅ Notes and comments
+- ✅ Participant boxes and grouping
+- ⚠️ Complex nesting (framework ready)
+- ❌ Auto-numbering and styling
 
 ### 🚧 Planned Support
 
@@ -68,7 +76,7 @@ Mermaid-Go aims to provide a native Go alternative to Mermaid.js with:
 - **🔄 Bidirectional Conversion**: Mermaid syntax ↔ Go structs (AST) ↔ Mermaid syntax
 - **🖼️ Image Export**: High-quality SVG export with Chinese character support
 - **🏗️ Native Integration**: Easy embedding in Go applications and CLI tools
-- **📊 Broad Compatibility**: Support for 12+ diagram types with 85%+ feature completeness
+- **📊 Broad Compatibility**: Support for 24+ diagram types with intelligent auto-detection
 
 ## 🚀 Quick Start
 
@@ -78,7 +86,7 @@ Mermaid-Go aims to provide a native Go alternative to Mermaid.js with:
 go get github.com/your-org/mermaid-go
 ```
 
-### Basic Usage
+### Enhanced Usage with Auto-Detection
 
 ```go
 package main
@@ -86,35 +94,127 @@ package main
 import (
     "fmt"
     "log"
+    "mermaid-go/pkg/ast"
+    "mermaid-go/pkg/detector"
     "mermaid-go/pkg/parser"
     "mermaid-go/pkg/renderer"
 )
 
 func main() {
-    // Parse a Mermaid diagram (supports Chinese characters!)
-    input := `flowchart TD
-        开始[开始] --> 决策{是否继续}
-        决策 -->|是| 处理[处理数据]
-        决策 -->|否| 结束[结束]
-        处理 --> 结束`
-
+    // Auto-detect and parse any Mermaid diagram type
+    input := `sequenceDiagram
+        participant U as User
+        participant S as Server
+        U -> S : request
+        S --> U : response`
+
+    // Create main parser with auto-detection
     mermaidParser := parser.NewMermaidParser()
+    
+    // Detect diagram type
+    diagramType := mermaidParser.GetDiagramType(input)
+    fmt.Printf("Detected diagram type: %s\n", diagramType)
+    
+    // Parse the diagram
     diagram, err := mermaidParser.Parse(input)
     if err != nil {
         log.Fatal(err)
     }
 
     // Render back to Mermaid syntax
-    mermaidRenderer := renderer.NewMermaidRenderer()
-    output, err := mermaidRenderer.Render(diagram)
-    if err != nil {
-        log.Fatal(err)
+    switch d := diagram.(type) {
+    case *ast.SequenceDiagram:
+        renderer := renderer.NewSequenceRenderer()
+        output, _ := renderer.Render(d)
+        fmt.Println(output)
+    case *ast.StateDiagram:
+        renderer := renderer.NewStateRenderer()
+        output, _ := renderer.Render(d)
+        fmt.Println(output)
+    // ... handle other diagram types
     }
-
-    fmt.Println(output)
 }
 ```
 
+### Enhanced Sequence Diagrams
+
+```go
+// Parse a complex sequence diagram with loops, alternatives, and parallel sections
+input := `
+sequenceDiagram
+    participant U as User
+    participant W as WebApp
+    participant S as Server
+    participant D as Database
+    
+    U -> W : login request
+    activate W
+    
+    loop Authentication
+        W -> S : validate credentials
+        S -> D : query user
+        D --> S : user data
+    end
+    
+    alt Valid credentials
+        S --> W : success
+        W --> U : login complete
+    else Invalid credentials
+        S --> W : failure
+        W --> U : login failed
+    end
+    
+    par User actions
+        U -> W : browse content
+    and Background tasks
+        S -> D : cleanup sessions
+    end
+    
+    deactivate W
+    `
+    
+parser := parser.NewSequenceParser()
+diagram, err := parser.Parse(input)
+// ... rest of the code
+```
+
+### Enhanced State Diagrams
+
+```go
+// Parse a state diagram with guards, actions, and notes
+input := `
+stateDiagram-v2
+    [*] --> Idle
+    Idle --> Processing : start [hasData] / processData
+    Processing --> Idle : complete [success] / cleanup
+    Processing --> Error : fail [error] / logError
+    
+    note right of Processing : Main processing state
+    note left of Error : Error handling
+    `
+    
+parser := parser.NewStateParser()
+diagram, err := parser.Parse(input)
+// ... rest of the code
+```
+
+## 🎯 Recent Enhancements
+
+### 🧠 Intelligent Diagram Type Detection
+- **Auto-Detection**: Automatically detects 24+ diagram types from input text
+- **Priority-Based**: More specific patterns detected first (e.g., `stateDiagram-v2` before `stateDiagram`)
+- **Robust Parsing**: Handles comments, directives, and front matter
+
+### 🔧 Enhanced Lexical Analysis
+- **Rich Arrow Support**: 20+ arrow types including bidirectional, dotted, crossed, and directional markers
+- **Special State Handling**: Proper recognition of complex diagram declarations
+- **Mermaid.js Compatibility**: Follows official mermaidjs lexical patterns
+
+### 🏗️ Modular Architecture
+- **Detector Registry**: Extensible system for adding new diagram types
+- **Parser Router**: Centralized parsing with type-specific handlers
+- **Clean Separation**: Lexical analysis, parsing, and rendering are fully decoupled
+
 ### Chinese Character Support
 
 mermaid-go fully supports Unicode characters including Chinese, Japanese, and Korean:

examples/enhanced_features_demo.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"mermaid-go/pkg/ast"
+	"mermaid-go/pkg/detector"
+	"mermaid-go/pkg/parser"
+	"mermaid-go/pkg/renderer"
+)
+
+func main() {
+	fmt.Println("🎯 mermaid-go 增强功能演示")
+	fmt.Println("================================")
+
+	// 创建主解析器
+	mermaidParser := parser.NewMermaidParser()
+
+	// 演示序列图检测和解析
+	fmt.Println("\n📊 序列图检测和解析:")
+	sequenceInput := `sequenceDiagram
+    participant U as User
+    participant W as WebApp
+    participant S as Server
+    
+    U -> W : login request
+    activate W
+    W -> S : validate credentials
+    S --> W : success
+    W --> U : login complete
+    deactivate W`
+
+	// 检测图表类型
+	diagramType := mermaidParser.GetDiagramType(sequenceInput)
+	fmt.Printf("检测到的图表类型: %s\n", diagramType)
+
+	// 解析序列图
+	sequenceDiagram, err := mermaidParser.Parse(sequenceInput)
+	if err != nil {
+		log.Fatalf("解析序列图失败: %v", err)
+	}
+
+	fmt.Printf("解析成功! 图表类型: %s\n", sequenceDiagram.Type())
+
+	// 渲染回 mermaid 语法
+	sequenceRenderer := renderer.NewSequenceRenderer()
+	sequenceOutput, err := sequenceRenderer.Render(sequenceDiagram.(*ast.SequenceDiagram))
+	if err != nil {
+		log.Fatalf("渲染序列图失败: %v", err)
+	}
+	fmt.Printf("渲染结果:\n%s\n", sequenceOutput)
+
+	// 演示状态图检测和解析
+	fmt.Println("\n🔄 状态图检测和解析:")
+	stateInput := `stateDiagram-v2
+    [*] --> Idle
+    Idle --> Processing : start [hasData] / processData
+    Processing --> Idle : complete [success] / cleanup
+    Processing --> Error : fail [error] / logError
+    
+    note right of Processing : Main processing state
+    note left of Error : Error handling`
+
+	// 检测图表类型
+	stateDiagramType := mermaidParser.GetDiagramType(stateInput)
+	fmt.Printf("检测到的图表类型: %s\n", stateDiagramType)
+
+	// 解析状态图
+	stateDiagram, err := mermaidParser.Parse(stateInput)
+	if err != nil {
+		log.Fatalf("解析状态图失败: %v", err)
+	}
+
+	fmt.Printf("解析成功! 图表类型: %s\n", stateDiagram.Type())
+
+	// 渲染回 mermaid 语法
+	stateRenderer := renderer.NewStateRenderer()
+	stateOutput, err := stateRenderer.Render(stateDiagram.(*ast.StateDiagram))
+	if err != nil {
+		log.Fatalf("渲染状态图失败: %v", err)
+	}
+	fmt.Printf("渲染结果:\n%s\n", stateOutput)
+
+	// 演示图表类型检测器
+	fmt.Println("\n🔍 图表类型检测器演示:")
+	testInputs := []struct {
+		name  string
+		input string
+	}{
+		{"序列图", "sequenceDiagram\n    A -> B : hello"},
+		{"状态图 V2", "stateDiagram-v2\n    [*] --> State1"},
+		{"状态图", "stateDiagram\n    [*] --> State1"},
+		{"流程图", "flowchart TD\n    A --> B"},
+		{"类图", "classDiagram\n    class Animal"},
+		{"ER图", "erDiagram\n    CUSTOMER ||--o{ ORDER"},
+		{"甘特图", "gantt\n    title A Gantt Diagram"},
+		{"饼图", "pie\n    title Pets adopted by volunteers"},
+		{"Git图", "gitGraph\n    commit"},
+		{"用户旅程", "journey\n    title My working day"},
+		{"时间线", "timeline\n    title History of Social Media Platform"},
+		{"思维导图", "mindmap\n  root((mindmap))"},
+		{"看板图", "kanban\n    title Kanban Example"},
+		{"桑基图", "sankey-beta\n    A --> B"},
+		{"XY图", "xychart-beta\n    title Sales Revenue"},
+		{"象限图", "quadrantChart\n    title Reach and engagement of campaigns"},
+		{"需求图", "requirement\n    requirement Test"},
+		{"块图", "block-beta\n    A"},
+		{"C4图", "c4Context\n    title System Context diagram for Internet Banking System"},
+		{"架构图", "architecture\n    title Architecture diagram"},
+		{"雷达图", "radar\n    title Simple Radar Chart"},
+		{"树状图", "treemap\n    title Tree Map Example"},
+		{"包图", "packet\n    title Packet Diagram"},
+		{"信息图", "info\n    title Info Diagram"},
+	}
+
+	detectorRegistry := detector.NewDetectorRegistry()
+	for _, test := range testInputs {
+		detectedType := detectorRegistry.DetectDiagramType(test.input)
+		fmt.Printf("  %-12s: %s\n", test.name, detectedType)
+	}
+
+	fmt.Println("\n✅ 演示完成!")
+	fmt.Println("\n🎉 mermaid-go 现在支持:")
+	fmt.Println("  • 智能图表类型检测 (24种图表类型)")
+	fmt.Println("  • 增强的序列图解析 (循环、条件、并行、激活框)")
+	fmt.Println("  • 增强的状态图解析 (守卫、动作、注释)")
+	fmt.Println("  • 丰富的箭头类型支持")
+	fmt.Println("  • 模块化的解析器架构")
+	fmt.Println("  • 完整的往返转换 (解析→渲染)")
+}

output/chinese_pie_test.svg

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 712 450" width="712" height="450" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.pieOuterCircle { fill: none; stroke: #333; stroke-width: 2; }
+.pieCircle { stroke: #fff; stroke-width: 2; }
+.slice { font-family: Arial, sans-serif; font-size: 14px; fill: #fff; font-weight: bold; }
+.pieTitleText { font-family: Arial, sans-serif; font-size: 20px; font-weight: bold; fill: #333; }
+.legend { font-family: Arial, sans-serif; font-size: 14px; fill: #333; }
+</style><g transform="translate(225,225)"><circle cx="0" cy="0" r="186" class="pieOuterCircle"/><path d="M 0 0 L 185 0 A 185 185 0 0 1 -175.9454555146034 57.16814395936529 Z" fill="#ff6b6b" class="pieCircle"/><text x="20.258263222709903" y="127.90564010707033" text-anchor="middle" class="slice">45%</text><path d="M 0 0 L -175.9454555146034 57.16814395936529 A 185 185 0 0 1 -3.3983948676339004e-14 -185 Z" fill="#4ecdc4" class="pieCircle"/><text x="-104.7677007715557" y="-76.11819017187526" text-anchor="middle" class="slice">30%</text><path d="M 0 0 L -3.3983948676339004e-14 -185 A 185 185 0 0 1 149.66814395936527 -108.74027167410755 Z" fill="#45b7d1" class="pieCircle"/><text x="58.79176971627129" y="-115.38534488239364" text-anchor="middle" class="slice">15%</text><path d="M 0 0 L 149.66814395936527 -108.74027167410755 A 185 185 0 0 1 185 -4.5311931568452005e-14 Z" fill="#96ceb4" class="pieCircle"/><text x="123.16181886022238" y="-40.01770077155572" text-anchor="middle" class="slice">10%</text></g><text x="400" y="25" text-anchor="middle" class="pieTitleText">2024 年市场份额分析</text><rect x="490" y="172" width="18" height="18" fill="#ff6b6b" stroke="#ff6b6b"/><text x="512" y="186" class="legend">苹果公司 [45]</text><rect x="490" y="194" width="18" height="18" fill="#4ecdc4" stroke="#4ecdc4"/><text x="512" y="208" class="legend">谷歌公司 [30]</text><rect x="490" y="216" width="18" height="18" fill="#45b7d1" stroke="#45b7d1"/><text x="512" y="230" class="legend">微软公司 [15]</text><rect x="490" y="238" width="18" height="18" fill="#96ceb4" stroke="#96ceb4"/><text x="512" y="252" class="legend">其他公司 [10]</text></svg>

output/gantt.svg

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 800 600" width="800" height="600" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.taskBar { fill: #4ecdc4; stroke: #26a69a; stroke-width: 1; }
+.taskText { font-family: Arial, sans-serif; font-size: 12px; fill: #333; }
+.sectionText { font-family: Arial, sans-serif; font-size: 14px; font-weight: bold; fill: #333; }
+.title { font-family: Arial, sans-serif; font-size: 18px; font-weight: bold; fill: #333; }
+</style><text x="400" y="30" text-anchor="middle" class="title">Project Timeline</text><text x="20" y="80" class="sectionText">Planning</text><rect x="50" y="100" width="200" height="20" class="taskBar"/><text x="260" y="115" class="taskText">Requirements</text><rect x="50" y="135" width="200" height="20" class="taskBar"/><text x="260" y="150" class="taskText">Design</text><text x="20" y="195" class="sectionText">Development</text><rect x="50" y="215" width="200" height="20" class="taskBar"/><text x="260" y="230" class="taskText">Backend</text><rect x="50" y="250" width="200" height="20" class="taskBar"/><text x="260" y="265" class="taskText">Frontend</text></svg>

output/large_pie.svg

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 712 450" width="712" height="450" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.pieOuterCircle { fill: none; stroke: #333; stroke-width: 2; }
+.pieCircle { stroke: #fff; stroke-width: 2; }
+.slice { font-family: Arial, sans-serif; font-size: 14px; fill: #fff; font-weight: bold; }
+.pieTitleText { font-family: Arial, sans-serif; font-size: 20px; font-weight: bold; fill: #333; }
+.legend { font-family: Arial, sans-serif; font-size: 14px; fill: #333; }
+</style><g transform="translate(225,225)"><circle cx="0" cy="0" r="186" class="pieOuterCircle"/><path d="M 0 0 L 185 0 A 185 185 0 0 1 -149.66814395936527 108.74027167410755 Z" fill="#ff6b6b" class="pieCircle"/><text x="40.017700771555695" y="123.16181886022238" text-anchor="middle" class="slice">40%</text><path d="M 0 0 L -149.66814395936527 108.74027167410755 A 185 185 0 0 1 -3.3983948676339004e-14 -185 Z" fill="#4ecdc4" class="pieCircle"/><text x="-115.38534488239364" y="-58.7917697162713" text-anchor="middle" class="slice">35%</text><path d="M 0 0 L -3.3983948676339004e-14 -185 A 185 185 0 0 1 185 -4.5311931568452005e-14 Z" fill="#45b7d1" class="pieCircle"/><text x="91.57032816365789" y="-91.57032816365792" text-anchor="middle" class="slice">25%</text></g><text x="800" y="25" text-anchor="middle" class="pieTitleText">Large Size Export</text><rect x="490" y="183" width="18" height="18" fill="#ff6b6b" stroke="#ff6b6b"/><text x="512" y="197" class="legend">Data A [40]</text><rect x="490" y="205" width="18" height="18" fill="#4ecdc4" stroke="#4ecdc4"/><text x="512" y="219" class="legend">Data B [35]</text><rect x="490" y="227" width="18" height="18" fill="#45b7d1" stroke="#45b7d1"/><text x="512" y="241" class="legend">Data C [25]</text></svg>

output/org_chart.svg

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 800 600" width="800" height="600" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.orgNode { fill: #e3f2fd; stroke: #1976d2; stroke-width: 2; }
+.orgText { font-family: Arial, sans-serif; font-size: 12px; fill: #333; text-anchor: middle; }
+.orgEdge { stroke: #1976d2; stroke-width: 2; }
+.title { font-family: Arial, sans-serif; font-size: 18px; font-weight: bold; fill: #333; }
+</style>
+<g transform="translate(400,80)">
+  <rect x="-80" y="-25" width="160" height="50" class="orgNode"/>
+  <text x="0" y="5" class="orgText">Chief Executive Officer</text>
+</g><text x="400" y="30" text-anchor="middle" class="title">Company Structure</text></svg>

output/pie_chart.svg

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 712 450" width="712" height="450" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.pieOuterCircle { fill: none; stroke: #333; stroke-width: 2; }
+.pieCircle { stroke: #fff; stroke-width: 2; }
+.slice { font-family: Arial, sans-serif; font-size: 14px; fill: #fff; font-weight: bold; }
+.pieTitleText { font-family: Arial, sans-serif; font-size: 20px; font-weight: bold; fill: #333; }
+.legend { font-family: Arial, sans-serif; font-size: 14px; fill: #333; }
+</style><g transform="translate(225,225)"><circle cx="0" cy="0" r="186" class="pieOuterCircle"/><path d="M 0 0 L 185 0 A 185 185 0 0 1 -175.9454555146034 57.16814395936529 Z" fill="#ff6b6b" class="pieCircle"/><text x="20.258263222709903" y="127.90564010707033" text-anchor="middle" class="slice">45%</text><path d="M 0 0 L -175.9454555146034 57.16814395936529 A 185 185 0 0 1 -3.3983948676339004e-14 -185 Z" fill="#4ecdc4" class="pieCircle"/><text x="-104.7677007715557" y="-76.11819017187526" text-anchor="middle" class="slice">30%</text><path d="M 0 0 L -3.3983948676339004e-14 -185 A 185 185 0 0 1 149.66814395936527 -108.74027167410755 Z" fill="#45b7d1" class="pieCircle"/><text x="58.79176971627129" y="-115.38534488239364" text-anchor="middle" class="slice">15%</text><path d="M 0 0 L 149.66814395936527 -108.74027167410755 A 185 185 0 0 1 185 -4.5311931568452005e-14 Z" fill="#96ceb4" class="pieCircle"/><text x="123.16181886022238" y="-40.01770077155572" text-anchor="middle" class="slice">10%</text></g><text x="400" y="25" text-anchor="middle" class="pieTitleText">Market Share 2024</text><rect x="490" y="172" width="18" height="18" fill="#ff6b6b" stroke="#ff6b6b"/><text x="512" y="186" class="legend">Company A [45]</text><rect x="490" y="194" width="18" height="18" fill="#4ecdc4" stroke="#4ecdc4"/><text x="512" y="208" class="legend">Company B [30]</text><rect x="490" y="216" width="18" height="18" fill="#45b7d1" stroke="#45b7d1"/><text x="512" y="230" class="legend">Company C [15]</text><rect x="490" y="238" width="18" height="18" fill="#96ceb4" stroke="#96ceb4"/><text x="512" y="252" class="legend">Others [10]</text></svg>

output/sequence.svg

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg viewBox="0 0 800 600" width="800" height="600" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs>
+
+<marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#333"/>
+</marker>
+<marker id="arrowheadWhite" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+  <polygon points="0 0, 10 3.5, 0 7" fill="#fff"/>
+</marker>
+</defs>
+<style>
+.participant { fill: #e3f2fd; stroke: #1976d2; stroke-width: 2; }
+.participantText { font-family: Arial, sans-serif; font-size: 12px; fill: #333; }
+.lifeline { stroke: #ccc; stroke-width: 1; stroke-dasharray: 5,5; }
+.messageArrow { stroke: #333; stroke-width: 2; }
+.messageText { font-family: Arial, sans-serif; font-size: 11px; fill: #333; }
+</style><rect x="206" y="40" width="120" height="40" class="participant"/><text x="266" y="65" text-anchor="middle" class="participantText">User</text><line x1="266" y1="80" x2="266" y2="550" class="lifeline"/><rect x="472" y="40" width="120" height="40" class="participant"/><text x="532" y="65" text-anchor="middle" class="participantText">System</text><line x1="532" y1="80" x2="532" y2="550" class="lifeline"/><line x1="266" y1="120" x2="532" y2="120" class="messageArrow" marker-end="url(#arrowhead)"/><text x="399" y="115" text-anchor="middle" class="messageText">Login Request</text><line x1="532" y1="170" x2="266" y2="170" class="messageArrow" marker-end="url(#arrowhead)"/><text x="399" y="165" text-anchor="middle" class="messageText">Login Response</text><line x1="266" y1="220" x2="532" y2="220" class="messageArrow" marker-end="url(#arrowhead)"/><text x="399" y="215" text-anchor="middle" class="messageText">Data Request</text><line x1="532" y1="270" x2="266" y2="270" class="messageArrow" marker-end="url(#arrowhead)"/><text x="399" y="265" text-anchor="middle" class="messageText">Data Response</text></svg>

pkg/ast/flowchart.go

@@ -7,9 +7,9 @@ type DiagramType string
 
 const (
 	DiagramTypeFlowchart    DiagramType = "flowchart"
-	DiagramTypeSequence     DiagramType = "sequenceDiagram"
+	DiagramTypeSequence     DiagramType = "sequence"
 	DiagramTypeClassDiagram DiagramType = "classDiagram"
-	DiagramTypeStateDiagram DiagramType = "stateDiagram"
+	DiagramTypeStateDiagram DiagramType = "state"
 	DiagramTypeERDiagram    DiagramType = "erDiagram"
 	DiagramTypeUserJourney  DiagramType = "journey"
 	DiagramTypeTimeline     DiagramType = "timeline"

pkg/ast/other_diagrams.go

@@ -3,10 +3,10 @@ package ast
 
 // ERDiagram represents an entity relationship diagram
 type ERDiagram struct {
-	Entities  map[string]*EREntity `json:"entities"`
-	Relations []*ERRelation        `json:"relations"`
-	Title     *string              `json:"title,omitempty"`
-	Config    map[string]any       `json:"config,omitempty"`
+	Entities  []*EREntity    `json:"entities"`
+	Relations []*ERRelation  `json:"relations"`
+	Title     *string        `json:"title,omitempty"`
+	Config    map[string]any `json:"config,omitempty"`
 }
 
 type EREntity struct {
@@ -42,12 +42,14 @@ type ERRelation struct {
 type ERRelationType string
 
 const (
-	ERRelationOneToOne   ERRelationType = "||--||"
-	ERRelationOneToMany  ERRelationType = "||--o{"
-	ERRelationManyToOne  ERRelationType = "}o--||"
-	ERRelationManyToMany ERRelationType = "}o--o{"
-	ERRelationZeroToOne  ERRelationType = "||--o|"
-	ERRelationZeroToMany ERRelationType = "||--o{"
+	ERRelationOneToOne      ERRelationType = "||--||"
+	ERRelationOneToMany     ERRelationType = "||--o{"
+	ERRelationOneToManyAlt  ERRelationType = "||--|{"
+	ERRelationManyToOne     ERRelationType = "}o--||"
+	ERRelationManyToMany    ERRelationType = "}o--o{"
+	ERRelationManyToManyAlt ERRelationType = "}|..|{"
+	ERRelationZeroToOne     ERRelationType = "||--o|"
+	ERRelationZeroToMany    ERRelationType = "||--o{"
 )
 
 type ERCardinality struct {
@@ -258,7 +260,7 @@ func (r *RequirementDiagram) Validate() error   { return nil }
 // Constructor functions
 func NewERDiagram() *ERDiagram {
 	return &ERDiagram{
-		Entities:  make(map[string]*EREntity),
+		Entities:  make([]*EREntity, 0),
 		Relations: make([]*ERRelation, 0),
 		Config:    make(map[string]any),
 	}

pkg/ast/sequence.go

@@ -12,6 +12,9 @@ type SequenceDiagram struct {
 	Pars         []*SequencePar         `json:"pars"`
 	Notes        []*SequenceNote        `json:"notes"`
 	Boxes        []*SequenceBox         `json:"boxes"`
+	Rects        []*SequenceRect        `json:"rects,omitempty"`
+	Criticals    []*SequenceCritical    `json:"criticals,omitempty"`
+	Breaks       []*SequenceBreak       `json:"breaks,omitempty"`
 	Activations  []*SequenceActivation  `json:"activations"`
 	Title        *string                `json:"title,omitempty"`
 	Config       map[string]any         `json:"config,omitempty"`
@@ -120,6 +123,27 @@ const (
 	ActivationTypeDeactivate ActivationType = "deactivate"
 )
 
+type SequenceRect struct {
+	Color    *string            `json:"color,omitempty"`
+	Messages []*SequenceMessage `json:"messages"`
+}
+
+type SequenceCritical struct {
+	Label    string             `json:"label"`
+	Options  []*SequenceOption  `json:"options"`
+	Messages []*SequenceMessage `json:"messages"`
+}
+
+type SequenceOption struct {
+	Label    string             `json:"label"`
+	Messages []*SequenceMessage `json:"messages"`
+}
+
+type SequenceBreak struct {
+	Label    string             `json:"label"`
+	Messages []*SequenceMessage `json:"messages"`
+}
+
 // Type returns the diagram type
 func (s *SequenceDiagram) Type() DiagramType {
 	return DiagramTypeSequence
@@ -156,6 +180,9 @@ func NewSequenceDiagram() *SequenceDiagram {
 		Pars:         make([]*SequencePar, 0),
 		Notes:        make([]*SequenceNote, 0),
 		Boxes:        make([]*SequenceBox, 0),
+		Rects:        make([]*SequenceRect, 0),
+		Criticals:    make([]*SequenceCritical, 0),
+		Breaks:       make([]*SequenceBreak, 0),
 		Activations:  make([]*SequenceActivation, 0),
 		Config:       make(map[string]any),
 	}

pkg/ast/state.go

@@ -20,6 +20,12 @@ type StateNode struct {
 	SubStates   map[string]*StateNode `json:"subStates,omitempty"`
 	Note        *StateNote            `json:"note,omitempty"`
 	CssClasses  []string              `json:"cssClasses,omitempty"`
+	// State actions and behaviors
+	EntryAction *string `json:"entry,omitempty"` // entry / action
+	ExitAction  *string `json:"exit,omitempty"`  // exit / action
+	DoAction    *string `json:"do,omitempty"`    // do / action
+	// Parallel regions (for concurrent states)
+	Regions []*StateRegion `json:"regions,omitempty"`
 }
 
 type StateType string
@@ -39,8 +45,8 @@ type StateTransition struct {
 	From      string  `json:"from"`
 	To        string  `json:"to"`
 	Label     *string `json:"label,omitempty"`
-	Condition *string `json:"condition,omitempty"`
-	Action    *string `json:"action,omitempty"`
+	Condition *string `json:"condition,omitempty"` // [guard]
+	Action    *string `json:"action,omitempty"`    // /action
 }
 
 type StateNote struct {
@@ -48,6 +54,13 @@ type StateNote struct {
 	Text     string    `json:"text"`
 }
 
+// StateRegion represents a parallel region in a composite state
+type StateRegion struct {
+	Name        string                `json:"name"`
+	States      map[string]*StateNode `json:"states"`
+	Transitions []*StateTransition    `json:"transitions,omitempty"`
+}
+
 // Type returns the diagram type
 func (s *StateDiagram) Type() DiagramType {
 	return DiagramTypeStateDiagram

pkg/detector/detector.go

@@ -0,0 +1,410 @@
+package detector
+
+import (
+	"regexp"
+	"strings"
+)
+
+// DiagramType represents the type of diagram
+type DiagramType string
+
+const (
+	DiagramTypeUnknown      DiagramType = "unknown"
+	DiagramTypeSequence     DiagramType = "sequence"
+	DiagramTypeState        DiagramType = "state"
+	DiagramTypeStateV2      DiagramType = "state-v2"
+	DiagramTypeFlowchart    DiagramType = "flowchart"
+	DiagramTypeClass        DiagramType = "class"
+	DiagramTypeER           DiagramType = "er"
+	DiagramTypeGantt        DiagramType = "gantt"
+	DiagramTypePie          DiagramType = "pie"
+	DiagramTypeGit          DiagramType = "git"
+	DiagramTypeUserJourney  DiagramType = "user-journey"
+	DiagramTypeTimeline     DiagramType = "timeline"
+	DiagramTypeMindmap      DiagramType = "mindmap"
+	DiagramTypeKanban       DiagramType = "kanban"
+	DiagramTypeSankey       DiagramType = "sankey"
+	DiagramTypeXYChart      DiagramType = "xychart"
+	DiagramTypeQuadrant     DiagramType = "quadrant-chart"
+	DiagramTypeRequirement  DiagramType = "requirement"
+	DiagramTypeBlock        DiagramType = "block"
+	DiagramTypeC4           DiagramType = "c4"
+	DiagramTypeArchitecture DiagramType = "architecture"
+	DiagramTypeRadar        DiagramType = "radar"
+	DiagramTypeTreemap      DiagramType = "treemap"
+	DiagramTypePacket       DiagramType = "packet"
+	DiagramTypeInfo         DiagramType = "info"
+)
+
+// DetectorFunc is a function that detects if text matches a specific diagram type
+type DetectorFunc func(text string) bool
+
+// DiagramDetector represents a diagram detector with its type and detection function
+type DiagramDetector struct {
+	Type     DiagramType
+	Detector DetectorFunc
+	Priority int // Higher priority = checked first
+}
+
+// DetectorRegistry manages all diagram detectors
+type DetectorRegistry struct {
+	detectors []DiagramDetector
+}
+
+// NewDetectorRegistry creates a new detector registry with default detectors
+func NewDetectorRegistry() *DetectorRegistry {
+	registry := &DetectorRegistry{
+		detectors: make([]DiagramDetector, 0),
+	}
+
+	// Register default detectors in order of specificity (most specific first)
+	registry.Register(sequenceDetector())
+	registry.Register(stateV2Detector())
+	registry.Register(stateDetector())
+	registry.Register(flowchartDetector())
+	registry.Register(classDetector())
+	registry.Register(erDetector())
+	registry.Register(ganttDetector())
+	registry.Register(pieDetector())
+	registry.Register(gitDetector())
+	registry.Register(userJourneyDetector())
+	registry.Register(timelineDetector())
+	registry.Register(mindmapDetector())
+	registry.Register(kanbanDetector())
+	registry.Register(sankeyDetector())
+	registry.Register(xyChartDetector())
+	registry.Register(quadrantDetector())
+	registry.Register(requirementDetector())
+	registry.Register(blockDetector())
+	registry.Register(c4Detector())
+	registry.Register(architectureDetector())
+	registry.Register(radarDetector())
+	registry.Register(treemapDetector())
+	registry.Register(packetDetector())
+	registry.Register(infoDetector())
+
+	return registry
+}
+
+// Register adds a diagram detector to the registry
+func (r *DetectorRegistry) Register(detector DiagramDetector) {
+	r.detectors = append(r.detectors, detector)
+	// Sort by priority (higher first)
+	for i := len(r.detectors) - 1; i > 0; i-- {
+		if r.detectors[i].Priority > r.detectors[i-1].Priority {
+			r.detectors[i], r.detectors[i-1] = r.detectors[i-1], r.detectors[i]
+		} else {
+			break
+		}
+	}
+}
+
+// DetectDiagramType detects the type of diagram from the given text
+func (r *DetectorRegistry) DetectDiagramType(text string) DiagramType {
+	// Clean the text by removing comments and directives
+	cleanText := cleanText(text)
+
+	for _, detector := range r.detectors {
+		if detector.Detector(cleanText) {
+			return detector.Type
+		}
+	}
+
+	return DiagramTypeUnknown
+}
+
+// cleanText removes comments, directives, and front matter from text
+func cleanText(text string) string {
+	// Remove front matter (YAML between --- markers)
+	frontMatterRegex := regexp.MustCompile(`(?s)^---\s*\n(.*?)\n---\s*\n+`)
+	text = frontMatterRegex.ReplaceAllString(text, "")
+
+	// Remove directives (%%{...}%%)
+	directiveRegex := regexp.MustCompile(`%%\{[^}]*\}%%`)
+	text = directiveRegex.ReplaceAllString(text, "")
+
+	// Remove comments (%% ...) - this will leave empty lines
+	commentRegex := regexp.MustCompile(`(?m)^\s*%%.*$`)
+	text = commentRegex.ReplaceAllString(text, "")
+
+	// Remove multiple consecutive newlines and normalize whitespace
+	text = regexp.MustCompile(`\n\s*\n+`).ReplaceAllString(text, "\n")
+
+	// Remove leading/trailing whitespace from each line
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lines[i] = strings.TrimRight(line, " \t")
+	}
+	text = strings.Join(lines, "\n")
+
+	// Remove leading/trailing whitespace from entire text
+	text = strings.TrimSpace(text)
+
+	return text
+}
+
+// Individual detector functions
+
+func sequenceDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeSequence,
+		Priority: 100,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*sequenceDiagram`, text)
+			return matched
+		},
+	}
+}
+
+func stateV2Detector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeStateV2,
+		Priority: 95,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*stateDiagram-v2`, text)
+			return matched
+		},
+	}
+}
+
+func stateDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeState,
+		Priority: 90,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*stateDiagram`, text)
+			return matched
+		},
+	}
+}
+
+func flowchartDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeFlowchart,
+		Priority: 85,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*(?:flowchart|graph)`, text)
+			return matched
+		},
+	}
+}
+
+func classDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeClass,
+		Priority: 80,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*classDiagram`, text)
+			return matched
+		},
+	}
+}
+
+func erDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeER,
+		Priority: 75,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*erDiagram`, text)
+			return matched
+		},
+	}
+}
+
+func ganttDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeGantt,
+		Priority: 70,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*gantt`, text)
+			return matched
+		},
+	}
+}
+
+func pieDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypePie,
+		Priority: 65,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*pie`, text)
+			return matched
+		},
+	}
+}
+
+func gitDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeGit,
+		Priority: 60,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*gitGraph`, text)
+			return matched
+		},
+	}
+}
+
+func userJourneyDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeUserJourney,
+		Priority: 55,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*journey`, text)
+			return matched
+		},
+	}
+}
+
+func timelineDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeTimeline,
+		Priority: 50,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*timeline`, text)
+			return matched
+		},
+	}
+}
+
+func mindmapDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeMindmap,
+		Priority: 45,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*mindmap`, text)
+			return matched
+		},
+	}
+}
+
+func kanbanDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeKanban,
+		Priority: 40,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*kanban`, text)
+			return matched
+		},
+	}
+}
+
+func sankeyDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeSankey,
+		Priority: 35,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*sankey-beta`, text)
+			return matched
+		},
+	}
+}
+
+func xyChartDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeXYChart,
+		Priority: 30,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*xychart-beta`, text)
+			return matched
+		},
+	}
+}
+
+func quadrantDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeQuadrant,
+		Priority: 25,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*quadrantChart`, text)
+			return matched
+		},
+	}
+}
+
+func requirementDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeRequirement,
+		Priority: 20,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*requirement`, text)
+			return matched
+		},
+	}
+}
+
+func blockDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeBlock,
+		Priority: 15,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*block-beta`, text)
+			return matched
+		},
+	}
+}
+
+func c4Detector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeC4,
+		Priority: 10,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*c4Context`, text)
+			return matched
+		},
+	}
+}
+
+func architectureDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeArchitecture,
+		Priority: 5,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*architecture`, text)
+			return matched
+		},
+	}
+}
+
+func radarDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeRadar,
+		Priority: 3,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*radar`, text)
+			return matched
+		},
+	}
+}
+
+func treemapDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeTreemap,
+		Priority: 2,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*treemap`, text)
+			return matched
+		},
+	}
+}
+
+func packetDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypePacket,
+		Priority: 1,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*packet`, text)
+			return matched
+		},
+	}
+}
+
+func infoDetector() DiagramDetector {
+	return DiagramDetector{
+		Type:     DiagramTypeInfo,
+		Priority: 0,
+		Detector: func(text string) bool {
+			matched, _ := regexp.MatchString(`(?i)^\s*info`, text)
+			return matched
+		},
+	}
+}

pkg/detector/detector_test.go

@@ -0,0 +1,246 @@
+package detector
+
+import (
+	"testing"
+)
+
+func TestDetectDiagramType(t *testing.T) {
+	registry := NewDetectorRegistry()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected DiagramType
+	}{
+		{
+			name:     "Sequence Diagram",
+			input:    "sequenceDiagram\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+		{
+			name:     "State Diagram V2",
+			input:    "stateDiagram-v2\n    [*] --> State1",
+			expected: DiagramTypeStateV2,
+		},
+		{
+			name:     "State Diagram",
+			input:    "stateDiagram\n    [*] --> State1",
+			expected: DiagramTypeState,
+		},
+		{
+			name:     "Flowchart",
+			input:    "flowchart TD\n    A --> B",
+			expected: DiagramTypeFlowchart,
+		},
+		{
+			name:     "Graph (alias for flowchart)",
+			input:    "graph TD\n    A --> B",
+			expected: DiagramTypeFlowchart,
+		},
+		{
+			name:     "Class Diagram",
+			input:    "classDiagram\n    class Animal",
+			expected: DiagramTypeClass,
+		},
+		{
+			name:     "ER Diagram",
+			input:    "erDiagram\n    CUSTOMER ||--o{ ORDER",
+			expected: DiagramTypeER,
+		},
+		{
+			name:     "Gantt Chart",
+			input:    "gantt\n    title A Gantt Diagram",
+			expected: DiagramTypeGantt,
+		},
+		{
+			name:     "Pie Chart",
+			input:    "pie\n    title Pets adopted by volunteers",
+			expected: DiagramTypePie,
+		},
+		{
+			name:     "Git Graph",
+			input:    "gitGraph\n    commit",
+			expected: DiagramTypeGit,
+		},
+		{
+			name:     "User Journey",
+			input:    "journey\n    title My working day",
+			expected: DiagramTypeUserJourney,
+		},
+		{
+			name:     "Timeline",
+			input:    "timeline\n    title History of Social Media Platform",
+			expected: DiagramTypeTimeline,
+		},
+		{
+			name:     "Mindmap",
+			input:    "mindmap\n  root((mindmap))",
+			expected: DiagramTypeMindmap,
+		},
+		{
+			name:     "Kanban",
+			input:    "kanban\n    title Kanban Example",
+			expected: DiagramTypeKanban,
+		},
+		{
+			name:     "Sankey Diagram",
+			input:    "sankey-beta\n    A --> B",
+			expected: DiagramTypeSankey,
+		},
+		{
+			name:     "XY Chart",
+			input:    "xychart-beta\n    title Sales Revenue",
+			expected: DiagramTypeXYChart,
+		},
+		{
+			name:     "Quadrant Chart",
+			input:    "quadrantChart\n    title Reach and engagement of campaigns",
+			expected: DiagramTypeQuadrant,
+		},
+		{
+			name:     "Requirement Diagram",
+			input:    "requirement\n    requirement Test",
+			expected: DiagramTypeRequirement,
+		},
+		{
+			name:     "Block Diagram",
+			input:    "block-beta\n    A",
+			expected: DiagramTypeBlock,
+		},
+		{
+			name:     "C4 Context",
+			input:    "c4Context\n    title System Context diagram for Internet Banking System",
+			expected: DiagramTypeC4,
+		},
+		{
+			name:     "Architecture Diagram",
+			input:    "architecture\n    title Architecture diagram",
+			expected: DiagramTypeArchitecture,
+		},
+		{
+			name:     "Radar Chart",
+			input:    "radar\n    title Simple Radar Chart",
+			expected: DiagramTypeRadar,
+		},
+		{
+			name:     "Treemap",
+			input:    "treemap\n    title Tree Map Example",
+			expected: DiagramTypeTreemap,
+		},
+		{
+			name:     "Packet Diagram",
+			input:    "packet\n    title Packet Diagram",
+			expected: DiagramTypePacket,
+		},
+		{
+			name:     "Info Diagram",
+			input:    "info\n    title Info Diagram",
+			expected: DiagramTypeInfo,
+		},
+		{
+			name:     "Unknown Diagram",
+			input:    "unknownDiagram\n    some content",
+			expected: DiagramTypeUnknown,
+		},
+		{
+			name:     "Empty Input",
+			input:    "",
+			expected: DiagramTypeUnknown,
+		},
+		{
+			name:     "With Comments",
+			input:    "%% This is a comment\nsequenceDiagram\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+		{
+			name:     "With Front Matter",
+			input:    "---\ntitle: Test\n---\nsequenceDiagram\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+		{
+			name:     "With Directives",
+			input:    "%%{init: {'theme':'base'}}%%\nsequenceDiagram\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+		{
+			name:     "Case Insensitive",
+			input:    "SEQUENCEDIAGRAM\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+		{
+			name:     "With Leading Whitespace",
+			input:    "   sequenceDiagram\n    A -> B : hello",
+			expected: DiagramTypeSequence,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := registry.DetectDiagramType(tt.input)
+			if result != tt.expected {
+				t.Errorf("Expected %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestCleanText(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Remove Comments",
+			input:    "%% This is a comment\nsequenceDiagram\n    A -> B : hello",
+			expected: "sequenceDiagram\n    A -> B : hello",
+		},
+		{
+			name:     "Remove Front Matter",
+			input:    "---\ntitle: Test\n---\nsequenceDiagram\n    A -> B : hello",
+			expected: "sequenceDiagram\n    A -> B : hello",
+		},
+		{
+			name:     "Remove Directives",
+			input:    "%%{init: {'theme':'base'}}%%\nsequenceDiagram\n    A -> B : hello",
+			expected: "sequenceDiagram\n    A -> B : hello",
+		},
+		{
+			name:     "Remove Multiple Comments",
+			input:    "%% Comment 1\nsequenceDiagram\n    %% Comment 2\n    A -> B : hello",
+			expected: "sequenceDiagram\n    A -> B : hello",
+		},
+		{
+			name:     "Trim Whitespace",
+			input:    "   \n  sequenceDiagram  \n  \n    A -> B : hello  \n  ",
+			expected: "sequenceDiagram\n    A -> B : hello",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := cleanText(tt.input)
+			if result != tt.expected {
+				t.Errorf("Expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestDetectorPriority(t *testing.T) {
+	registry := NewDetectorRegistry()
+
+	// Test that stateDiagram-v2 has higher priority than stateDiagram
+	stateV2Input := "stateDiagram-v2\n    [*] --> State1"
+	result := registry.DetectDiagramType(stateV2Input)
+	if result != DiagramTypeStateV2 {
+		t.Errorf("Expected %v, got %v", DiagramTypeStateV2, result)
+	}
+
+	// Test that sequenceDiagram has higher priority than generic patterns
+	sequenceInput := "sequenceDiagram\n    A -> B : hello"
+	result = registry.DetectDiagramType(sequenceInput)
+	if result != DiagramTypeSequence {
+		t.Errorf("Expected %v, got %v", DiagramTypeSequence, result)
+	}
+}

pkg/lexer/lexer.go

@@ -39,6 +39,11 @@ const (
 	TokenRL // Right Left
 	TokenLR // Left Right
 
+	// State diagram action keywords
+	TokenEntry // entry
+	TokenExit  // exit
+	TokenDo    // do
+
 	// Identifiers and literals
 	TokenID
 	TokenString
@@ -68,11 +73,29 @@ const (
 	TokenArrowCircle // --o
 
 	// ER diagram relationship tokens
-	TokenEROneToMany  // ||--o{
-	TokenERManyToOne  // }o--||
-	TokenEROneToOne   // ||--||
-	TokenERManyToMany // }o--o{
-	TokenERZeroToOne  // ||--o|
+	TokenEROneToMany     // ||--o{
+	TokenEROneToManyAlt  // ||--|{
+	TokenERManyToOne     // }o--||
+	TokenEROneToOne      // ||--||
+	TokenERManyToMany    // }o--o{
+	TokenERManyToManyAlt // }|..|{
+	TokenERZeroToOne     // ||--o|
+
+	// Class diagram relationship tokens
+	TokenClassInheritance // <|--
+	TokenClassComposition // *--
+	TokenClassAggregation // o--
+	TokenClassAssociation // -->
+	TokenClassRealization // ..|>
+	TokenClassDependency  // ..>
+
+	// ER diagram cardinality tokens
+	TokenERCardOnlyOne    // ||
+	TokenERCardZeroOrOne  // o
+	TokenERCardZeroOrMore // o{
+	TokenERCardOneOrMore  // |{
+	TokenERCardCloseOne   // }|
+	TokenERCardCloseZero  // }o
 
 	// Edge modifiers
 	TokenPipe        // |
@@ -141,6 +164,9 @@ var tokenTypeNames = map[TokenType]string{
 	TokenBT:               "BT",
 	TokenRL:               "RL",
 	TokenLR:               "LR",
+	TokenEntry:            "ENTRY",
+	TokenExit:             "EXIT",
+	TokenDo:               "DO",
 	TokenID:               "ID",
 	TokenString:           "STRING",
 	TokenNodeString:       "NODE_STRING",
@@ -164,10 +190,24 @@ var tokenTypeNames = map[TokenType]string{
 	TokenArrowCross:       "ARROW_CROSS",
 	TokenArrowCircle:      "ARROW_CIRCLE",
 	TokenEROneToMany:      "ER_ONE_TO_MANY",
+	TokenEROneToManyAlt:   "ER_ONE_TO_MANY_ALT",
 	TokenERManyToOne:      "ER_MANY_TO_ONE",
 	TokenEROneToOne:       "ER_ONE_TO_ONE",
 	TokenERManyToMany:     "ER_MANY_TO_MANY",
+	TokenERManyToManyAlt:  "ER_MANY_TO_MANY_ALT",
 	TokenERZeroToOne:      "ER_ZERO_TO_ONE",
+	TokenClassInheritance: "CLASS_INHERITANCE",
+	TokenClassComposition: "CLASS_COMPOSITION",
+	TokenClassAggregation: "CLASS_AGGREGATION",
+	TokenClassAssociation: "CLASS_ASSOCIATION",
+	TokenClassRealization: "CLASS_REALIZATION",
+	TokenClassDependency:  "CLASS_DEPENDENCY",
+	TokenERCardOnlyOne:    "ER_CARD_ONLY_ONE",
+	TokenERCardZeroOrOne:  "ER_CARD_ZERO_OR_ONE",
+	TokenERCardZeroOrMore: "ER_CARD_ZERO_OR_MORE",
+	TokenERCardOneOrMore:  "ER_CARD_ONE_OR_MORE",
+	TokenERCardCloseOne:   "ER_CARD_CLOSE_ONE",
+	TokenERCardCloseZero:  "ER_CARD_CLOSE_ZERO",
 	TokenPipe:             "PIPE",
 	TokenColon:            "COLON",
 	TokenSemicolon:        "SEMICOLON",
@@ -265,6 +305,28 @@ func (l *Lexer) nextToken() error {
 
 // tryMultiCharOperator attempts to match multi-character operators
 func (l *Lexer) tryMultiCharOperator() TokenType {
+	// Check for state diagram special markers first
+	if l.matchString("<<fork>>") {
+		l.addTokenAndAdvance(TokenID, "<<fork>>", 8)
+		return TokenID
+	}
+	if l.matchString("<<join>>") {
+		l.addTokenAndAdvance(TokenID, "<<join>>", 8)
+		return TokenID
+	}
+	if l.matchString("<<choice>>") {
+		l.addTokenAndAdvance(TokenID, "<<choice>>", 10)
+		return TokenID
+	}
+	if l.matchString("<<history>>") {
+		l.addTokenAndAdvance(TokenID, "<<history>>", 11)
+		return TokenID
+	}
+	if l.matchString("<<deepHistory>>") {
+		l.addTokenAndAdvance(TokenID, "<<deepHistory>>", 15)
+		return TokenID
+	}
+
 	// Check for ER diagram relationships first (need to be before shorter patterns)
 	if l.matchString("||--o{") {
 		l.addTokenAndAdvance(TokenEROneToMany, "||--o{", 6)
@@ -286,16 +348,139 @@ func (l *Lexer) tryMultiCharOperator() TokenType {
 		l.addTokenAndAdvance(TokenERZeroToOne, "||--o|", 6)
 		return TokenERZeroToOne
 	}
+	if l.matchString("||--|{") {
+		l.addTokenAndAdvance(TokenEROneToManyAlt, "||--|{", 6)
+		return TokenEROneToManyAlt
+	}
+	if l.matchString("}|..|{") {
+		l.addTokenAndAdvance(TokenERManyToManyAlt, "}|..|{", 6)
+		return TokenERManyToManyAlt
+	}
 
-	// Check for sequence diagram arrows
-	if l.matchString("->>") {
-		l.addTokenAndAdvance(TokenArrowSolid, "->>", 3)
+	// Check for class diagram relationship symbols
+	if l.matchString("<|--") {
+		l.addTokenAndAdvance(TokenClassInheritance, "<|--", 4)
+		return TokenClassInheritance
+	}
+	if l.matchString("*--") {
+		l.addTokenAndAdvance(TokenClassComposition, "*--", 3)
+		return TokenClassComposition
+	}
+	if l.matchString("o--") {
+		l.addTokenAndAdvance(TokenClassAggregation, "o--", 3)
+		return TokenClassAggregation
+	}
+	if l.matchString("-->") {
+		l.addTokenAndAdvance(TokenClassAssociation, "-->", 3)
+		return TokenClassAssociation
+	}
+	if l.matchString("..|>") {
+		l.addTokenAndAdvance(TokenClassRealization, "..|>", 4)
+		return TokenClassRealization
+	}
+	if l.matchString("..>") {
+		l.addTokenAndAdvance(TokenClassDependency, "..>", 3)
+		return TokenClassDependency
+	}
+
+	// Check for ER diagram cardinality symbols
+	if l.matchString("||") {
+		l.addTokenAndAdvance(TokenERCardOnlyOne, "||", 2)
+		return TokenERCardOnlyOne
+	}
+	if l.matchString("o{") {
+		l.addTokenAndAdvance(TokenERCardZeroOrMore, "o{", 2)
+		return TokenERCardZeroOrMore
+	}
+	if l.matchString("|{") {
+		l.addTokenAndAdvance(TokenERCardOneOrMore, "|{", 2)
+		return TokenERCardOneOrMore
+	}
+	if l.matchString("}|") {
+		l.addTokenAndAdvance(TokenERCardCloseOne, "}|", 2)
+		return TokenERCardCloseOne
+	}
+	if l.matchString("}o") {
+		l.addTokenAndAdvance(TokenERCardCloseZero, "}o", 2)
+		return TokenERCardCloseZero
+	}
+
+	// Check for special diagram type declarations first
+	if l.matchString("stateDiagram-v2") {
+		l.addTokenAndAdvance(TokenID, "stateDiagram-v2", 15)
+		return TokenID
+	}
+	if l.matchString("stateDiagram") {
+		l.addTokenAndAdvance(TokenID, "stateDiagram", 12)
+		return TokenID
+	}
+	if l.matchString("sequenceDiagram") {
+		l.addTokenAndAdvance(TokenID, "sequenceDiagram", 15)
+		return TokenID
+	}
+	if l.matchString("erDiagram") {
+		l.addTokenAndAdvance(TokenID, "erDiagram", 9)
+		return TokenID
+	}
+
+	// Check for sequence diagram arrows (longer patterns first, following mermaidjs patterns)
+	// Bidirectional arrows
+	if l.matchString("<<-->>") {
+		l.addTokenAndAdvance(TokenArrowDotted, "<<-->>", 6)
+		return TokenArrowDotted
+	}
+	if l.matchString("<<->>") {
+		l.addTokenAndAdvance(TokenArrowSolid, "<<->>", 5)
+		return TokenArrowSolid
+	}
+
+	// Complex arrows with directional markers
+	if l.matchString("--|\\") {
+		l.addTokenAndAdvance(TokenArrowSolid, "--|\\", 4)
+		return TokenArrowSolid
+	}
+	if l.matchString("--|/") {
+		l.addTokenAndAdvance(TokenArrowSolid, "--|/", 4)
+		return TokenArrowSolid
+	}
+	if l.matchString("-|\\") {
+		l.addTokenAndAdvance(TokenArrowSolid, "-|\\", 3)
 		return TokenArrowSolid
 	}
+	if l.matchString("-|/") {
+		l.addTokenAndAdvance(TokenArrowSolid, "-|/", 3)
+		return TokenArrowSolid
+	}
+
+	// Standard arrows
 	if l.matchString("-->>") {
 		l.addTokenAndAdvance(TokenArrowDotted, "-->>", 4)
 		return TokenArrowDotted
 	}
+	if l.matchString("->>") {
+		l.addTokenAndAdvance(TokenArrowSolid, "->>", 3)
+		return TokenArrowSolid
+	}
+	if l.matchString("<->") {
+		l.addTokenAndAdvance(TokenArrowSolid, "<->", 3)
+		return TokenArrowSolid
+	}
+	if l.matchString("-x") {
+		l.addTokenAndAdvance(TokenArrowCross, "-x", 2)
+		return TokenArrowCross
+	}
+	if l.matchString("--)") {
+		l.addTokenAndAdvance(TokenArrowOpen, "--)", 3)
+		return TokenArrowOpen
+	}
+	if l.matchString("->") {
+		l.addTokenAndAdvance(TokenArrowSolid, "->", 2)
+		return TokenArrowSolid
+	}
+	if l.matchString("-)") {
+		l.addTokenAndAdvance(TokenArrowOpen, "-)", 2)
+		return TokenArrowOpen
+	}
 
 	// Check for arrows - based on destructLink patterns
 	if l.matchString("==>") {
@@ -331,6 +516,12 @@ func (l *Lexer) tryMultiCharOperator() TokenType {
 		return TokenCloseDoubleParen
 	}
 
+	// Check for single character ER cardinality symbols
+	if l.matchString("o") && !l.isNextChar('{') && !l.isNextChar('-') && !l.isNextCharLetter() {
+		l.addTokenAndAdvance(TokenERCardZeroOrOne, "o", 1)
+		return TokenERCardZeroOrOne
+	}
+
 	return TokenError
 }
 
@@ -435,6 +626,27 @@ func (l *Lexer) getKeywordType(value string) TokenType {
 		return TokenRL
 	case "lr":
 		return TokenLR
+	// State diagram keywords
+	case "state":
+		return TokenID
+	case "diagram":
+		return TokenID
+	case "statediagram-v2":
+		return TokenID
+	case "statediagram":
+		return TokenID
+	case "entry":
+		return TokenEntry
+	case "exit":
+		return TokenExit
+	case "do":
+		return TokenDo
+	case "pk":
+		return TokenID
+	case "fk":
+		return TokenID
+	case "uk":
+		return TokenID
 	default:
 		return TokenID
 	}
@@ -456,6 +668,30 @@ func (l *Lexer) consumeNumber() error {
 		}
 	}
 
+	// Check for duration suffixes (d, w, m, y, h)
+	if l.position < len(l.input) {
+		ch := l.current()
+		if ch == 'd' || ch == 'w' || ch == 'm' || ch == 'y' || ch == 'h' {
+			l.advance()
+		}
+	}
+
+	// Check for date format (YYYY-MM-DD) - look for additional numbers with dashes
+	if l.position < len(l.input) && l.current() == '-' {
+		l.advance() // consume the dash
+		// Look for more digits after dash
+		for l.position < len(l.input) && unicode.IsDigit(l.current()) {
+			l.advance()
+		}
+		// Look for another dash and more digits
+		if l.position < len(l.input) && l.current() == '-' {
+			l.advance() // consume the second dash
+			for l.position < len(l.input) && unicode.IsDigit(l.current()) {
+				l.advance()
+			}
+		}
+	}
+
 	l.addToken(TokenNumber, l.input[start:l.position])
 	return nil
 }
@@ -600,6 +836,22 @@ func (l *Lexer) matchString(s string) bool {
 	return l.input[l.position:l.position+len(s)] == s
 }
 
+// isNextChar checks if the next character matches the given character
+func (l *Lexer) isNextChar(ch byte) bool {
+	if l.position+1 >= len(l.input) {
+		return false
+	}
+	return l.input[l.position+1] == ch
+}
+
+// isNextCharLetter checks if the next character is a letter
+func (l *Lexer) isNextCharLetter() bool {
+	if l.position+1 >= len(l.input) {
+		return false
+	}
+	return unicode.IsLetter(rune(l.input[l.position+1]))
+}
+
 // addToken adds a token to the token list
 func (l *Lexer) addToken(tokenType TokenType, value string) {
 	runeCount := utf8.RuneCountInString(value)
@@ -655,7 +907,7 @@ func (l *Lexer) isUnicodeIdentifierStart(ch rune) bool {
 
 // isUnicodeIdentifierChar checks if a character can be part of a Unicode identifier
 func (l *Lexer) isUnicodeIdentifierChar(ch rune) bool {
-	return unicode.IsLetter(ch) || unicode.IsDigit(ch) || ch == '_' || l.isChineseChar(ch)
+	return unicode.IsLetter(ch) || unicode.IsDigit(ch) || ch == '_' || ch == '-' || l.isChineseChar(ch)
 }
 
 // FilterTokens removes whitespace and comment tokens for parsing

pkg/parser/class.go

@@ -362,7 +362,29 @@ func (p *ClassParser) parseRelation(fromClass string) error {
 func (p *ClassParser) parseRelationType() ast.ClassRelationType {
 	token := p.peek()
 
-	// Check for direct arrow tokens
+	// Check for compound class diagram relationship tokens
+	switch token.Type {
+	case lexer.TokenClassInheritance:
+		p.advance()
+		return ast.RelationInheritance
+	case lexer.TokenClassComposition:
+		p.advance()
+		return ast.RelationComposition
+	case lexer.TokenClassAggregation:
+		p.advance()
+		return ast.RelationAggregation
+	case lexer.TokenClassAssociation:
+		p.advance()
+		return ast.RelationAssociation
+	case lexer.TokenClassRealization:
+		p.advance()
+		return ast.RelationRealization
+	case lexer.TokenClassDependency:
+		p.advance()
+		return ast.RelationDependency
+	}
+
+	// Check for direct arrow tokens (fallback)
 	if p.check(lexer.TokenArrowSolid) {
 		p.advance() // consume -->
 		return ast.RelationAssociation
@@ -516,7 +538,13 @@ func (p *ClassParser) checkVisibility() bool {
 
 func (p *ClassParser) checkRelation() bool {
 	token := p.peek()
-	// Check for various relation operators
+	// Check for compound class diagram relationship tokens
+	switch token.Type {
+	case lexer.TokenClassInheritance, lexer.TokenClassComposition, lexer.TokenClassAggregation,
+		lexer.TokenClassAssociation, lexer.TokenClassRealization, lexer.TokenClassDependency:
+		return true
+	}
+	// Check for legacy relation operators
 	return token.Value == "--" || token.Value == ".." ||
 		p.check(lexer.TokenArrowSolid) || p.check(lexer.TokenArrowDotted) ||
 		token.Value == "--|>" || token.Value == "--*" || token.Value == "--o"

pkg/parser/class_test.go

@@ -0,0 +1,246 @@
+package parser
+
+import (
+	"mermaid-go/pkg/ast"
+	"mermaid-go/pkg/renderer"
+	"strings"
+	"testing"
+)
+
+func TestClassParser_BasicFunctionality(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Simple Class",
+			input: `classDiagram
+    class Animal {
+        +String name
+        +int age
+        +makeSound()
+    }`,
+			expected: `classDiagram
+    class Animal {
+        +String name
+        +int age
+        +makeSound()
+    }
+`,
+		},
+		{
+			name: "Class with Inheritance",
+			input: `classDiagram
+    class Animal {
+        +String name
+        +makeSound()
+    }
+    class Dog {
+        +String breed
+        +bark()
+    }
+    Animal <|-- Dog`,
+			expected: `classDiagram
+    class Animal {
+        +String name
+        +makeSound()
+    }
+    class Dog {
+        +String breed
+        +bark()
+    }
+    Animal <|-- Dog
+`,
+		},
+		{
+			name: "Interface and Implementation",
+			input: `classDiagram
+    class Vehicle {
+        <<interface>>
+        +start()
+        +stop()
+    }
+    class Car {
+        +int wheels
+        +drive()
+    }
+    Vehicle ..|> Car`,
+			expected: `classDiagram
+    class Vehicle {
+        <<interface>>
+        +start()
+        +stop()
+    }
+    class Car {
+        +int wheels
+        +drive()
+    }
+    Vehicle ..|> Car
+`,
+		},
+		{
+			name: "Multiple Relationships",
+			input: `classDiagram
+    class Person {
+        +String name
+        +int age
+    }
+    class Company {
+        +String name
+        +String address
+    }
+    class Employee {
+        +String position
+        +double salary
+    }
+    Person <|-- Employee
+    Company *-- Employee
+    Person --> Company`,
+			expected: `classDiagram
+    class Person {
+        +String name
+        +int age
+    }
+    class Company {
+        +String name
+        +String address
+    }
+    class Employee {
+        +String position
+        +double salary
+    }
+    Person <|-- Employee
+    Company *-- Employee
+    Person --> Company
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewClassParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Test rendering
+			renderer := renderer.NewClassRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Normalize whitespace for comparison
+			expected := strings.TrimSpace(tt.expected)
+			actual := strings.TrimSpace(output)
+
+			if actual != expected {
+				t.Errorf("Expected:\n%s\nGot:\n%s", expected, actual)
+			}
+		})
+	}
+}
+
+func TestClassParser_VisibilityParsing(t *testing.T) {
+	input := `classDiagram
+    class TestClass {
+        +publicMethod()
+        -privateMethod()
+        #protectedMethod()
+        ~packageMethod()
+        +String publicField
+        -int privateField
+    }`
+
+	parser := NewClassParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	if len(diagram.Classes) != 1 {
+		t.Fatalf("Expected 1 class, got %d", len(diagram.Classes))
+	}
+
+	class := diagram.Classes["TestClass"]
+	if class == nil {
+		t.Fatal("TestClass not found")
+	}
+
+	// Check methods
+	if len(class.Methods) != 4 {
+		t.Fatalf("Expected 4 methods, got %d", len(class.Methods))
+	}
+
+	expectedVisibilities := []ast.MemberVisibility{
+		ast.VisibilityPublic,
+		ast.VisibilityPrivate,
+		ast.VisibilityProtected,
+		ast.VisibilityPackage,
+	}
+
+	for i, method := range class.Methods {
+		if method.Visibility != expectedVisibilities[i] {
+			t.Errorf("Method %d: expected visibility %s, got %s", i, expectedVisibilities[i], method.Visibility)
+		}
+	}
+
+	// Check members
+	if len(class.Members) != 2 {
+		t.Fatalf("Expected 2 members, got %d", len(class.Members))
+	}
+
+	expectedMemberVisibilities := []ast.MemberVisibility{
+		ast.VisibilityPublic,
+		ast.VisibilityPrivate,
+	}
+
+	for i, member := range class.Members {
+		if member.Visibility != expectedMemberVisibilities[i] {
+			t.Errorf("Member %d: expected visibility %s, got %s", i, expectedMemberVisibilities[i], member.Visibility)
+		}
+	}
+}
+
+func TestClassParser_RelationshipParsing(t *testing.T) {
+	input := `classDiagram
+    class A {
+        +methodA()
+    }
+    class B {
+        +methodB()
+    }
+    A <|-- B
+    A --> B
+    A *-- B
+    A o-- B
+    A ..|> B
+    A ..> B`
+
+	parser := NewClassParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	expectedRelations := []ast.ClassRelationType{
+		ast.RelationInheritance,
+		ast.RelationAssociation,
+		ast.RelationComposition,
+		ast.RelationAggregation,
+		ast.RelationRealization,
+		ast.RelationDependency,
+	}
+
+	if len(diagram.Relations) != len(expectedRelations) {
+		t.Fatalf("Expected %d relations, got %d", len(expectedRelations), len(diagram.Relations))
+	}
+
+	for i, rel := range diagram.Relations {
+		if rel.Type != expectedRelations[i] {
+			t.Errorf("Relation %d: expected type %s, got %s", i, expectedRelations[i], rel.Type)
+		}
+	}
+}

pkg/parser/enhanced_sequence_test.go

@@ -0,0 +1,251 @@
+package parser
+
+import (
+	"strings"
+	"testing"
+
+	"mermaid-go/pkg/renderer"
+)
+
+func TestSequenceParser_NewBlocks(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Rect Block",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    rect rgb(255, 0, 0)
+        A -> B : message1
+        B -> A : response1
+    end
+    A -> B : message2`,
+			expected: `sequenceDiagram
+    participant A
+    participant B
+    A -> B : message2
+    rect rgb(255,0,0)
+        A -> B : message1
+        B -> A : response1
+    end
+`,
+		},
+		{
+			name: "Critical Block with Option",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    critical Critical Section
+        A -> B : critical message
+        option Success Path
+            B --> A : success response
+        option Failure Path
+            B --> A : error response
+    end`,
+			expected: `sequenceDiagram
+    participant A
+    participant B
+    critical Critical Section
+        A -> B : critical message
+        option Success Path
+            B -> A : success response
+        option Failure Path
+            B -> A : error response
+    end
+`,
+		},
+		{
+			name: "Break Block",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    break Break Condition
+        A -> B : break message
+        B --> A : break response
+    end`,
+			expected: `sequenceDiagram
+    participant A
+    participant B
+    break Break Condition
+        A -> B : break message
+        B -> A : break response
+    end
+`,
+		},
+		{
+			name: "Complex Nested Blocks",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    participant C
+    rect rgb(0, 255, 0)
+        critical Authentication
+            A -> B : login request
+            option Valid Credentials
+                B --> A : auth success
+                A -> C : access resource
+                C --> A : resource data
+            option Invalid Credentials
+                B --> A : auth failed
+        end
+    end`,
+			expected: `sequenceDiagram
+    participant A
+    participant B
+    participant C
+    rect rgb(0,255,0)
+    end
+    critical Authentication
+        A -> B : login request
+        option Valid Credentials
+            B -> A : auth success
+            A -> C : access resource
+            C -> A : resource data
+        option Invalid Credentials
+            B -> A : auth failed
+    end
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewSequenceParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Test rendering
+			renderer := renderer.NewSequenceRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Normalize whitespace for comparison
+			expected := strings.TrimSpace(tt.expected)
+			actual := strings.TrimSpace(output)
+
+			if expected != actual {
+				t.Errorf("Expected:\n%s\n\nGot:\n%s", expected, actual)
+			}
+		})
+	}
+}
+
+func TestSequenceParser_RectBlock(t *testing.T) {
+	input := `sequenceDiagram
+    participant A
+    participant B
+    rect rgb(255, 0, 0)
+        A -> B : message in rect
+    end`
+
+	parser := NewSequenceParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check rect was parsed
+	if len(diagram.Rects) != 1 {
+		t.Fatalf("Expected 1 rect, got %d", len(diagram.Rects))
+	}
+
+	rect := diagram.Rects[0]
+	if rect.Color == nil || *rect.Color != "rgb(255,0,0)" {
+		if rect.Color == nil {
+			t.Errorf("Expected color rgb(255,0,0), got nil")
+		} else {
+			t.Errorf("Expected color rgb(255,0,0), got %s", *rect.Color)
+		}
+	}
+
+	if len(rect.Messages) != 1 {
+		t.Fatalf("Expected 1 message in rect, got %d", len(rect.Messages))
+	}
+
+	message := rect.Messages[0]
+	if message.From != "A" || message.To != "B" || message.Message != "message in rect" {
+		t.Errorf("Expected A -> B : message in rect, got %s %s %s : %s", message.From, string(message.Type), message.To, message.Message)
+	}
+}
+
+func TestSequenceParser_CriticalBlock(t *testing.T) {
+	input := `sequenceDiagram
+    participant A
+    participant B
+    critical Critical Section
+        A -> B : critical message
+        option Success
+            B --> A : success
+        option Failure
+            B --> A : failure
+    end`
+
+	parser := NewSequenceParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check critical was parsed
+	if len(diagram.Criticals) != 1 {
+		t.Fatalf("Expected 1 critical, got %d", len(diagram.Criticals))
+	}
+
+	critical := diagram.Criticals[0]
+	if critical.Label != "Critical Section" {
+		t.Errorf("Expected label 'Critical Section', got '%s'", critical.Label)
+	}
+
+	if len(critical.Options) != 2 {
+		t.Fatalf("Expected 2 options, got %d", len(critical.Options))
+	}
+
+	// Check options
+	if critical.Options[0].Label != "Success" {
+		t.Errorf("Expected first option label 'Success', got '%s'", critical.Options[0].Label)
+	}
+	if critical.Options[1].Label != "Failure" {
+		t.Errorf("Expected second option label 'Failure', got '%s'", critical.Options[1].Label)
+	}
+}
+
+func TestSequenceParser_BreakBlock(t *testing.T) {
+	input := `sequenceDiagram
+    participant A
+    participant B
+    break Break Condition
+        A -> B : break message
+    end`
+
+	parser := NewSequenceParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check break was parsed
+	if len(diagram.Breaks) != 1 {
+		t.Fatalf("Expected 1 break, got %d", len(diagram.Breaks))
+	}
+
+	breakBlock := diagram.Breaks[0]
+	if breakBlock.Label != "Break Condition" {
+		t.Errorf("Expected label 'Break Condition', got '%s'", breakBlock.Label)
+	}
+
+	if len(breakBlock.Messages) != 1 {
+		t.Fatalf("Expected 1 message in break, got %d", len(breakBlock.Messages))
+	}
+
+	message := breakBlock.Messages[0]
+	if message.From != "A" || message.To != "B" || message.Message != "break message" {
+		t.Errorf("Expected A -> B : break message, got %s %s %s : %s", message.From, string(message.Type), message.To, message.Message)
+	}
+}

pkg/parser/enhanced_state_test.go

@@ -0,0 +1,216 @@
+package parser
+
+import (
+	"strings"
+	"testing"
+
+	"mermaid-go/pkg/renderer"
+)
+
+func TestStateParser_EnhancedFeatures(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Basic State with Actions",
+			input: `stateDiagram-v2
+    [*] --> State1
+    State1 : entry / initialize
+    State1 : exit / cleanup
+    State1 : do / process
+    State1 --> State2 : transition`,
+			expected: `stateDiagram-v2
+    [*] --> State1
+    State1 : entry / initialize
+    State1 : exit / cleanup
+    State1 : do / process
+    State1 --> State2 : transition
+`,
+		},
+		{
+			name: "Composite State",
+			input: `stateDiagram-v2
+    [*] --> CompositeState
+    state CompositeState {
+        [*] --> SubState1
+        SubState1 --> SubState2
+        SubState2 --> [*]
+    }
+    CompositeState --> [*]`,
+			expected: `stateDiagram-v2
+    [*] --> CompositeState
+    state CompositeState {
+        [*] --> SubState1
+        SubState1 --> SubState2
+        SubState2 --> [*]
+    }
+    CompositeState --> [*]
+`,
+		},
+		{
+			name: "Parallel States",
+			input: `stateDiagram-v2
+    [*] --> ParallelState
+    state ParallelState {
+        [*] --> Region1
+        [*] --> Region2
+        state Region1 {
+            [*] --> StateA
+            StateA --> StateB
+        }
+        state Region2 {
+            [*] --> StateC
+            StateC --> StateD
+        }
+    }`,
+			expected: `stateDiagram-v2
+    [*] --> ParallelState
+    state ParallelState {
+        [*] --> Region1
+        [*] --> Region2
+        state Region1 {
+            [*] --> StateA
+            StateA --> StateB
+        }
+        state Region2 {
+            [*] --> StateC
+            StateC --> StateD
+        }
+    }
+`,
+		},
+		{
+			name: "Special States",
+			input: `stateDiagram-v2
+    [*] --> ForkState
+    ForkState : <<fork>>
+    ForkState --> ChoiceState
+    ChoiceState : <<choice>>
+    ChoiceState --> JoinState
+    JoinState : <<join>>
+    JoinState --> [*]`,
+			expected: `stateDiagram-v2
+    state JoinState : <<join>>
+    state ForkState : <<fork>>
+    state ChoiceState : <<choice>>
+    [*] --> ForkState
+    ForkState --> ChoiceState
+    ChoiceState --> JoinState
+    JoinState --> [*]
+`,
+		},
+		{
+			name: "Complex Transitions with Guards and Actions",
+			input: `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2 : normal [condition] / action
+    State2 --> State3 : urgent [priority > 5] / handle
+    State3 --> [*]`,
+			expected: `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2 : normal [condition] / action
+    State2 --> State3 : urgent [priority > 5] / handle
+    State3 --> [*]
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewStateParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Test rendering
+			renderer := renderer.NewStateRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Normalize whitespace for comparison
+			expected := strings.TrimSpace(tt.expected)
+			actual := strings.TrimSpace(output)
+
+			if expected != actual {
+				t.Errorf("Expected:\n%s\n\nGot:\n%s", expected, actual)
+			}
+		})
+	}
+}
+
+func TestStateParser_StateActions(t *testing.T) {
+	input := `stateDiagram-v2
+    [*] --> State1
+    State1 : entry / initialize system
+    State1 : exit / cleanup resources
+    State1 : do / process data
+    State1 --> State2`
+
+	parser := NewStateParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check state was parsed with actions
+	if len(diagram.States) == 0 {
+		t.Fatal("No states found")
+	}
+
+	state1, exists := diagram.States["State1"]
+	if !exists {
+		t.Fatal("State1 not found")
+	}
+
+	if state1.EntryAction == nil || *state1.EntryAction != "/ initialize system" {
+		t.Errorf("Expected entry action '/ initialize system', got %v", state1.EntryAction)
+	}
+
+	if state1.ExitAction == nil || *state1.ExitAction != "/ cleanup resources" {
+		t.Errorf("Expected exit action '/ cleanup resources', got %v", state1.ExitAction)
+	}
+
+	if state1.DoAction == nil || *state1.DoAction != "/ process data" {
+		t.Errorf("Expected do action '/ process data', got %v", state1.DoAction)
+	}
+}
+
+func TestStateParser_CompositeStates(t *testing.T) {
+	input := `stateDiagram-v2
+    [*] --> CompositeState
+    state CompositeState {
+        [*] --> SubState1
+        SubState1 --> SubState2
+    }
+    CompositeState --> [*]`
+
+	parser := NewStateParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check composite state was parsed
+	compositeState, exists := diagram.States["CompositeState"]
+	if !exists {
+		t.Fatal("CompositeState not found")
+	}
+
+	if compositeState.SubStates == nil || len(compositeState.SubStates) == 0 {
+		t.Fatal("No substates found in CompositeState")
+	}
+
+	// Check substates
+	if _, exists := compositeState.SubStates["SubState1"]; !exists {
+		t.Error("SubState1 not found in CompositeState")
+	}
+
+	if _, exists := compositeState.SubStates["SubState2"]; !exists {
+		t.Error("SubState2 not found in CompositeState")
+	}
+}

pkg/parser/enhanced_test.go

@@ -0,0 +1,402 @@
+package parser
+
+import (
+	"mermaid-go/pkg/renderer"
+	"testing"
+)
+
+// TestEnhancedSequenceDiagramSupport tests the enhanced sequence diagram parsing and rendering
+func TestEnhancedSequenceDiagramSupport(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Basic sequence with different arrow types",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    A -> B : solid arrow
+    A --> B : dotted arrow
+    A ->> B : solid arrow with arrowhead
+    A -->> B : dotted arrow with arrowhead
+    A -x B : destroy solid
+    A --x B : destroy dotted
+    A -) B : open solid
+    A --) B : open dotted
+    A <-> B : bidirectional`,
+			expected: "sequenceDiagram",
+		},
+		{
+			name: "Sequence with loops and alternatives",
+			input: `sequenceDiagram
+    participant U as User
+    participant S as Server
+    participant D as Database
+    
+    loop Authentication
+        U -> S : login request
+        S -> D : validate credentials
+        D --> S : user data
+    end
+    
+    alt Valid credentials
+        S --> U : login success
+    else Invalid credentials
+        S --> U : login failed
+    end
+    
+    opt Remember me
+        S -> D : save session
+    end`,
+			expected: "sequenceDiagram",
+		},
+		{
+			name: "Sequence with parallel sections",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    participant C
+    
+    par Parallel execution
+        A -> B : message 1
+        A -> C : message 2
+    and Another parallel section
+        B -> C : message 3
+    end`,
+			expected: "sequenceDiagram",
+		},
+		{
+			name: "Sequence with boxes and notes",
+			input: `sequenceDiagram
+    box "Frontend" lightblue
+        participant U as User
+        participant W as WebApp
+    end
+    
+    box "Backend" lightgreen
+        participant S as Server
+        participant D as Database
+    end
+    
+    U -> W : request
+    W -> S : API call
+    
+    Note over W,S : Processing request
+    
+    S -> D : query
+    D --> S : results
+    S --> W : response
+    W --> U : display`,
+			expected: "sequenceDiagram",
+		},
+		{
+			name: "Sequence with activations",
+			input: `sequenceDiagram
+    participant A
+    participant B
+    
+    A -> B : start processing
+    activate B
+    B -> A : processing...
+    deactivate B
+    B --> A : done`,
+			expected: "sequenceDiagram",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Parse the input
+			parser := NewSequenceParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Verify basic structure
+			if diagram == nil {
+				t.Fatal("Diagram is nil")
+			}
+
+			// Render back to mermaid syntax
+			renderer := renderer.NewSequenceRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Verify output contains expected elements
+			if !containsString(output, tt.expected) {
+				t.Errorf("Expected output to contain %q, got: %s", tt.expected, output)
+			}
+
+			t.Logf("Successfully parsed and rendered: %s", tt.name)
+			t.Logf("Output: %s", output)
+		})
+	}
+}
+
+// TestEnhancedStateDiagramSupport tests the enhanced state diagram parsing and rendering
+func TestEnhancedStateDiagramSupport(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Basic state diagram with transitions",
+			input: `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2 : transition
+    State2 --> [*]`,
+			expected: "stateDiagram-v2",
+		},
+		{
+			name: "State diagram with guards and actions",
+			input: `stateDiagram-v2
+    [*] --> Idle
+    Idle --> Processing : start [hasData] / processData
+    Processing --> Idle : complete [success] / cleanup
+    Processing --> Error : fail [error] / logError`,
+			expected: "stateDiagram-v2",
+		},
+		{
+			name: "State diagram with composite states",
+			input: `stateDiagram-v2
+    [*] --> Active
+    
+    state Active {
+        [*] --> Working
+        Working --> Waiting
+        Waiting --> Working
+    }
+    
+    Active --> [*]`,
+			expected: "stateDiagram-v2",
+		},
+		{
+			name: "State diagram with notes",
+			input: `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2
+    
+    note right of State1 : This is State1
+    note left of State2 : This is State2`,
+			expected: "stateDiagram-v2",
+		},
+		{
+			name: "State diagram with special states",
+			input: `stateDiagram-v2
+    [*] --> Start
+    Start --> Choice : <<choice>>
+    Choice --> Fork : <<fork>>
+    Fork --> Join : <<join>>
+    Join --> History : <<history>>
+    History --> [*]`,
+			expected: "stateDiagram-v2",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Parse the input
+			parser := NewStateParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Verify basic structure
+			if diagram == nil {
+				t.Fatal("Diagram is nil")
+			}
+
+			// Render back to mermaid syntax
+			renderer := renderer.NewStateRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Verify output contains expected elements
+			if !containsString(output, tt.expected) {
+				t.Errorf("Expected output to contain %q, got: %s", tt.expected, output)
+			}
+
+			t.Logf("Successfully parsed and rendered: %s", tt.name)
+			t.Logf("Output: %s", output)
+		})
+	}
+}
+
+// TestRoundTripConversion tests that parsing and rendering preserves the original structure
+func TestRoundTripConversion(t *testing.T) {
+	// Test sequence diagram round trip
+	seqInput := `sequenceDiagram
+    participant A
+    participant B
+    A -> B : hello
+    loop repeat
+        B --> A : response
+    end
+    alt success
+        A -> B : continue
+    else error
+        A -> B : retry
+    end`
+
+	seqParser := NewSequenceParser()
+	seqDiagram, err := seqParser.Parse(seqInput)
+	if err != nil {
+		t.Fatalf("Failed to parse sequence diagram: %v", err)
+	}
+
+	seqRenderer := renderer.NewSequenceRenderer()
+	seqOutput, err := seqRenderer.Render(seqDiagram)
+	if err != nil {
+		t.Fatalf("Failed to render sequence diagram: %v", err)
+	}
+
+	t.Logf("Sequence diagram round trip successful")
+	t.Logf("Original: %s", seqInput)
+	t.Logf("Rendered: %s", seqOutput)
+
+	// Test state diagram round trip
+	stateInput := `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2 : transition [guard] / action
+    State2 --> [*]`
+
+	stateParser := NewStateParser()
+	stateDiagram, err := stateParser.Parse(stateInput)
+	if err != nil {
+		t.Fatalf("Failed to parse state diagram: %v", err)
+	}
+
+	stateRenderer := renderer.NewStateRenderer()
+	stateOutput, err := stateRenderer.Render(stateDiagram)
+	if err != nil {
+		t.Fatalf("Failed to render state diagram: %v", err)
+	}
+
+	t.Logf("State diagram round trip successful")
+	t.Logf("Original: %s", stateInput)
+	t.Logf("Rendered: %s", stateOutput)
+}
+
+// TestComplexSequenceDiagram tests a complex sequence diagram with all features
+func TestComplexSequenceDiagram(t *testing.T) {
+	complexInput := `sequenceDiagram
+    participant U as User
+    participant W as WebApp
+    participant A as API
+    participant D as Database
+    participant C as Cache
+    
+    box "Frontend" lightblue
+        U
+        W
+    end
+    
+    box "Backend" lightgreen
+        A
+        D
+        C
+    end
+    
+    U -> W : login request
+    activate W
+    
+    W -> A : authenticate
+    activate A
+    
+    alt Cache hit
+        A -> C : get user data
+        C --> A : cached data
+    else Cache miss
+        A -> D : query user
+        D --> A : user data
+        A -> C : store in cache
+    end
+    
+    A --> W : auth result
+    deactivate A
+    
+    opt Remember session
+        W -> C : store session
+    end
+    
+    W --> U : login response
+    deactivate W
+    
+    Note over U,C : Authentication complete
+    
+    par User actions
+        U -> W : browse content
+        W -> A : fetch data
+    and Background tasks
+        A -> D : cleanup old sessions
+    end`
+
+	parser := NewSequenceParser()
+	diagram, err := parser.Parse(complexInput)
+	if err != nil {
+		t.Fatalf("Failed to parse complex sequence diagram: %v", err)
+	}
+
+	// Verify structure
+	if len(diagram.Participants) < 5 {
+		t.Errorf("Expected at least 5 participants, got %d", len(diagram.Participants))
+	}
+
+	if len(diagram.Boxes) < 2 {
+		t.Errorf("Expected at least 2 boxes, got %d", len(diagram.Boxes))
+	}
+
+	if len(diagram.Alts) < 1 {
+		t.Errorf("Expected at least 1 alt block, got %d", len(diagram.Alts))
+	}
+
+	if len(diagram.Opts) < 1 {
+		t.Errorf("Expected at least 1 opt block, got %d", len(diagram.Opts))
+	}
+
+	if len(diagram.Pars) < 1 {
+		t.Errorf("Expected at least 1 par block, got %d", len(diagram.Pars))
+	}
+
+	if len(diagram.Notes) < 1 {
+		t.Errorf("Expected at least 1 note, got %d", len(diagram.Notes))
+	}
+
+	// Render and verify
+	renderer := renderer.NewSequenceRenderer()
+	output, err := renderer.Render(diagram)
+	if err != nil {
+		t.Fatalf("Failed to render complex sequence diagram: %v", err)
+	}
+
+	t.Logf("Complex sequence diagram test passed")
+	t.Logf("Output: %s", output)
+}
+
+// Helper function to check if a string contains a substring
+func containsString(s, substr string) bool {
+	return len(s) >= len(substr) &&
+		(s == substr ||
+			(len(s) > len(substr) &&
+				(s[:len(substr)] == substr ||
+					s[len(s)-len(substr):] == substr ||
+					containsSubstring(s, substr))))
+}
+
+func containsSubstring(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}

pkg/parser/er.go

@@ -11,15 +11,17 @@ import (
 
 // ERParser implements ER diagram parsing following erDiagram.jison
 type ERParser struct {
-	tokens  []lexer.Token
-	current int
-	diagram *ast.ERDiagram
+	tokens    []lexer.Token
+	current   int
+	diagram   *ast.ERDiagram
+	entityMap map[string]*ast.EREntity // Keep track of entities by name for quick lookup
 }
 
 // NewERParser creates a new ER parser
 func NewERParser() *ERParser {
 	return &ERParser{
-		diagram: ast.NewERDiagram(),
+		diagram:   ast.NewERDiagram(),
+		entityMap: make(map[string]*ast.EREntity),
 	}
 }
 
@@ -74,128 +76,133 @@ func (p *ERParser) parseStatement() error {
 	case p.check(lexer.TokenNewline):
 		p.advance() // Skip newlines
 		return nil
-	case p.checkKeyword("title"):
-		return p.parseTitle()
+	case p.checkKeyword("direction"):
+		return p.parseDirectionStatement()
 	case p.check(lexer.TokenID):
 		// Try to parse as entity or relationship
-		return p.parseEntityOrRelation()
-	case p.check(lexer.TokenString):
-		// Entity name in quotes
-		return p.parseEntityOrRelation()
+		return p.parseEntityOrRelationship()
 	default:
 		token := p.peek()
 		return p.error(fmt.Sprintf("unexpected token: %s", token.Value))
 	}
 }
 
-// parseTitle parses title statements
-func (p *ERParser) parseTitle() error {
-	p.advance() // consume 'title'
+// parseEntityOrRelationship attempts to parse either an entity definition or a relationship
+func (p *ERParser) parseEntityOrRelationship() error {
+	entityName := p.advance().Value
 
-	var titleParts []string
-	for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
-		titleParts = append(titleParts, p.advance().Value)
+	// Check if this is a relationship (has cardinality symbols)
+	if p.checkCardinality() {
+		return p.parseRelationship(entityName)
 	}
 
-	if len(titleParts) > 0 {
-		title := strings.TrimSpace(strings.Join(titleParts, " "))
-		p.diagram.Title = &title
+	// Check if this is an entity with attributes (has {)
+	if p.check(lexer.TokenOpenBrace) {
+		return p.parseEntityWithAttributes(entityName)
 	}
 
+	// Simple entity without attributes
+	p.addEntity(entityName)
 	return nil
 }
 
-// parseEntityOrRelation parses either an entity definition or relationship
-func (p *ERParser) parseEntityOrRelation() error {
-	// Get entity name
-	entityName := p.advance().Value
+// parseRelationship parses a relationship between two entities
+func (p *ERParser) parseRelationship(fromEntity string) error {
+	// Parse relationship type (already tokenized as compound token)
+	relType, err := p.parseRelType()
+	if err != nil {
+		return err
+	}
 
-	// Remove quotes if present
-	if strings.HasPrefix(entityName, "\"") && strings.HasSuffix(entityName, "\"") {
-		entityName = entityName[1 : len(entityName)-1]
+	// Parse second entity
+	if !p.check(lexer.TokenID) {
+		return p.error("expected second entity name")
 	}
+	toEntity := p.advance().Value
 
-	// Check for entity attributes block
-	if p.check(lexer.TokenOpenBrace) {
-		return p.parseEntityWithAttributes(entityName)
+	// Ensure both entities exist
+	p.addEntity(fromEntity)
+	p.addEntity(toEntity)
+
+	// Parse optional label
+	var label *string
+	if p.check(lexer.TokenColon) {
+		p.advance() // consume ':'
+		var labelParts []string
+		for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
+			labelParts = append(labelParts, p.advance().Value)
+		}
+		labelStr := strings.TrimSpace(strings.Join(labelParts, " "))
+		label = &labelStr
 	}
 
-	// Check for relationship (cardinality indicators)
-	if p.checkRelationship() {
-		return p.parseRelationship(entityName)
+	// Create relationship
+	relation := &ast.ERRelation{
+		From:  fromEntity,
+		To:    toEntity,
+		Type:  relType,
+		Label: label,
 	}
 
-	// Just a standalone entity
-	p.ensureEntity(entityName)
+	p.diagram.Relations = append(p.diagram.Relations, relation)
 	return nil
 }
 
-// parseEntityWithAttributes parses entity with attribute block
+// parseEntityWithAttributes parses an entity with attribute definitions
 func (p *ERParser) parseEntityWithAttributes(entityName string) error {
-	entity := p.ensureEntity(entityName)
-
 	p.advance() // consume '{'
 
-	// Parse attributes until '}'
+	entity := p.addEntity(entityName)
+
+	// Parse attributes
 	for !p.check(lexer.TokenCloseBrace) && !p.isAtEnd() {
 		if p.check(lexer.TokenNewline) {
-			p.advance() // Skip newlines
+			p.advance()
 			continue
 		}
 
-		if err := p.parseAttribute(entity); err != nil {
+		attribute, err := p.parseAttribute()
+		if err != nil {
 			return err
 		}
+		entity.Attributes = append(entity.Attributes, attribute)
 	}
 
 	if !p.check(lexer.TokenCloseBrace) {
-		return p.error("expected '}'")
+		return p.error("expected '}' to close entity attributes")
 	}
 	p.advance() // consume '}'
 
 	return nil
 }
 
-// parseAttribute parses entity attributes
-func (p *ERParser) parseAttribute(entity *ast.EREntity) error {
-	// Parse: type name [key] ["comment"]
+// parseAttribute parses an attribute definition
+func (p *ERParser) parseAttribute() (*ast.ERAttribute, error) {
+	// Parse attribute type
 	if !p.check(lexer.TokenID) {
-		return p.error("expected attribute type")
+		return nil, p.error("expected attribute type")
 	}
-
 	attrType := p.advance().Value
 
+	// Parse attribute name
 	if !p.check(lexer.TokenID) {
-		return p.error("expected attribute name")
+		return nil, p.error("expected attribute name")
 	}
-
 	attrName := p.advance().Value
 
 	attribute := &ast.ERAttribute{
-		Name: attrName,
 		Type: attrType,
+		Name: attrName,
 	}
 
-	// Check for key constraint
-	if p.check(lexer.TokenID) {
-		keyWord := p.peek().Value
-		if keyWord == "PK" || keyWord == "FK" || keyWord == "UK" {
-			p.advance()
-			switch keyWord {
-			case "PK":
-				key := ast.ERKeyPrimary
-				attribute.Key = &key
-			case "FK":
-				key := ast.ERKeyForeign
-				attribute.Key = &key
-			case "UK":
-				key := ast.ERKeyUnique
-				attribute.Key = &key
-			}
-		}
+	// Parse optional key (PK, FK, UK)
+	if p.check(lexer.TokenID) && p.isKeyWord() {
+		keyStr := p.advance().Value
+		key := ast.ERKeyType(keyStr)
+		attribute.Key = &key
 	}
 
-	// Check for comment
+	// Parse optional comment (quoted string)
 	if p.check(lexer.TokenString) {
 		comment := p.advance().Value
 		// Remove quotes
@@ -205,156 +212,173 @@ func (p *ERParser) parseAttribute(entity *ast.EREntity) error {
 		attribute.Comment = &comment
 	}
 
-	entity.Attributes = append(entity.Attributes, attribute)
-	return nil
+	return attribute, nil
 }
 
-// parseRelationship parses entity relationships
-func (p *ERParser) parseRelationship(fromEntity string) error {
-	// Ensure from entity exists
-	p.ensureEntity(fromEntity)
-
-	// Parse relationship specification
-	relType, err := p.parseRelationshipSpec()
-	if err != nil {
-		return err
-	}
-
-	// Parse to entity
-	if !p.check(lexer.TokenID) && !p.check(lexer.TokenString) {
-		return p.error("expected target entity")
-	}
-
-	toEntity := p.advance().Value
-	// Remove quotes if present
-	if strings.HasPrefix(toEntity, "\"") && strings.HasSuffix(toEntity, "\"") {
-		toEntity = toEntity[1 : len(toEntity)-1]
-	}
-
-	// Ensure to entity exists
-	p.ensureEntity(toEntity)
-
-	// Parse role/label
-	var label *string
-	if p.check(lexer.TokenColon) {
-		p.advance() // consume ':'
-		var labelParts []string
-		for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
-			labelParts = append(labelParts, p.advance().Value)
-		}
-		if len(labelParts) > 0 {
-			labelText := strings.TrimSpace(strings.Join(labelParts, " "))
-			// Remove quotes if present
-			if strings.HasPrefix(labelText, "\"") && strings.HasSuffix(labelText, "\"") {
-				labelText = labelText[1 : len(labelText)-1]
-			}
-			label = &labelText
-		}
-	}
-
-	relation := &ast.ERRelation{
-		From:  fromEntity,
-		To:    toEntity,
-		Type:  relType,
-		Label: label,
+// parseRelType parses relationship type symbols
+func (p *ERParser) parseRelType() (ast.ERRelationType, error) {
+	if p.isAtEnd() {
+		return "", p.error("expected relationship type")
 	}
 
-	p.diagram.Relations = append(p.diagram.Relations, relation)
-	return nil
-}
+	token := p.peek()
 
-// parseRelationshipSpec parses relationship specification
-func (p *ERParser) parseRelationshipSpec() (ast.ERRelationType, error) {
-	// Check for ER relationship tokens first
-	if p.check(lexer.TokenEROneToMany) {
+	// Check for compound ER relationship tokens first
+	switch token.Type {
+	case lexer.TokenEROneToMany:
 		p.advance()
 		return ast.ERRelationOneToMany, nil
-	}
-	if p.check(lexer.TokenERManyToOne) {
+	case lexer.TokenEROneToManyAlt:
+		p.advance()
+		return ast.ERRelationOneToManyAlt, nil
+	case lexer.TokenERManyToOne:
 		p.advance()
 		return ast.ERRelationManyToOne, nil
-	}
-	if p.check(lexer.TokenEROneToOne) {
+	case lexer.TokenEROneToOne:
 		p.advance()
 		return ast.ERRelationOneToOne, nil
-	}
-	if p.check(lexer.TokenERManyToMany) {
+	case lexer.TokenERManyToMany:
 		p.advance()
 		return ast.ERRelationManyToMany, nil
-	}
-	if p.check(lexer.TokenERZeroToOne) {
+	case lexer.TokenERManyToManyAlt:
+		p.advance()
+		return ast.ERRelationManyToManyAlt, nil
+	case lexer.TokenERZeroToOne:
 		p.advance()
 		return ast.ERRelationZeroToOne, nil
 	}
 
-	// Fallback: build the relationship string by consuming tokens until we find the target entity
-	var relationParts []string
-
-	// Consume tokens until we find the next entity (ID or String)
-	for !p.isAtEnd() && !p.check(lexer.TokenID) && !p.check(lexer.TokenString) {
-		token := p.advance()
-		relationParts = append(relationParts, token.Value)
-	}
-
-	if len(relationParts) == 0 {
-		return ast.ERRelationOneToMany, fmt.Errorf("no relationship operator found")
+	// Fall back to individual token parsing for patterns not covered by compound tokens
+	// Look ahead to match relationship patterns
+	if p.matchString("||--||") {
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		p.advance() // consume '-'
+		p.advance() // consume '-'
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		return ast.ERRelationOneToOne, nil
 	}
-
-	// Join the parts to form the complete relationship operator
-	relationOp := strings.Join(relationParts, "")
-
-	// Map common ER relationship patterns
-	switch relationOp {
-	case "||--o{":
+	if p.matchString("||--o{") {
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		p.advance() // consume '-'
+		p.advance() // consume '-'
+		p.advance() // consume 'o'
+		p.advance() // consume '{'
 		return ast.ERRelationOneToMany, nil
-	case "}o--||":
+	}
+	if p.matchString("}o--||") {
+		p.advance() // consume '}'
+		p.advance() // consume 'o'
+		p.advance() // consume '-'
+		p.advance() // consume '-'
+		p.advance() // consume '|'
+		p.advance() // consume '|'
 		return ast.ERRelationManyToOne, nil
-	case "||--||":
-		return ast.ERRelationOneToOne, nil
-	case "}o--o{":
+	}
+	if p.matchString("}o--o{") {
+		p.advance() // consume '}'
+		p.advance() // consume 'o'
+		p.advance() // consume '-'
+		p.advance() // consume '-'
+		p.advance() // consume 'o'
+		p.advance() // consume '{'
 		return ast.ERRelationManyToMany, nil
-	case "||--o|":
+	}
+	if p.matchString("||--o|") {
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		p.advance() // consume '-'
+		p.advance() // consume '-'
+		p.advance() // consume 'o'
+		p.advance() // consume '|'
 		return ast.ERRelationZeroToOne, nil
-	default:
-		// Default to one-to-many for unrecognized patterns
-		return ast.ERRelationOneToMany, nil
 	}
-}
-
-// checkRelationship checks if current position looks like a relationship
-func (p *ERParser) checkRelationship() bool {
-	// Check for ER relationship tokens
-	if p.check(lexer.TokenEROneToMany) || p.check(lexer.TokenERManyToOne) ||
-		p.check(lexer.TokenEROneToOne) || p.check(lexer.TokenERManyToMany) ||
-		p.check(lexer.TokenERZeroToOne) {
-		return true
+	if p.matchString("}o..o{") {
+		p.advance() // consume '}'
+		p.advance() // consume 'o'
+		p.advance() // consume '.'
+		p.advance() // consume '.'
+		p.advance() // consume 'o'
+		p.advance() // consume '{'
+		return ast.ERRelationManyToMany, nil
+	}
+	if p.matchString("||..||") {
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		p.advance() // consume '.'
+		p.advance() // consume '.'
+		p.advance() // consume '|'
+		p.advance() // consume '|'
+		return ast.ERRelationOneToOne, nil
 	}
 
-	// Check for old-style relationship patterns
-	token := p.peek()
-	return strings.Contains(token.Value, "||") ||
-		strings.Contains(token.Value, "}") ||
-		strings.Contains(token.Value, "o") ||
-		strings.Contains(token.Value, "--")
+	return "", p.error("unrecognized relationship pattern")
 }
 
-// ensureEntity ensures an entity exists, creating it if needed
-func (p *ERParser) ensureEntity(name string) *ast.EREntity {
-	if entity, exists := p.diagram.Entities[name]; exists {
+// Helper methods
+func (p *ERParser) addEntity(name string) *ast.EREntity {
+	if entity, exists := p.entityMap[name]; exists {
 		return entity
 	}
 
 	entity := &ast.EREntity{
-		ID:         name,
+		ID:         fmt.Sprintf("entity-%s-%d", name, len(p.diagram.Entities)),
 		Name:       name,
 		Attributes: make([]*ast.ERAttribute, 0),
-		CssClasses: make([]string, 0),
+		CssClasses: []string{"default"},
 	}
-	p.diagram.Entities[name] = entity
+
+	p.entityMap[name] = entity
+	p.diagram.Entities = append(p.diagram.Entities, entity)
 	return entity
 }
 
-// Helper methods
+func (p *ERParser) checkCardinality() bool {
+	if p.isAtEnd() {
+		return false
+	}
+
+	token := p.peek()
+
+	// Check for compound ER relationship tokens
+	switch token.Type {
+	case lexer.TokenEROneToMany, lexer.TokenEROneToManyAlt, lexer.TokenERManyToOne,
+		lexer.TokenEROneToOne, lexer.TokenERManyToMany, lexer.TokenERManyToManyAlt, lexer.TokenERZeroToOne:
+		return true
+	}
+
+	// Fall back to string matching for patterns not covered by compound tokens
+	return p.matchString("||--||") || p.matchString("||--o{") || p.matchString("}o--||") ||
+		p.matchString("}o--o{") || p.matchString("||--o|") || p.matchString("}o..o{") ||
+		p.matchString("||..||")
+}
+
+func (p *ERParser) isKeyWord() bool {
+	if p.isAtEnd() {
+		return false
+	}
+	token := p.peek()
+	return token.Type == lexer.TokenID && (token.Value == "PK" || token.Value == "FK" || token.Value == "UK")
+}
+
+func (p *ERParser) matchString(s string) bool {
+	if p.current+len(s)-1 >= len(p.tokens) {
+		return false
+	}
+
+	var actual strings.Builder
+	for i := 0; i < len(s); i++ {
+		if p.current+i >= len(p.tokens) {
+			return false
+		}
+		actual.WriteString(p.tokens[p.current+i].Value)
+	}
+
+	return actual.String() == s
+}
+
 func (p *ERParser) check(tokenType lexer.TokenType) bool {
 	if p.isAtEnd() {
 		return false
@@ -367,7 +391,7 @@ func (p *ERParser) checkKeyword(keyword string) bool {
 		return false
 	}
 	token := p.peek()
-	return token.Type == lexer.TokenID && strings.ToLower(token.Value) == strings.ToLower(keyword)
+	return token.Type == lexer.TokenID && strings.EqualFold(token.Value, keyword)
 }
 
 func (p *ERParser) advance() lexer.Token {
@@ -395,6 +419,20 @@ func (p *ERParser) previous() lexer.Token {
 	return p.tokens[p.current-1]
 }
 
+func (p *ERParser) parseDirectionStatement() error {
+	p.advance() // consume 'direction'
+
+	if !p.check(lexer.TokenID) {
+		return p.error("expected direction (TB, BT, RL, LR)")
+	}
+
+	// For now, we'll just consume the direction token
+	// The existing ERDiagram struct doesn't have a Direction field
+	p.advance()
+
+	return nil
+}
+
 func (p *ERParser) error(message string) error {
 	token := p.peek()
 	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",

pkg/parser/er_test.go

@@ -0,0 +1,229 @@
+package parser
+
+import (
+	"strings"
+	"testing"
+
+	"mermaid-go/pkg/ast"
+	"mermaid-go/pkg/renderer"
+)
+
+func TestERParser_BasicFunctionality(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Simple Relationship",
+			input: `erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains`,
+			expected: `erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains
+`,
+		},
+		{
+			name: "Entity with Attributes",
+			input: `erDiagram
+    CUSTOMER {
+        string name
+        string custNumber
+        string sector
+    }
+    CUSTOMER ||--o{ ORDER : places`,
+			expected: `erDiagram
+    CUSTOMER {
+        string name
+        string custNumber
+        string sector
+    }
+    CUSTOMER ||--o{ ORDER : places
+`,
+		},
+		{
+			name: "Attributes with Keys",
+			input: `erDiagram
+    ORDER {
+        int orderNumber PK
+        string deliveryAddress
+        float total FK
+    }`,
+			expected: `erDiagram
+    ORDER {
+        int orderNumber PK
+        string deliveryAddress
+        float total FK
+    }
+`,
+		},
+		{
+			name: "Non-identifying Relationship",
+			input: `erDiagram
+    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses`,
+			expected: `erDiagram
+    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses
+`,
+		},
+		{
+			name: "Complex Example",
+			input: `erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    CUSTOMER {
+        string name
+        string custNumber
+        string sector
+    }
+    ORDER ||--|{ LINE-ITEM : contains
+    ORDER {
+        int orderNumber
+        string deliveryAddress
+    }
+    LINE-ITEM {
+        string productCode
+        int quantity
+        float pricePerUnit
+    }`,
+			expected: `erDiagram
+    CUSTOMER {
+        string name
+        string custNumber
+        string sector
+    }
+    ORDER {
+        int orderNumber
+        string deliveryAddress
+    }
+    LINE-ITEM {
+        string productCode
+        int quantity
+        float pricePerUnit
+    }
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewERParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Test rendering
+			renderer := renderer.NewERRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Normalize whitespace for comparison
+			expected := strings.TrimSpace(tt.expected)
+			actual := strings.TrimSpace(output)
+
+			if expected != actual {
+				t.Errorf("Expected:\n%s\n\nGot:\n%s", expected, actual)
+			}
+		})
+	}
+}
+
+func TestERParser_EntityParsing(t *testing.T) {
+	input := `erDiagram
+    CUSTOMER {
+        string name
+        string custNumber
+        string sector
+    }`
+
+	parser := NewERParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check entity was parsed
+	if len(diagram.Entities) != 1 {
+		t.Fatalf("Expected 1 entity, got %d", len(diagram.Entities))
+	}
+
+	var customer *ast.EREntity
+	for _, entity := range diagram.Entities {
+		if entity.Name == "CUSTOMER" {
+			customer = entity
+			break
+		}
+	}
+	if customer == nil {
+		t.Fatal("CUSTOMER entity not found")
+	}
+
+	if len(customer.Attributes) != 3 {
+		t.Fatalf("Expected 3 attributes, got %d", len(customer.Attributes))
+	}
+
+	// Check attributes
+	expectedAttrs := []struct {
+		Type string
+		Name string
+	}{
+		{"string", "name"},
+		{"string", "custNumber"},
+		{"string", "sector"},
+	}
+
+	for i, expected := range expectedAttrs {
+		attr := customer.Attributes[i]
+		if attr.Type != expected.Type {
+			t.Errorf("Attribute %d: expected type %s, got %s", i, expected.Type, attr.Type)
+		}
+		if attr.Name != expected.Name {
+			t.Errorf("Attribute %d: expected name %s, got %s", i, expected.Name, attr.Name)
+		}
+	}
+}
+
+func TestERParser_RelationshipParsing(t *testing.T) {
+	input := `erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER }|..|{ LINE-ITEM : contains`
+
+	parser := NewERParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	// Check relationships were parsed
+	if len(diagram.Relations) != 2 {
+		t.Fatalf("Expected 2 relationships, got %d", len(diagram.Relations))
+	}
+
+	// Check first relationship (one-to-many)
+	rel1 := diagram.Relations[0]
+	if rel1.From != "CUSTOMER" || rel1.To != "ORDER" {
+		t.Errorf("First relationship: expected CUSTOMER -> ORDER, got %s -> %s", rel1.From, rel1.To)
+	}
+	if rel1.Label == nil || *rel1.Label != "places" {
+		t.Errorf("First relationship: expected label 'places', got %v", rel1.Label)
+	}
+	if rel1.Type != ast.ERRelationOneToMany {
+		t.Errorf("First relationship: expected one-to-many type, got %s", rel1.Type)
+	}
+
+	// Check second relationship (many-to-many with dots)
+	rel2 := diagram.Relations[1]
+	if rel2.From != "ORDER" || rel2.To != "LINE-ITEM" {
+		t.Errorf("Second relationship: expected ORDER -> LINE-ITEM, got %s -> %s", rel2.From, rel2.To)
+	}
+	if rel2.Label == nil || *rel2.Label != "contains" {
+		t.Errorf("Second relationship: expected label 'contains', got %v", rel2.Label)
+	}
+	if rel2.Type != ast.ERRelationManyToManyAlt {
+		t.Errorf("Second relationship: expected many-to-many-alt type, got %s", rel2.Type)
+	}
+}

pkg/parser/gantt.go

@@ -175,8 +175,21 @@ func (p *GanttParser) parseSection() error {
 
 // parseTask parses task definitions
 func (p *GanttParser) parseTask() error {
-	// Parse task name
-	taskName := p.advance().Value
+	// Parse task name (may be multiple words)
+	var taskNameParts []string
+	for !p.check(lexer.TokenColon) && !p.isAtEnd() {
+		if p.check(lexer.TokenID) || p.check(lexer.TokenNumber) {
+			taskNameParts = append(taskNameParts, p.advance().Value)
+		} else {
+			break
+		}
+	}
+
+	if len(taskNameParts) == 0 {
+		return p.error("expected task name")
+	}
+
+	taskName := strings.Join(taskNameParts, " ")
 
 	// Expect colon
 	if !p.check(lexer.TokenColon) {
@@ -184,6 +197,16 @@ func (p *GanttParser) parseTask() error {
 	}
 	p.advance()
 
+	// Check if there's a task ID immediately after colon
+	var taskID string
+	if p.check(lexer.TokenID) && !p.checkKeyword("after") && !p.checkKeyword("done") && !p.checkKeyword("active") && !p.checkKeyword("crit") {
+		taskID = p.advance().Value
+		// Skip comma if present
+		if p.check(lexer.TokenComma) {
+			p.advance()
+		}
+	}
+
 	// Parse task data
 	var taskDataParts []string
 	for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
@@ -200,9 +223,15 @@ func (p *GanttParser) parseTask() error {
 		Dependencies: make([]string, 0),
 	}
 
+	// Use taskID if provided
+	if taskID != "" {
+		task.Dependencies = append(task.Dependencies, taskID)
+	}
+
 	// Parse task data (status, dates, dependencies)
 	if taskData != "" {
-		parts := strings.Fields(taskData)
+		// Split by comma first, then by spaces within each part
+		parts := strings.Split(taskData, ",")
 		for _, part := range parts {
 			part = strings.TrimSpace(part)
 			if part == "" {
@@ -226,9 +255,15 @@ func (p *GanttParser) parseTask() error {
 					} else if task.End == nil {
 						task.End = &part
 					}
-				} else if strings.HasSuffix(part, "d") || strings.HasSuffix(part, "w") {
+				} else if strings.HasSuffix(part, "d") || strings.HasSuffix(part, "w") || strings.HasSuffix(part, "m") || strings.HasSuffix(part, "y") {
 					// Looks like a duration
 					task.Duration = &part
+				} else if strings.HasPrefix(part, "after") {
+					// This is a dependency
+					task.Dependencies = append(task.Dependencies, part)
+				} else {
+					// Could be a task ID or other identifier
+					task.Dependencies = append(task.Dependencies, part)
 				}
 			}
 		}

pkg/parser/gantt_test.go

@@ -0,0 +1,166 @@
+package parser
+
+import (
+	"mermaid-go/pkg/ast"
+	"mermaid-go/pkg/renderer"
+	"strings"
+	"testing"
+)
+
+func TestGanttParser_BasicFunctionality(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name: "Basic Gantt Chart",
+			input: `gantt
+    title A Gantt Diagram
+    dateFormat YYYY-MM-DD
+    section Section
+    A task :a1, 2014-01-01, 30d
+    Another task :after a1, 45d`,
+			expected: `gantt
+    title A Gantt Diagram
+    dateFormat YYYY-MM-DD
+    section Section
+    A task : a1 2014-01-01 30d
+    Another task : after a1 45d
+`,
+		},
+		{
+			name: "Multiple Sections",
+			input: `gantt
+    title Project Timeline
+    section Design
+    UI Design :design, 2024-01-01, 14d
+    API Design :api, after design, 10d
+    section Development
+    Frontend :frontend, after api, 21d
+    Backend :backend, after api, 21d`,
+			expected: `gantt
+    title Project Timeline
+    dateFormat YYYY-MM-DD
+    section Design
+    UI Design : design 2024-01-01 14d
+    API Design : api after design 10d
+    section Development
+    Frontend : frontend after api 21d
+    Backend : backend after api 21d
+`,
+		},
+		{
+			name: "Task Status",
+			input: `gantt
+    title Task Status Example
+    section Completed Tasks
+    Task 1 :done, 2024-01-01, 7d
+    Task 2 :active, 2024-01-08, 5d
+    Task 3 :crit, 2024-01-13, 3d`,
+			expected: `gantt
+    title Task Status Example
+    dateFormat YYYY-MM-DD
+    section Completed Tasks
+    Task 1 : done 2024-01-01 7d
+    Task 2 : 2024-01-08 5d
+    Task 3 : crit 2024-01-13 3d
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewGanttParser()
+			diagram, err := parser.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse: %v", err)
+			}
+
+			// Test rendering
+			renderer := renderer.NewGanttRenderer()
+			output, err := renderer.Render(diagram)
+			if err != nil {
+				t.Fatalf("Failed to render: %v", err)
+			}
+
+			// Normalize whitespace for comparison
+			expected := strings.TrimSpace(tt.expected)
+			actual := strings.TrimSpace(output)
+
+			if actual != expected {
+				t.Errorf("Expected:\n%s\nGot:\n%s", expected, actual)
+			}
+		})
+	}
+}
+
+func TestGanttParser_DateFormatParsing(t *testing.T) {
+	input := `gantt
+    title Date Format Test
+    dateFormat DD-MM-YYYY
+    section Test
+    Task : task1, 01-01-2024, 7d`
+
+	parser := NewGanttParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	if diagram.DateFormat != "DD-MM-YYYY" {
+		t.Errorf("Expected dateFormat 'DD-MM-YYYY', got '%s'", diagram.DateFormat)
+	}
+
+	if diagram.Title == nil || *diagram.Title != "Date Format Test" {
+		t.Errorf("Expected title 'Date Format Test', got '%v'", diagram.Title)
+	}
+}
+
+func TestGanttParser_TaskParsing(t *testing.T) {
+	input := `gantt
+    title Task Parsing Test
+    section Tasks
+    Simple Task : task1, 2024-01-01, 7d
+    Task with Status :done, task2, 2024-01-08, 5d
+    Task with Dependencies :after task1, task3, 2024-01-13, 3d`
+
+	parser := NewGanttParser()
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse: %v", err)
+	}
+
+	if len(diagram.Sections) != 1 {
+		t.Fatalf("Expected 1 section, got %d", len(diagram.Sections))
+	}
+
+	section := diagram.Sections[0]
+	if len(section.Tasks) != 3 {
+		t.Fatalf("Expected 3 tasks, got %d", len(section.Tasks))
+	}
+
+	// Check first task
+	task1 := section.Tasks[0]
+	if task1.Name != "Simple Task" {
+		t.Errorf("Task 1: expected name 'Simple Task', got '%s'", task1.Name)
+	}
+	if task1.Status != ast.GanttStatusActive {
+		t.Errorf("Task 1: expected status 'active', got '%s'", task1.Status)
+	}
+
+	// Check second task
+	task2 := section.Tasks[1]
+	if task2.Name != "Task with Status" {
+		t.Errorf("Task 2: expected name 'Task with Status', got '%s'", task2.Name)
+	}
+	if task2.Status != ast.GanttStatusDone {
+		t.Errorf("Task 2: expected status 'done', got '%s'", task2.Status)
+	}
+
+	// Check third task
+	task3 := section.Tasks[2]
+	if task3.Name != "Task with Dependencies" {
+		t.Errorf("Task 3: expected name 'Task with Dependencies', got '%s'", task3.Name)
+	}
+}

pkg/parser/main.go

@@ -0,0 +1,219 @@
+package parser
+
+import (
+	"fmt"
+	"mermaid-go/pkg/ast"
+	"mermaid-go/pkg/detector"
+)
+
+// MermaidParser is the main parser that can handle all diagram types
+type MermaidParser struct {
+	detector *detector.DetectorRegistry
+}
+
+// NewMermaidParser creates a new main parser
+func NewMermaidParser() *MermaidParser {
+	return &MermaidParser{
+		detector: detector.NewDetectorRegistry(),
+	}
+}
+
+// Parse parses mermaid text and returns the appropriate diagram AST
+func (p *MermaidParser) Parse(input string) (ast.Diagram, error) {
+	// First, detect the diagram type
+	diagramType := p.detector.DetectDiagramType(input)
+
+	switch diagramType {
+	case detector.DiagramTypeSequence:
+		return p.parseSequence(input)
+	case detector.DiagramTypeState, detector.DiagramTypeStateV2:
+		return p.parseState(input)
+	case detector.DiagramTypeFlowchart:
+		return p.parseFlowchart(input)
+	case detector.DiagramTypeClass:
+		return p.parseClass(input)
+	case detector.DiagramTypeER:
+		return p.parseER(input)
+	case detector.DiagramTypeGantt:
+		return p.parseGantt(input)
+	case detector.DiagramTypePie:
+		return p.parsePie(input)
+	case detector.DiagramTypeGit:
+		return p.parseGit(input)
+	case detector.DiagramTypeUserJourney:
+		return p.parseUserJourney(input)
+	case detector.DiagramTypeTimeline:
+		return p.parseTimeline(input)
+	case detector.DiagramTypeMindmap:
+		return p.parseMindmap(input)
+	case detector.DiagramTypeKanban:
+		return p.parseKanban(input)
+	case detector.DiagramTypeSankey:
+		return p.parseSankey(input)
+	case detector.DiagramTypeXYChart:
+		return p.parseXYChart(input)
+	case detector.DiagramTypeQuadrant:
+		return p.parseQuadrant(input)
+	case detector.DiagramTypeRequirement:
+		return p.parseRequirement(input)
+	case detector.DiagramTypeBlock:
+		return p.parseBlock(input)
+	case detector.DiagramTypeC4:
+		return p.parseC4(input)
+	case detector.DiagramTypeArchitecture:
+		return p.parseArchitecture(input)
+	case detector.DiagramTypeRadar:
+		return p.parseRadar(input)
+	case detector.DiagramTypeTreemap:
+		return p.parseTreemap(input)
+	case detector.DiagramTypePacket:
+		return p.parsePacket(input)
+	case detector.DiagramTypeInfo:
+		return p.parseInfo(input)
+	default:
+		return nil, fmt.Errorf("unsupported diagram type: %s", diagramType)
+	}
+}
+
+// GetDiagramType returns the detected diagram type without parsing
+func (p *MermaidParser) GetDiagramType(input string) detector.DiagramType {
+	return p.detector.DetectDiagramType(input)
+}
+
+// parseSequence parses sequence diagrams
+func (p *MermaidParser) parseSequence(input string) (ast.Diagram, error) {
+	parser := NewSequenceParser()
+	return parser.Parse(input)
+}
+
+// parseState parses state diagrams
+func (p *MermaidParser) parseState(input string) (ast.Diagram, error) {
+	parser := NewStateParser()
+	return parser.Parse(input)
+}
+
+// parseFlowchart parses flowcharts (placeholder implementation)
+func (p *MermaidParser) parseFlowchart(input string) (ast.Diagram, error) {
+	// TODO: Implement flowchart parser
+	return nil, fmt.Errorf("flowchart parsing not yet implemented")
+}
+
+// parseClass parses class diagrams (placeholder implementation)
+func (p *MermaidParser) parseClass(input string) (ast.Diagram, error) {
+	// TODO: Implement class diagram parser
+	return nil, fmt.Errorf("class diagram parsing not yet implemented")
+}
+
+// parseER parses ER diagrams (placeholder implementation)
+func (p *MermaidParser) parseER(input string) (ast.Diagram, error) {
+	// TODO: Implement ER diagram parser
+	return nil, fmt.Errorf("ER diagram parsing not yet implemented")
+}
+
+// parseGantt parses Gantt charts (placeholder implementation)
+func (p *MermaidParser) parseGantt(input string) (ast.Diagram, error) {
+	// TODO: Implement Gantt chart parser
+	return nil, fmt.Errorf("Gantt chart parsing not yet implemented")
+}
+
+// parsePie parses pie charts (placeholder implementation)
+func (p *MermaidParser) parsePie(input string) (ast.Diagram, error) {
+	// TODO: Implement pie chart parser
+	return nil, fmt.Errorf("pie chart parsing not yet implemented")
+}
+
+// parseGit parses git graphs (placeholder implementation)
+func (p *MermaidParser) parseGit(input string) (ast.Diagram, error) {
+	// TODO: Implement git graph parser
+	return nil, fmt.Errorf("git graph parsing not yet implemented")
+}
+
+// parseUserJourney parses user journey diagrams (placeholder implementation)
+func (p *MermaidParser) parseUserJourney(input string) (ast.Diagram, error) {
+	// TODO: Implement user journey parser
+	return nil, fmt.Errorf("user journey parsing not yet implemented")
+}
+
+// parseTimeline parses timeline diagrams (placeholder implementation)
+func (p *MermaidParser) parseTimeline(input string) (ast.Diagram, error) {
+	// TODO: Implement timeline parser
+	return nil, fmt.Errorf("timeline parsing not yet implemented")
+}
+
+// parseMindmap parses mindmaps (placeholder implementation)
+func (p *MermaidParser) parseMindmap(input string) (ast.Diagram, error) {
+	// TODO: Implement mindmap parser
+	return nil, fmt.Errorf("mindmap parsing not yet implemented")
+}
+
+// parseKanban parses kanban diagrams (placeholder implementation)
+func (p *MermaidParser) parseKanban(input string) (ast.Diagram, error) {
+	// TODO: Implement kanban parser
+	return nil, fmt.Errorf("kanban parsing not yet implemented")
+}
+
+// parseSankey parses Sankey diagrams (placeholder implementation)
+func (p *MermaidParser) parseSankey(input string) (ast.Diagram, error) {
+	// TODO: Implement Sankey diagram parser
+	return nil, fmt.Errorf("Sankey diagram parsing not yet implemented")
+}
+
+// parseXYChart parses XY charts (placeholder implementation)
+func (p *MermaidParser) parseXYChart(input string) (ast.Diagram, error) {
+	// TODO: Implement XY chart parser
+	return nil, fmt.Errorf("XY chart parsing not yet implemented")
+}
+
+// parseQuadrant parses quadrant charts (placeholder implementation)
+func (p *MermaidParser) parseQuadrant(input string) (ast.Diagram, error) {
+	// TODO: Implement quadrant chart parser
+	return nil, fmt.Errorf("quadrant chart parsing not yet implemented")
+}
+
+// parseRequirement parses requirement diagrams (placeholder implementation)
+func (p *MermaidParser) parseRequirement(input string) (ast.Diagram, error) {
+	// TODO: Implement requirement diagram parser
+	return nil, fmt.Errorf("requirement diagram parsing not yet implemented")
+}
+
+// parseBlock parses block diagrams (placeholder implementation)
+func (p *MermaidParser) parseBlock(input string) (ast.Diagram, error) {
+	// TODO: Implement block diagram parser
+	return nil, fmt.Errorf("block diagram parsing not yet implemented")
+}
+
+// parseC4 parses C4 diagrams (placeholder implementation)
+func (p *MermaidParser) parseC4(input string) (ast.Diagram, error) {
+	// TODO: Implement C4 diagram parser
+	return nil, fmt.Errorf("C4 diagram parsing not yet implemented")
+}
+
+// parseArchitecture parses architecture diagrams (placeholder implementation)
+func (p *MermaidParser) parseArchitecture(input string) (ast.Diagram, error) {
+	// TODO: Implement architecture diagram parser
+	return nil, fmt.Errorf("architecture diagram parsing not yet implemented")
+}
+
+// parseRadar parses radar charts (placeholder implementation)
+func (p *MermaidParser) parseRadar(input string) (ast.Diagram, error) {
+	// TODO: Implement radar chart parser
+	return nil, fmt.Errorf("radar chart parsing not yet implemented")
+}
+
+// parseTreemap parses treemaps (placeholder implementation)
+func (p *MermaidParser) parseTreemap(input string) (ast.Diagram, error) {
+	// TODO: Implement treemap parser
+	return nil, fmt.Errorf("treemap parsing not yet implemented")
+}
+
+// parsePacket parses packet diagrams (placeholder implementation)
+func (p *MermaidParser) parsePacket(input string) (ast.Diagram, error) {
+	// TODO: Implement packet diagram parser
+	return nil, fmt.Errorf("packet diagram parsing not yet implemented")
+}
+
+// parseInfo parses info diagrams (placeholder implementation)
+func (p *MermaidParser) parseInfo(input string) (ast.Diagram, error) {
+	// TODO: Implement info diagram parser
+	return nil, fmt.Errorf("info diagram parsing not yet implemented")
+}

pkg/parser/main_test.go

@@ -0,0 +1,144 @@
+package parser
+
+import (
+	"mermaid-go/pkg/detector"
+	"testing"
+)
+
+func TestMermaidParser_GetDiagramType(t *testing.T) {
+	parser := NewMermaidParser()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected detector.DiagramType
+	}{
+		{
+			name:     "Sequence Diagram",
+			input:    "sequenceDiagram\n    A -> B : hello",
+			expected: detector.DiagramTypeSequence,
+		},
+		{
+			name:     "State Diagram V2",
+			input:    "stateDiagram-v2\n    [*] --> State1",
+			expected: detector.DiagramTypeStateV2,
+		},
+		{
+			name:     "State Diagram",
+			input:    "stateDiagram\n    [*] --> State1",
+			expected: detector.DiagramTypeState,
+		},
+		{
+			name:     "Flowchart",
+			input:    "flowchart TD\n    A --> B",
+			expected: detector.DiagramTypeFlowchart,
+		},
+		{
+			name:     "Class Diagram",
+			input:    "classDiagram\n    class Animal",
+			expected: detector.DiagramTypeClass,
+		},
+		{
+			name:     "Unknown Diagram",
+			input:    "unknownDiagram\n    some content",
+			expected: detector.DiagramTypeUnknown,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := parser.GetDiagramType(tt.input)
+			if result != tt.expected {
+				t.Errorf("Expected %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestMermaidParser_Parse(t *testing.T) {
+	parser := NewMermaidParser()
+
+	tests := []struct {
+		name        string
+		input       string
+		expectError bool
+	}{
+		{
+			name:        "Valid Sequence Diagram",
+			input:       "sequenceDiagram\n    A -> B : hello",
+			expectError: false,
+		},
+		{
+			name:        "Valid State Diagram",
+			input:       "stateDiagram-v2\n    [*] --> State1",
+			expectError: false,
+		},
+		{
+			name:        "Unsupported Diagram Type",
+			input:       "flowchart TD\n    A --> B",
+			expectError: true,
+		},
+		{
+			name:        "Unknown Diagram Type",
+			input:       "unknownDiagram\n    some content",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := parser.Parse(tt.input)
+			if tt.expectError && err == nil {
+				t.Errorf("Expected error but got none")
+			}
+			if !tt.expectError && err != nil {
+				t.Errorf("Expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestMermaidParser_Parse_SequenceDiagram(t *testing.T) {
+	parser := NewMermaidParser()
+
+	input := `sequenceDiagram
+    participant A
+    participant B
+    A -> B : hello
+    B --> A : response`
+
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse sequence diagram: %v", err)
+	}
+
+	if diagram == nil {
+		t.Fatal("Diagram is nil")
+	}
+
+	if diagram.Type() != "sequence" {
+		t.Errorf("Expected diagram type 'sequence', got '%s'", diagram.Type())
+	}
+}
+
+func TestMermaidParser_Parse_StateDiagram(t *testing.T) {
+	parser := NewMermaidParser()
+
+	input := `stateDiagram-v2
+    [*] --> State1
+    State1 --> State2 : transition
+    State2 --> [*]`
+
+	diagram, err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse state diagram: %v", err)
+	}
+
+	if diagram == nil {
+		t.Fatal("Diagram is nil")
+	}
+
+	if diagram.Type() != "state" {
+		t.Errorf("Expected diagram type 'state', got '%s'", diagram.Type())
+	}
+}

pkg/parser/mermaid.go

@@ -1,202 +0,0 @@
-// Package parser provides the main parser router for all diagram types
-package parser
-
-import (
-	"fmt"
-	"strings"
-
-	"mermaid-go/pkg/ast"
-)
-
-// MermaidParser is the main parser that routes to specific diagram parsers
-type MermaidParser struct{}
-
-// NewMermaidParser creates a new main mermaid parser
-func NewMermaidParser() *MermaidParser {
-	return &MermaidParser{}
-}
-
-// Parse parses a mermaid diagram string and returns the appropriate AST
-func (p *MermaidParser) Parse(input string) (ast.Diagram, error) {
-	// Detect diagram type from the input
-	diagramType := p.detectDiagramType(input)
-
-	switch diagramType {
-	case ast.DiagramTypeFlowchart:
-		parser := NewFlowchartParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeSequence:
-		parser := NewSequenceParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeClassDiagram:
-		parser := NewClassParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeStateDiagram:
-		parser := NewStateParser()
-		return parser.Parse(input)
-	case ast.DiagramTypePie:
-		parser := NewPieParser()
-		return parser.Parse(input)
-	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)
-	}
-}
-
-// detectDiagramType analyzes the input to determine the diagram type
-func (p *MermaidParser) detectDiagramType(input string) ast.DiagramType {
-	// Clean input and get first meaningful line
-	lines := strings.Split(input, "\n")
-
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "%%") {
-			continue // Skip empty lines and comments
-		}
-
-		// Check for explicit diagram type declarations
-		lowerLine := strings.ToLower(line)
-
-		if strings.HasPrefix(lowerLine, "sequencediagram") {
-			return ast.DiagramTypeSequence
-		}
-		if strings.HasPrefix(lowerLine, "classdiagram") {
-			return ast.DiagramTypeClassDiagram
-		}
-		if strings.HasPrefix(lowerLine, "statediagram") {
-			return ast.DiagramTypeStateDiagram
-		}
-		if strings.HasPrefix(lowerLine, "flowchart") ||
-			strings.HasPrefix(lowerLine, "graph") {
-			return ast.DiagramTypeFlowchart
-		}
-		if strings.HasPrefix(lowerLine, "erdiagram") {
-			return ast.DiagramTypeERDiagram
-		}
-		if strings.HasPrefix(lowerLine, "journey") {
-			return ast.DiagramTypeUserJourney
-		}
-		if strings.HasPrefix(lowerLine, "timeline") {
-			return ast.DiagramTypeTimeline
-		}
-		if strings.HasPrefix(lowerLine, "gantt") {
-			return ast.DiagramTypeGantt
-		}
-		if strings.HasPrefix(lowerLine, "pie") {
-			return ast.DiagramTypePie
-		}
-		if strings.HasPrefix(lowerLine, "quadrantchart") {
-			return ast.DiagramTypeQuadrant
-		}
-		if strings.HasPrefix(lowerLine, "requirementdiagram") {
-			return ast.DiagramTypeRequirement
-		}
-		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
-
-		// Look for sequence diagram patterns
-		if strings.Contains(lowerLine, "participant") ||
-			strings.Contains(lowerLine, "actor") ||
-			strings.Contains(lowerLine, "-->") ||
-			strings.Contains(lowerLine, "->>") {
-			return ast.DiagramTypeSequence
-		}
-
-		// Look for class diagram patterns
-		if strings.Contains(lowerLine, "class ") ||
-			strings.Contains(lowerLine, "--|>") ||
-			strings.Contains(lowerLine, "--*") ||
-			strings.Contains(lowerLine, "--o") {
-			return ast.DiagramTypeClassDiagram
-		}
-
-		// Look for state diagram patterns
-		if strings.Contains(lowerLine, "[*]") ||
-			strings.Contains(lowerLine, "state ") {
-			return ast.DiagramTypeStateDiagram
-		}
-
-		// Default to flowchart for backwards compatibility
-		break
-	}
-
-	// Default fallback
-	return ast.DiagramTypeFlowchart
-}
-
-// ParseWithType forces parsing with a specific diagram type
-func (p *MermaidParser) ParseWithType(input string, diagramType ast.DiagramType) (ast.Diagram, error) {
-	switch diagramType {
-	case ast.DiagramTypeFlowchart:
-		parser := NewFlowchartParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeSequence:
-		parser := NewSequenceParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeClassDiagram:
-		parser := NewClassParser()
-		return parser.Parse(input)
-	case ast.DiagramTypeStateDiagram:
-		parser := NewStateParser()
-		return parser.Parse(input)
-	case ast.DiagramTypePie:
-		parser := NewPieParser()
-		return parser.Parse(input)
-	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/sequence.go

@@ -14,6 +14,8 @@ type SequenceParser struct {
 	tokens  []lexer.Token
 	current int
 	diagram *ast.SequenceDiagram
+	// messageCollector allows routing parsed messages into current container (loop/alt/opt/par)
+	messageCollector func(msg *ast.SequenceMessage)
 }
 
 // NewSequenceParser creates a new sequence parser
@@ -36,6 +38,9 @@ func (p *SequenceParser) Parse(input string) (*ast.SequenceDiagram, error) {
 	p.tokens = lexer.FilterTokens(tokens)
 	p.current = 0
 	p.diagram = ast.NewSequenceDiagram()
+	p.messageCollector = func(msg *ast.SequenceMessage) {
+		p.diagram.Messages = append(p.diagram.Messages, msg)
+	}
 
 	// Parse document
 	err = p.parseDocument()
@@ -91,6 +96,15 @@ func (p *SequenceParser) parseStatement() error {
 		return p.parsePar()
 	case p.checkKeyword("box"):
 		return p.parseBox()
+	case p.checkKeyword("rect"):
+		return p.parseRect()
+	case p.checkKeyword("critical"):
+		return p.parseCritical()
+	case p.checkKeyword("option"):
+		_, err := p.parseOption()
+		return err
+	case p.checkKeyword("break"):
+		return p.parseBreak()
 	case p.checkKeyword("activate"):
 		return p.parseActivate()
 	case p.checkKeyword("deactivate"):
@@ -201,7 +215,12 @@ func (p *SequenceParser) parseMessage() error {
 		Type:    msgType,
 	}
 
-	p.diagram.Messages = append(p.diagram.Messages, seqMsg)
+	// Route message to current collector (global or container)
+	if p.messageCollector != nil {
+		p.messageCollector(seqMsg)
+	} else {
+		p.diagram.Messages = append(p.diagram.Messages, seqMsg)
+	}
 
 	// Ensure participants exist
 	p.ensureParticipant(from)
@@ -214,16 +233,44 @@ func (p *SequenceParser) parseMessage() error {
 func (p *SequenceParser) parseArrowType() (ast.SequenceMessageType, error) {
 	token := p.peek()
 
-	if p.check(lexer.TokenArrowSolid) {
+	// Handle different arrow token types from lexer
+	switch token.Type {
+	case lexer.TokenArrowSolid:
 		p.advance()
 		return ast.MessageTypeSolid, nil
-	} else if p.check(lexer.TokenArrowDotted) {
+	case lexer.TokenArrowDotted:
 		p.advance()
 		return ast.MessageTypeDotted, nil
-	} else if token.Type == lexer.TokenMinus && p.checkNext(lexer.TokenCloseAngle) {
-		p.advance() // consume '-'
-		p.advance() // consume '>'
-		return ast.MessageTypeSolid, nil
+	case lexer.TokenArrowCross:
+		p.advance()
+		return ast.MessageTypeSolidCross, nil
+	case lexer.TokenArrowOpen:
+		p.advance()
+		return ast.MessageTypeSolidOpen, nil
+	default:
+		// Fallback for unrecognized arrow patterns
+		if token.Value == "-->" {
+			p.advance()
+			return ast.MessageTypeDotted, nil
+		} else if token.Value == "->" {
+			p.advance()
+			return ast.MessageTypeSolid, nil
+		} else if token.Value == "-x" {
+			p.advance()
+			return ast.MessageTypeSolidCross, nil
+		} else if token.Value == "-->x" || token.Value == "--x" {
+			p.advance()
+			return ast.MessageTypeDottedCross, nil
+		} else if token.Value == "-)" {
+			p.advance()
+			return ast.MessageTypeSolidOpen, nil
+		} else if token.Value == "--)" {
+			p.advance()
+			return ast.MessageTypeDottedOpen, nil
+		} else if token.Value == "<->" {
+			p.advance()
+			return ast.MessageTypeBidirectional, nil
+		}
 	}
 
 	return "", p.error("expected arrow type")
@@ -304,6 +351,10 @@ func (p *SequenceParser) parseLoop() error {
 		Messages: make([]*ast.SequenceMessage, 0),
 	}
 
+	// Temporarily redirect messages into loop
+	prev := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) { loop.Messages = append(loop.Messages, msg) }
+
 	// Parse statements until 'end'
 	for !p.isAtEnd() {
 		if p.checkKeyword("end") {
@@ -311,9 +362,11 @@ func (p *SequenceParser) parseLoop() error {
 			break
 		}
 		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prev
 			return err
 		}
 	}
+	p.messageCollector = prev
 
 	p.diagram.Loops = append(p.diagram.Loops, loop)
 	return nil
@@ -339,24 +392,41 @@ func (p *SequenceParser) parseAlt() error {
 		ElseMessages: make([]*ast.SequenceMessage, 0),
 	}
 
-	// Parse statements until 'else' or 'end'
+	// First phase: IF block
+	prev := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) { alt.IfMessages = append(alt.IfMessages, msg) }
 	for !p.isAtEnd() {
 		if p.checkKeyword("else") {
 			p.advance()
-			// Skip to next line
 			if p.check(lexer.TokenNewline) {
 				p.advance()
 			}
-			continue
+			break
 		}
+		if p.checkKeyword("end") {
+			p.advance()
+			p.messageCollector = prev
+			p.diagram.Alts = append(p.diagram.Alts, alt)
+			return nil
+		}
+		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prev
+			return err
+		}
+	}
+	// Second phase: ELSE block
+	p.messageCollector = func(msg *ast.SequenceMessage) { alt.ElseMessages = append(alt.ElseMessages, msg) }
+	for !p.isAtEnd() {
 		if p.checkKeyword("end") {
 			p.advance()
 			break
 		}
 		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prev
 			return err
 		}
 	}
+	p.messageCollector = prev
 
 	p.diagram.Alts = append(p.diagram.Alts, alt)
 	return nil
@@ -381,6 +451,9 @@ func (p *SequenceParser) parseOpt() error {
 		Messages: make([]*ast.SequenceMessage, 0),
 	}
 
+	prev := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) { opt.Messages = append(opt.Messages, msg) }
+
 	// Parse statements until 'end'
 	for !p.isAtEnd() {
 		if p.checkKeyword("end") {
@@ -388,10 +461,12 @@ func (p *SequenceParser) parseOpt() error {
 			break
 		}
 		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prev
 			return err
 		}
 	}
 
+	p.messageCollector = prev
 	p.diagram.Opts = append(p.diagram.Opts, opt)
 	return nil
 }
@@ -412,6 +487,9 @@ func (p *SequenceParser) parsePar() error {
 		Messages: make([]*ast.SequenceMessage, 0),
 	}
 
+	prev := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) { currentSection.Messages = append(currentSection.Messages, msg) }
+
 	// Parse statements until 'and' or 'end'
 	for !p.isAtEnd() {
 		if p.checkKeyword("and") {
@@ -430,6 +508,8 @@ func (p *SequenceParser) parsePar() error {
 				Label:    &label,
 				Messages: make([]*ast.SequenceMessage, 0),
 			}
+			// redirect collector to new section
+			p.messageCollector = func(msg *ast.SequenceMessage) { currentSection.Messages = append(currentSection.Messages, msg) }
 
 			if p.check(lexer.TokenNewline) {
 				p.advance()
@@ -441,12 +521,14 @@ func (p *SequenceParser) parsePar() error {
 			break
 		}
 		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prev
 			return err
 		}
 	}
 
 	// Add final section
 	par.Sections = append(par.Sections, currentSection)
+	p.messageCollector = prev
 	p.diagram.Pars = append(p.diagram.Pars, par)
 	return nil
 }
@@ -494,6 +576,190 @@ func (p *SequenceParser) parseBox() error {
 	return nil
 }
 
+// parseRect parses 'rect ... end' blocks
+func (p *SequenceParser) parseRect() error {
+	p.advance() // consume 'rect'
+
+	var color *string
+	// Parse optional color (collect all tokens until newline)
+	var colorParts []string
+	for !p.isAtEnd() && !p.check(lexer.TokenNewline) {
+		token := p.advance()
+		colorParts = append(colorParts, token.Value)
+	}
+
+	if len(colorParts) > 0 {
+		colorVal := strings.Join(colorParts, "")
+		color = &colorVal
+	}
+	if p.check(lexer.TokenNewline) {
+		p.advance()
+	}
+
+	rect := &ast.SequenceRect{
+		Color:    color,
+		Messages: make([]*ast.SequenceMessage, 0),
+	}
+
+	// Set up message collector for this rect
+	prevCollector := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) {
+		rect.Messages = append(rect.Messages, msg)
+	}
+
+	// Parse inner statements until 'end'
+	for !p.isAtEnd() {
+		if p.checkKeyword("end") {
+			p.advance()
+			break
+		}
+		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prevCollector
+			return err
+		}
+	}
+
+	// Restore previous collector
+	p.messageCollector = prevCollector
+	p.diagram.Rects = append(p.diagram.Rects, rect)
+	return nil
+}
+
+// parseCritical parses 'critical ... option ... end' blocks
+func (p *SequenceParser) parseCritical() error {
+	p.advance() // consume 'critical'
+
+	// Parse label (rest of line)
+	var labelParts []string
+	for !p.isAtEnd() && !p.check(lexer.TokenNewline) {
+		labelParts = append(labelParts, p.advance().Value)
+	}
+	if p.check(lexer.TokenNewline) {
+		p.advance()
+	}
+	label := strings.TrimSpace(strings.Join(labelParts, " "))
+
+	critical := &ast.SequenceCritical{
+		Label:    label,
+		Options:  make([]*ast.SequenceOption, 0),
+		Messages: make([]*ast.SequenceMessage, 0),
+	}
+
+	// Set up message collector for this critical
+	prevCollector := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) {
+		critical.Messages = append(critical.Messages, msg)
+	}
+
+	for !p.isAtEnd() {
+		if p.checkKeyword("end") {
+			p.advance()
+			break
+		}
+		if p.checkKeyword("option") { // allow options sections
+			option, err := p.parseOption()
+			if err != nil {
+				p.messageCollector = prevCollector
+				return err
+			}
+			critical.Options = append(critical.Options, option)
+			continue
+		}
+		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prevCollector
+			return err
+		}
+	}
+
+	// Restore previous collector
+	p.messageCollector = prevCollector
+	p.diagram.Criticals = append(p.diagram.Criticals, critical)
+	return nil
+}
+
+// parseOption parses an 'option ...' section within critical
+func (p *SequenceParser) parseOption() (*ast.SequenceOption, error) {
+	p.advance() // consume 'option'
+
+	// Parse label (rest of line)
+	var labelParts []string
+	for !p.isAtEnd() && !p.check(lexer.TokenNewline) {
+		labelParts = append(labelParts, p.advance().Value)
+	}
+	if p.check(lexer.TokenNewline) {
+		p.advance()
+	}
+	label := strings.TrimSpace(strings.Join(labelParts, " "))
+
+	option := &ast.SequenceOption{
+		Label:    label,
+		Messages: make([]*ast.SequenceMessage, 0),
+	}
+
+	// Set up message collector for this option
+	prevCollector := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) {
+		option.Messages = append(option.Messages, msg)
+	}
+
+	// parse statements until next 'option' or 'end'
+	for !p.isAtEnd() {
+		if p.checkKeyword("option") || p.checkKeyword("end") {
+			break
+		}
+		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prevCollector
+			return nil, err
+		}
+	}
+
+	// Restore previous collector
+	p.messageCollector = prevCollector
+	return option, nil
+}
+
+// parseBreak parses 'break ... end' blocks
+func (p *SequenceParser) parseBreak() error {
+	p.advance() // consume 'break'
+
+	// Parse label (rest of line)
+	var labelParts []string
+	for !p.isAtEnd() && !p.check(lexer.TokenNewline) {
+		labelParts = append(labelParts, p.advance().Value)
+	}
+	if p.check(lexer.TokenNewline) {
+		p.advance()
+	}
+	label := strings.TrimSpace(strings.Join(labelParts, " "))
+
+	breakBlock := &ast.SequenceBreak{
+		Label:    label,
+		Messages: make([]*ast.SequenceMessage, 0),
+	}
+
+	// Set up message collector for this break
+	prevCollector := p.messageCollector
+	p.messageCollector = func(msg *ast.SequenceMessage) {
+		breakBlock.Messages = append(breakBlock.Messages, msg)
+	}
+
+	for !p.isAtEnd() {
+		if p.checkKeyword("end") {
+			p.advance()
+			break
+		}
+		if err := p.parseStatement(); err != nil {
+			p.messageCollector = prevCollector
+			return err
+		}
+	}
+
+	// Restore previous collector
+	p.messageCollector = prevCollector
+	p.diagram.Breaks = append(p.diagram.Breaks, breakBlock)
+	return nil
+}
+
 func (p *SequenceParser) parseActivate() error {
 	p.advance() // consume 'activate'
 
@@ -567,7 +833,14 @@ func (p *SequenceParser) checkKeyword(keyword string) bool {
 		return false
 	}
 	token := p.peek()
-	return token.Type == lexer.TokenID && strings.ToLower(token.Value) == strings.ToLower(keyword)
+
+	// Handle special keywords that have their own token types
+	switch keyword {
+	case "end":
+		return token.Type == lexer.TokenEnd
+	default:
+		return token.Type == lexer.TokenID && strings.EqualFold(token.Value, keyword)
+	}
 }
 
 func (p *SequenceParser) advance() lexer.Token {

pkg/parser/state.go

@@ -81,6 +81,12 @@ func (p *StateParser) parseStatement() error {
 		return p.parseNote()
 	case p.checkKeyword("state"):
 		return p.parseState()
+	case p.check(lexer.TokenEntry):
+		return p.parseStateAction("entry")
+	case p.check(lexer.TokenExit):
+		return p.parseStateAction("exit")
+	case p.check(lexer.TokenDo):
+		return p.parseStateAction("do")
 	case p.check(lexer.TokenOpenBracket):
 		// Handle [*] start/end states
 		return p.parseStartEndState()
@@ -261,17 +267,50 @@ func (p *StateParser) parseStateOrTransition() error {
 		return p.parseTransition(stateName)
 	}
 
-	// Check for colon (description or special type)
+	// Check for colon (description, special type, or state action)
 	if p.check(lexer.TokenColon) {
 		p.advance() // consume ':'
-		var descParts []string
-		for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
-			descParts = append(descParts, p.advance().Value)
-		}
-		if len(descParts) > 0 {
-			desc := strings.TrimSpace(strings.Join(descParts, " "))
+
+		// Check if this is a state action (entry/exit/do)
+		if p.check(lexer.TokenEntry) || p.check(lexer.TokenExit) || p.check(lexer.TokenDo) {
+			var actionType string
+			if p.check(lexer.TokenEntry) {
+				actionType = "entry"
+			} else if p.check(lexer.TokenExit) {
+				actionType = "exit"
+			} else if p.check(lexer.TokenDo) {
+				actionType = "do"
+			}
+			p.advance() // consume action type
+
+			// Parse action content (everything until newline)
+			var actionParts []string
+			for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
+				actionParts = append(actionParts, p.advance().Value)
+			}
+
+			actionContent := strings.TrimSpace(strings.Join(actionParts, " "))
 			state := p.diagram.States[stateName]
-			state.Description = &desc
+
+			switch actionType {
+			case "entry":
+				state.EntryAction = &actionContent
+			case "exit":
+				state.ExitAction = &actionContent
+			case "do":
+				state.DoAction = &actionContent
+			}
+		} else {
+			// Regular description or special type
+			var descParts []string
+			for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
+				descParts = append(descParts, p.advance().Value)
+			}
+			if len(descParts) > 0 {
+				desc := strings.TrimSpace(strings.Join(descParts, " "))
+				state := p.diagram.States[stateName]
+				state.Description = &desc
+			}
 		}
 	}
 
@@ -319,16 +358,41 @@ func (p *StateParser) parseTransition(fromState string) error {
 		To:   toState,
 	}
 
-	// Check for label
+	// Optional decorations: ':' label, '[guard]' and '/action' in any order after ':'
 	if p.check(lexer.TokenColon) {
 		p.advance() // consume ':'
-		var labelParts []string
+
+		// Collect rest of the line
+		var parts []string
 		for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
-			labelParts = append(labelParts, p.advance().Value)
+			parts = append(parts, p.advance().Value)
 		}
-		if len(labelParts) > 0 {
-			label := strings.TrimSpace(strings.Join(labelParts, " "))
-			transition.Label = &label
+		raw := strings.TrimSpace(strings.Join(parts, " "))
+
+		// Extract [guard]
+		guardStart := strings.Index(raw, "[")
+		guardEnd := strings.Index(raw, "]")
+		if guardStart >= 0 && guardEnd > guardStart {
+			cond := strings.TrimSpace(raw[guardStart+1 : guardEnd])
+			if cond != "" {
+				transition.Condition = &cond
+			}
+			// Remove guard from raw
+			raw = strings.TrimSpace(raw[:guardStart] + raw[guardEnd+1:])
+		}
+
+		// Extract '/action'
+		if slash := strings.Index(raw, "/"); slash >= 0 {
+			action := strings.TrimSpace(raw[slash+1:])
+			if action != "" {
+				transition.Action = &action
+			}
+			raw = strings.TrimSpace(raw[:slash])
+		}
+
+		if raw != "" {
+			lbl := strings.TrimSpace(raw)
+			transition.Label = &lbl
 		}
 	}
 
@@ -369,7 +433,57 @@ func (p *StateParser) parseDirection() error {
 
 // parseNote parses note statements - placeholder
 func (p *StateParser) parseNote() error {
-	return p.skipToNextStatement()
+	p.advance() // consume 'note'
+
+	// note left of <state> : text
+	// note right of <state> : text
+	// note over <state> : text (treat as over)
+
+	var place ast.NotePlace
+	if p.checkKeyword("left") {
+		p.advance()
+		if !p.checkKeyword("of") {
+			return p.error("expected 'of' after 'left'")
+		}
+		p.advance()
+		place = ast.NotePlaceLeft
+	} else if p.checkKeyword("right") {
+		p.advance()
+		if !p.checkKeyword("of") {
+			return p.error("expected 'of' after 'right'")
+		}
+		p.advance()
+		place = ast.NotePlaceRight
+	} else if p.checkKeyword("over") {
+		p.advance()
+		place = ast.NotePlaceOver
+	} else {
+		return p.error("expected note placement (left of, right of, over)")
+	}
+
+	if !p.check(lexer.TokenID) {
+		return p.error("expected state ID for note")
+	}
+	stateID := p.advance().Value
+
+	if !p.check(lexer.TokenColon) {
+		return p.error("expected ':' after state in note")
+	}
+	p.advance()
+
+	// Collect text
+	var txt []string
+	for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
+		txt = append(txt, p.advance().Value)
+	}
+	noteText := strings.TrimSpace(strings.Join(txt, " "))
+
+	// Attach to state; ensure exists
+	p.ensureState(stateID)
+	if st, ok := p.diagram.States[stateID]; ok {
+		st.Note = &ast.StateNote{Position: place, Text: noteText}
+	}
+	return nil
 }
 
 // ensureState ensures a state exists, creating it if needed
@@ -454,3 +568,51 @@ func (p *StateParser) skipToNextStatement() error {
 	}
 	return nil
 }
+
+// parseStateAction parses state actions (entry, exit, do)
+func (p *StateParser) parseStateAction(actionType string) error {
+	p.advance() // consume action type (entry/exit/do)
+
+	// Expect colon
+	if !p.check(lexer.TokenColon) {
+		return p.error("expected ':' after " + actionType)
+	}
+	p.advance() // consume ':'
+
+	// Parse state name
+	if !p.check(lexer.TokenID) {
+		return p.error("expected state name after " + actionType + " :")
+	}
+	stateName := p.advance().Value
+
+	// Ensure state exists
+	if _, exists := p.diagram.States[stateName]; !exists {
+		// Create state if it doesn't exist
+		p.diagram.States[stateName] = &ast.StateNode{
+			ID:    stateName,
+			Label: stateName,
+			Type:  ast.StateTypeDefault,
+		}
+	}
+
+	// Parse action content (everything after state name until newline)
+	var actionParts []string
+	for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
+		actionParts = append(actionParts, p.advance().Value)
+	}
+
+	actionContent := strings.TrimSpace(strings.Join(actionParts, " "))
+
+	// Set the appropriate action field
+	state := p.diagram.States[stateName]
+	switch actionType {
+	case "entry":
+		state.EntryAction = &actionContent
+	case "exit":
+		state.ExitAction = &actionContent
+	case "do":
+		state.DoAction = &actionContent
+	}
+
+	return nil
+}

pkg/renderer/class.go

@@ -33,7 +33,7 @@ func (r *ClassRenderer) Render(diagram *ast.ClassDiagram) (string, error) {
 		builder.WriteString(fmt.Sprintf("    direction %s\n", diagram.Direction))
 	}
 
-		// Render classes
+	// Render classes
 	for _, class := range diagram.Classes {
 		builder.WriteString("    class ")
 		builder.WriteString(class.ID)
@@ -138,11 +138,11 @@ func (r *ClassRenderer) Render(diagram *ast.ClassDiagram) (string, error) {
 		// Render relation type
 		switch relation.Type {
 		case ast.RelationInheritance:
-			builder.WriteString("--|>")
+			builder.WriteString("<|--")
 		case ast.RelationComposition:
-			builder.WriteString("--*")
+			builder.WriteString("*--")
 		case ast.RelationAggregation:
-			builder.WriteString("--o")
+			builder.WriteString("o--")
 		case ast.RelationAssociation:
 			builder.WriteString("-->")
 		case ast.RelationRealization:

pkg/renderer/er.go

@@ -1,4 +1,4 @@
-// Package renderer provides ER diagram rendering
+// Package renderer provides rendering functionality for ER diagrams
 package renderer
 
 import (
@@ -20,59 +20,66 @@ func NewERRenderer() *ERRenderer {
 func (r *ERRenderer) Render(diagram *ast.ERDiagram) (string, error) {
 	var builder strings.Builder
 
+	// Start with diagram declaration
 	builder.WriteString("erDiagram\n")
 
-	// Render title if present
+	// Add title if present
 	if diagram.Title != nil {
 		builder.WriteString(fmt.Sprintf("    title %s\n", *diagram.Title))
 	}
 
+	// Note: ERDiagram doesn't have a Direction field in the existing structure
+	// Direction support could be added to the AST if needed
+
 	// Render entities with attributes
 	for _, entity := range diagram.Entities {
 		if len(entity.Attributes) > 0 {
-			builder.WriteString(fmt.Sprintf("    %s {\n", r.quoteIfNeeded(entity.Name)))
+			builder.WriteString("    ")
+			builder.WriteString(entity.Name)
+			builder.WriteString(" {\n")
+
 			for _, attr := range entity.Attributes {
 				builder.WriteString("        ")
 				builder.WriteString(attr.Type)
 				builder.WriteString(" ")
 				builder.WriteString(attr.Name)
 
-				// Add key constraint if present
+				// Add key if present
 				if attr.Key != nil {
-					switch *attr.Key {
-					case ast.ERKeyPrimary:
-						builder.WriteString(" PK")
-					case ast.ERKeyForeign:
-						builder.WriteString(" FK")
-					case ast.ERKeyUnique:
-						builder.WriteString(" UK")
-					}
+					builder.WriteString(" ")
+					builder.WriteString(string(*attr.Key))
 				}
 
 				// Add comment if present
 				if attr.Comment != nil {
-					builder.WriteString(fmt.Sprintf(" \"%s\"", *attr.Comment))
+					builder.WriteString(" \"")
+					builder.WriteString(*attr.Comment)
+					builder.WriteString("\"")
 				}
 
 				builder.WriteString("\n")
 			}
+
 			builder.WriteString("    }\n")
 		}
 	}
 
 	// Render relationships
-	for _, relation := range diagram.Relations {
+	for _, rel := range diagram.Relations {
 		builder.WriteString("    ")
-		builder.WriteString(r.quoteIfNeeded(relation.From))
+		builder.WriteString(rel.From)
 		builder.WriteString(" ")
-		builder.WriteString(r.renderRelationType(relation.Type))
+		builder.WriteString(string(rel.Type))
 		builder.WriteString(" ")
-		builder.WriteString(r.quoteIfNeeded(relation.To))
+		builder.WriteString(rel.To)
 
-		// Add label if present
-		if relation.Label != nil {
+		if rel.Label != nil {
 			builder.WriteString(" : ")
-			builder.WriteString(*relation.Label)
+			if strings.Contains(*rel.Label, " ") {
+				builder.WriteString(fmt.Sprintf("\"%s\"", *rel.Label))
+			} else {
+				builder.WriteString(*rel.Label)
+			}
 		}
 
 		builder.WriteString("\n")
@@ -80,27 +87,3 @@ func (r *ERRenderer) Render(diagram *ast.ERDiagram) (string, error) {
 
 	return builder.String(), nil
 }
-
-// renderRelationType converts relation type to mermaid syntax
-func (r *ERRenderer) renderRelationType(relType ast.ERRelationType) string {
-	switch relType {
-	case ast.ERRelationOneToOne:
-		return "||--||"
-	case ast.ERRelationOneToMany:
-		return "||--o{"
-	case ast.ERRelationManyToOne:
-		return "}o--||"
-	case ast.ERRelationManyToMany:
-		return "}o--o{"
-	default:
-		return "||--o{" // Default to one-to-many
-	}
-}
-
-// quoteIfNeeded adds quotes around entity names if they contain spaces
-func (r *ERRenderer) quoteIfNeeded(name string) string {
-	if strings.Contains(name, " ") {
-		return fmt.Sprintf("\"%s\"", name)
-	}
-	return name
-}

pkg/renderer/gantt.go

@@ -28,8 +28,8 @@ func (r *GanttRenderer) Render(diagram *ast.GanttDiagram) (string, error) {
 		result.WriteString(fmt.Sprintf("    title %s\n", *diagram.Title))
 	}
 
-	// Add date format if not default
-	if diagram.DateFormat != "" && diagram.DateFormat != "YYYY-MM-DD" {
+	// Add date format if present
+	if diagram.DateFormat != "" {
 		result.WriteString(fmt.Sprintf("    dateFormat %s\n", diagram.DateFormat))
 	}
 
@@ -63,7 +63,12 @@ func (r *GanttRenderer) renderTask(result *strings.Builder, task *ast.GanttTask)
 	// Add task data
 	var taskData []string
 
-	// Add status if not default
+	// Add dependencies first (task IDs)
+	for _, dep := range task.Dependencies {
+		taskData = append(taskData, dep)
+	}
+
+	// Add status if not default (only render explicit status)
 	if task.Status != ast.GanttStatusActive {
 		taskData = append(taskData, string(task.Status))
 	}
@@ -80,11 +85,6 @@ func (r *GanttRenderer) renderTask(result *strings.Builder, task *ast.GanttTask)
 		taskData = append(taskData, *task.Duration)
 	}
 
-	// Add dependencies
-	for _, dep := range task.Dependencies {
-		taskData = append(taskData, dep)
-	}
-
 	if len(taskData) > 0 {
 		result.WriteString(strings.Join(taskData, " "))
 	}

pkg/renderer/sequence.go

@@ -230,5 +230,112 @@ func (r *SequenceRenderer) Render(diagram *ast.SequenceDiagram) (string, error)
 		builder.WriteString("    end\n")
 	}
 
+	// Render rects
+	for _, rect := range diagram.Rects {
+		builder.WriteString("    rect")
+		if rect.Color != nil {
+			builder.WriteString(" ")
+			builder.WriteString(*rect.Color)
+		}
+		builder.WriteString("\n")
+
+		for _, message := range rect.Messages {
+			builder.WriteString("        ")
+			builder.WriteString(message.From)
+			builder.WriteString(" ")
+			builder.WriteString(string(message.Type))
+			builder.WriteString(" ")
+			builder.WriteString(message.To)
+
+			if message.Message != "" {
+				builder.WriteString(" : ")
+				builder.WriteString(message.Message)
+			}
+			builder.WriteString("\n")
+		}
+
+		builder.WriteString("    end\n")
+	}
+
+	// Render criticals
+	for _, critical := range diagram.Criticals {
+		builder.WriteString("    critical")
+		if critical.Label != "" {
+			builder.WriteString(" ")
+			builder.WriteString(critical.Label)
+		}
+		builder.WriteString("\n")
+
+		// Render critical messages
+		for _, message := range critical.Messages {
+			builder.WriteString("        ")
+			builder.WriteString(message.From)
+			builder.WriteString(" ")
+			builder.WriteString(string(message.Type))
+			builder.WriteString(" ")
+			builder.WriteString(message.To)
+
+			if message.Message != "" {
+				builder.WriteString(" : ")
+				builder.WriteString(message.Message)
+			}
+			builder.WriteString("\n")
+		}
+
+		// Render options
+		for _, option := range critical.Options {
+			builder.WriteString("        option")
+			if option.Label != "" {
+				builder.WriteString(" ")
+				builder.WriteString(option.Label)
+			}
+			builder.WriteString("\n")
+
+			for _, message := range option.Messages {
+				builder.WriteString("            ")
+				builder.WriteString(message.From)
+				builder.WriteString(" ")
+				builder.WriteString(string(message.Type))
+				builder.WriteString(" ")
+				builder.WriteString(message.To)
+
+				if message.Message != "" {
+					builder.WriteString(" : ")
+					builder.WriteString(message.Message)
+				}
+				builder.WriteString("\n")
+			}
+		}
+
+		builder.WriteString("    end\n")
+	}
+
+	// Render breaks
+	for _, breakBlock := range diagram.Breaks {
+		builder.WriteString("    break")
+		if breakBlock.Label != "" {
+			builder.WriteString(" ")
+			builder.WriteString(breakBlock.Label)
+		}
+		builder.WriteString("\n")
+
+		for _, message := range breakBlock.Messages {
+			builder.WriteString("        ")
+			builder.WriteString(message.From)
+			builder.WriteString(" ")
+			builder.WriteString(string(message.Type))
+			builder.WriteString(" ")
+			builder.WriteString(message.To)
+
+			if message.Message != "" {
+				builder.WriteString(" : ")
+				builder.WriteString(message.Message)
+			}
+			builder.WriteString("\n")
+		}
+
+		builder.WriteString("    end\n")
+	}
+
 	return builder.String(), nil
 }

pkg/renderer/state.go

@@ -102,47 +102,54 @@ func (r *StateRenderer) Render(diagram *ast.StateDiagram) (string, error) {
 			builder.WriteString(state.Note.Text)
 			builder.WriteString("\n")
 		}
+
+		// Render state actions
+		if state.EntryAction != nil {
+			builder.WriteString("    ")
+			builder.WriteString(state.ID)
+			builder.WriteString(" : entry ")
+			builder.WriteString(*state.EntryAction)
+			builder.WriteString("\n")
+		}
+		if state.ExitAction != nil {
+			builder.WriteString("    ")
+			builder.WriteString(state.ID)
+			builder.WriteString(" : exit ")
+			builder.WriteString(*state.ExitAction)
+			builder.WriteString("\n")
+		}
+		if state.DoAction != nil {
+			builder.WriteString("    ")
+			builder.WriteString(state.ID)
+			builder.WriteString(" : do ")
+			builder.WriteString(*state.DoAction)
+			builder.WriteString("\n")
+		}
 	}
 
 	// Render transitions
 	for _, transition := range diagram.Transitions {
 		builder.WriteString("    ")
-
-		// Handle start state
-		if transition.From == "[*]" {
-			builder.WriteString("[*]")
-		} else {
-			builder.WriteString(transition.From)
-		}
-
+		builder.WriteString(transition.From)
 		builder.WriteString(" --> ")
+		builder.WriteString(transition.To)
 
-		// Handle end state
-		if transition.To == "[*]" {
-			builder.WriteString("[*]")
-		} else {
-			builder.WriteString(transition.To)
-		}
-
-		// Add label if present
+		// Add transition decorations: label, [guard], /action
+		var decorations []string
 		if transition.Label != nil {
-			builder.WriteString(" : ")
-			builder.WriteString(*transition.Label)
+			decorations = append(decorations, *transition.Label)
 		}
-
-		// Add condition if present
 		if transition.Condition != nil {
-			builder.WriteString(" [")
-			builder.WriteString(*transition.Condition)
-			builder.WriteString("]")
+			decorations = append(decorations, fmt.Sprintf("[%s]", *transition.Condition))
 		}
-
-		// Add action if present
 		if transition.Action != nil {
-			builder.WriteString(" / ")
-			builder.WriteString(*transition.Action)
+			decorations = append(decorations, fmt.Sprintf("/%s", *transition.Action))
 		}
 
+		if len(decorations) > 0 {
+			builder.WriteString(" : ")
+			builder.WriteString(strings.Join(decorations, " "))
+		}
 		builder.WriteString("\n")
 	}