style: format all files with prettier

2026-03-18 17:47:16 +00:00 · 2026-01-19 17:07:03 -05:00
parent 8d37048deb
commit 56848874a2
355 changed files with 15215 additions and 10241 deletions
--- a/plugins/code-documentation/commands/code-explain.md
+++ b/plugins/code-documentation/commands/code-explain.md
@@ -3,9 +3,11 @@
 You are a code education expert specializing in explaining complex code through clear narratives, visual diagrams, and step-by-step breakdowns. Transform difficult concepts into understandable explanations for developers at all levels.

 ## Context
+
 The user needs help understanding complex code sections, algorithms, design patterns, or system architectures. Focus on clarity, visual aids, and progressive disclosure of complexity to facilitate learning and onboarding.

 ## Requirements
+
 $ARGUMENTS

 ## Instructions
@@ -15,6 +17,7 @@ $ARGUMENTS
 Analyze the code to determine complexity and structure:

 **Code Complexity Assessment**
+
 ```python
 import ast
 import re
@@ -32,11 +35,11 @@ class CodeAnalyzer:
            'dependencies': [],
            'difficulty_level': 'beginner'
        }
-        
+
        # Parse code structure
        try:
            tree = ast.parse(code)
-            
+
            # Analyze complexity metrics
            analysis['metrics'] = {
                'lines_of_code': len(code.splitlines()),
@@ -45,59 +48,59 @@ class CodeAnalyzer:
                'function_count': len([n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]),
                'class_count': len([n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)])
            }
-            
+
            # Identify concepts used
            analysis['concepts'] = self._identify_concepts(tree)
-            
+
            # Detect design patterns
            analysis['patterns'] = self._detect_patterns(tree)
-            
+
            # Extract dependencies
            analysis['dependencies'] = self._extract_dependencies(tree)
-            
+
            # Determine difficulty level
            analysis['difficulty_level'] = self._assess_difficulty(analysis)
-            
+
        except SyntaxError as e:
            analysis['parse_error'] = str(e)
-            
+
        return analysis
-    
+
    def _identify_concepts(self, tree) -> List[str]:
        """
        Identify programming concepts used in the code
        """
        concepts = []
-        
+
        for node in ast.walk(tree):
            # Async/await
            if isinstance(node, (ast.AsyncFunctionDef, ast.AsyncWith, ast.AsyncFor)):
                concepts.append('asynchronous programming')
-            
+
            # Decorators
            elif isinstance(node, ast.FunctionDef) and node.decorator_list:
                concepts.append('decorators')
-            
+
            # Context managers
            elif isinstance(node, ast.With):
                concepts.append('context managers')
-            
+
            # Generators
            elif isinstance(node, ast.Yield):
                concepts.append('generators')
-            
+
            # List/Dict/Set comprehensions
            elif isinstance(node, (ast.ListComp, ast.DictComp, ast.SetComp)):
                concepts.append('comprehensions')
-            
+
            # Lambda functions
            elif isinstance(node, ast.Lambda):
                concepts.append('lambda functions')
-            
+
            # Exception handling
            elif isinstance(node, ast.Try):
                concepts.append('exception handling')
-                
+
        return list(set(concepts))
 ```

@@ -106,84 +109,86 @@ class CodeAnalyzer:
 Create visual representations of code flow:

 **Flow Diagram Generation**
-```python
+
+````python
 class VisualExplainer:
    def generate_flow_diagram(self, code_structure):
        """
        Generate Mermaid diagram showing code flow
        """
        diagram = "```mermaid\nflowchart TD\n"
-        
+
        # Example: Function call flow
        if code_structure['type'] == 'function_flow':
            nodes = []
            edges = []
-            
+
            for i, func in enumerate(code_structure['functions']):
                node_id = f"F{i}"
                nodes.append(f"    {node_id}[{func['name']}]")
-                
+
                # Add function details
                if func.get('parameters'):
                    nodes.append(f"    {node_id}_params[/{', '.join(func['parameters'])}/]")
                    edges.append(f"    {node_id}_params --> {node_id}")
-                
+
                # Add return value
                if func.get('returns'):
                    nodes.append(f"    {node_id}_return[{func['returns']}]")
                    edges.append(f"    {node_id} --> {node_id}_return")
-                
+
                # Connect to called functions
                for called in func.get('calls', []):
                    called_id = f"F{code_structure['function_map'][called]}"
                    edges.append(f"    {node_id} --> {called_id}")
-            
+
            diagram += "\n".join(nodes) + "\n"
            diagram += "\n".join(edges) + "\n"
-            
+
        diagram += "```"
        return diagram
-    
+
    def generate_class_diagram(self, classes):
        """
        Generate UML-style class diagram
        """
        diagram = "```mermaid\nclassDiagram\n"
-        
+
        for cls in classes:
            # Class definition
            diagram += f"    class {cls['name']} {{\n"
-            
+
            # Attributes
            for attr in cls.get('attributes', []):
                visibility = '+' if attr['public'] else '-'
                diagram += f"        {visibility}{attr['name']} : {attr['type']}\n"
-            
+
            # Methods
            for method in cls.get('methods', []):
                visibility = '+' if method['public'] else '-'
                params = ', '.join(method.get('params', []))
                diagram += f"        {visibility}{method['name']}({params}) : {method['returns']}\n"
-            
+
            diagram += "    }\n"
-            
+
            # Relationships
            if cls.get('inherits'):
                diagram += f"    {cls['inherits']} <|-- {cls['name']}\n"
-            
+
            for composition in cls.get('compositions', []):
                diagram += f"    {cls['name']} *-- {composition}\n"
-            
+
        diagram += "```"
        return diagram
-```
+````

 ### 3. Step-by-Step Explanation

 Break down complex code into digestible steps:

 **Progressive Explanation**
-```python
+
+````python
 def generate_step_by_step_explanation(self, code, analysis):
    """
    Create progressive explanation from simple to complex
@@ -194,7 +199,7 @@ def generate_step_by_step_explanation(self, code, analysis):
        'deep_dive': [],
        'examples': []
    }
-    
+
    # Level 1: High-level overview
    explanation['overview'] = f"""
 ## What This Code Does
@@ -204,7 +209,7 @@ def generate_step_by_step_explanation(self, code, analysis):
 **Key Concepts**: {', '.join(analysis['concepts'])}
 **Difficulty Level**: {analysis['difficulty_level'].capitalize()}
 """
-    
+
    # Level 2: Step-by-step breakdown
    if analysis.get('functions'):
        for i, func in enumerate(analysis['functions']):
@@ -218,18 +223,18 @@ def generate_step_by_step_explanation(self, code, analysis):
            # Break down function logic
            for j, logic_step in enumerate(self._analyze_function_logic(func)):
                step += f"{j+1}. {logic_step}\n"
-            
+
            # Add visual flow if complex
            if func['complexity'] > 5:
                step += f"\n{self._generate_function_flow(func)}\n"
-            
+
            explanation['steps'].append(step)
-    
+
    # Level 3: Deep dive into complex parts
    for concept in analysis['concepts']:
        deep_dive = self._explain_concept(concept, code)
        explanation['deep_dive'].append(deep_dive)
-    
+
    return explanation

 def _explain_concept(self, concept, code):
@@ -255,11 +260,12 @@ def slow_function():
 def slow_function():
    time.sleep(1)
 slow_function = timer(slow_function)
-```
+````

 **In this code**: The decorator is used to {specific_use_in_code}
 ''',
-        'generators': '''
+'generators': '''
+
 ## Understanding Generators

 Generators produce values one at a time, saving memory by not creating all values at once.
@@ -267,6 +273,7 @@ Generators produce values one at a time, saving memory by not creating all value
 **Simple Analogy**: Like a ticket dispenser that gives one ticket at a time, rather than printing all tickets upfront.

 **How it works**:
+
 ```python
 # Generator function
 def count_up_to(n):
@@ -282,10 +289,11 @@ for num in count_up_to(5):

 **In this code**: The generator is used to {specific_use_in_code}
 '''
-    }
-    
+}
+
    return explanations.get(concept, f"Explanation for {concept}")
-```
+
+````

 ### 4. Algorithm Visualization

@@ -299,7 +307,7 @@ class AlgorithmVisualizer:
        Create step-by-step visualization of sorting algorithm
        """
        steps = []
-        
+
        if algorithm_name == 'bubble_sort':
            steps.append("""
 ## Bubble Sort Visualization
@@ -313,34 +321,34 @@ class AlgorithmVisualizer:

 ### Step-by-Step Execution:
 """)
-            
+
            # Simulate bubble sort with visualization
            arr = array.copy()
            n = len(arr)
-            
+
            for i in range(n):
                swapped = False
                step_viz = f"\n**Pass {i+1}**:\n"
-                
+
                for j in range(0, n-i-1):
                    # Show comparison
                    step_viz += f"Compare [{arr[j]}] and [{arr[j+1]}]: "
-                    
+
                    if arr[j] > arr[j+1]:
                        arr[j], arr[j+1] = arr[j+1], arr[j]
                        step_viz += f"Swap → {arr}\n"
                        swapped = True
                    else:
                        step_viz += "No swap needed\n"
-                
+
                steps.append(step_viz)
-                
+
                if not swapped:
                    steps.append(f"\n✅ Array is sorted: {arr}")
                    break
-        
+
        return '\n'.join(steps)
-    
+
    def visualize_recursion(self, func_name, example_input):
        """
        Visualize recursive function calls
@@ -349,25 +357,27 @@ class AlgorithmVisualizer:
 ## Recursion Visualization: {func_name}

 ### Call Stack Visualization:
-```
+````
+
 {func_name}({example_input})
 │
 ├─> Base case check: {example_input} == 0? No
 ├─> Recursive call: {func_name}({example_input - 1})
-│   │
-│   ├─> Base case check: {example_input - 1} == 0? No
-│   ├─> Recursive call: {func_name}({example_input - 2})
-│   │   │
-│   │   ├─> Base case check: 1 == 0? No
-│   │   ├─> Recursive call: {func_name}(0)
-│   │   │   │
-│   │   │   └─> Base case: Return 1
-│   │   │
-│   │   └─> Return: 1 * 1 = 1
-│   │
-│   └─> Return: 2 * 1 = 2
+│ │
+│ ├─> Base case check: {example_input - 1} == 0? No
+│ ├─> Recursive call: {func_name}({example_input - 2})
+│ │ │
+│ │ ├─> Base case check: 1 == 0? No
+│ │ ├─> Recursive call: {func_name}(0)
+│ │ │ │
+│ │ │ └─> Base case: Return 1
+│ │ │
+│ │ └─> Return: 1 _ 1 = 1
+│ │
+│ └─> Return: 2 _ 1 = 2
 │
-└─> Return: 3 * 2 = 6
+└─> Return: 3 \* 2 = 6
+
 ```

 **Final Result**: {func_name}({example_input}) = 6
@@ -380,7 +390,8 @@ class AlgorithmVisualizer:
 Generate interactive examples for better understanding:

 **Code Playground Examples**
-```python
+
+````python
 def generate_interactive_examples(self, concept):
    """
    Create runnable examples for concepts
@@ -409,9 +420,10 @@ def safe_divide(a, b):
 safe_divide(10, 2)    # Success case
 safe_divide(10, 0)    # Division by zero
 safe_divide(10, "2")  # Type error
-```
+````

 ### Example 2: Custom Exceptions
+
 ```python
 class ValidationError(Exception):
    """Custom exception for validation errors"""
@@ -438,17 +450,21 @@ except ValidationError as e:
 ```

 ### Exercise: Implement Your Own
+
 Try implementing a function that:
+
 1. Takes a list of numbers
 2. Returns their average
 3. Handles empty lists
 4. Handles non-numeric values
 5. Uses appropriate exception handling
-''',
-        'async_programming': '''
+   ''',
+   'async_programming': '''
+
 ## Try It Yourself: Async Programming

 ### Example 1: Basic Async/Await
+
 ```python
 import asyncio
 import time
@@ -465,7 +481,7 @@ async def main():
    await slow_operation("Task 1", 2)
    await slow_operation("Task 2", 2)
    print(f"Sequential time: {time.time() - start:.2f}s")
-    
+
    # Concurrent execution (fast)
    start = time.time()
    results = await asyncio.gather(
@@ -480,6 +496,7 @@ asyncio.run(main())
 ```

 ### Example 2: Real-world Async Pattern
+
 ```python
 async def fetch_data(url):
    """Simulate API call"""
@@ -496,11 +513,13 @@ urls = ["api.example.com/1", "api.example.com/2", "api.example.com/3"]
 results = asyncio.run(process_urls(urls))
 print(results)
 ```
+
 '''
-    }
-    
+}
+
    return examples.get(concept, "No example available")
-```
+
+````

 ### 6. Design Pattern Explanation

@@ -535,38 +554,46 @@ classDiagram
        +getInstance(): Singleton
    }
    Singleton --> Singleton : returns same instance
-```
+````

 ### Implementation in this code:
+
 {code_analysis}

 ### Benefits:
+
 ✅ Controlled access to single instance
 ✅ Reduced namespace pollution
 ✅ Permits refinement of operations

 ### Drawbacks:
+
 ❌ Can make unit testing difficult
 ❌ Violates Single Responsibility Principle
 ❌ Can hide dependencies

 ### Alternative Approaches:
+
 1. Dependency Injection
 2. Module-level singleton
 3. Borg pattern
-''',
-            'observer': '''
+   ''',
+   'observer': '''
+
 ## Observer Pattern

 ### What is it?
+
 The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all dependents are notified.

 ### When to use it?
+
 - Event handling systems
 - Model-View architectures
 - Distributed event handling

 ### Visual Representation:
+
 ```mermaid
 classDiagram
    class Subject {
@@ -593,26 +620,28 @@ classDiagram
 ```

 ### Implementation in this code:
+
 {code_analysis}

 ### Real-world Example:
+
 ```python
 # Newsletter subscription system
 class Newsletter:
    def __init__(self):
        self._subscribers = []
        self._latest_article = None
-    
+
    def subscribe(self, subscriber):
        self._subscribers.append(subscriber)
-    
+
    def unsubscribe(self, subscriber):
        self._subscribers.remove(subscriber)
-    
+
    def publish_article(self, article):
        self._latest_article = article
        self._notify_subscribers()
-    
+
    def _notify_subscribers(self):
        for subscriber in self._subscribers:
            subscriber.update(self._latest_article)
@@ -620,15 +649,17 @@ class Newsletter:
 class EmailSubscriber:
    def __init__(self, email):
        self.email = email
-    
+
    def update(self, article):
        print(f"Sending email to {self.email}: New article - {article}")
 ```
+
 '''
-        }
-        
+}
+
        return patterns.get(pattern_name, "Pattern explanation not available")
-```
+
+````

 ### 7. Common Pitfalls and Best Practices

@@ -641,7 +672,7 @@ def analyze_common_pitfalls(self, code):
    Identify common mistakes and suggest improvements
    """
    issues = []
-    
+
    # Check for common Python pitfalls
    pitfall_patterns = [
        {
@@ -674,25 +705,29 @@ except (ValueError, TypeError) as e:
 except Exception as e:
    logger.error(f"Unexpected error: {e}")
    raise
-```
+````
+
 '''
-        },
-        {
-            'pattern': r'def.*\(\s*\):.*global',
-            'issue': 'Global variable usage',
-            'severity': 'medium',
-            'explanation': '''
+},
+{
+'pattern': r'def._\(\s_\):.\*global',
+'issue': 'Global variable usage',
+'severity': 'medium',
+'explanation': '''
+
 ## ⚠️ Global Variable Usage

 **Problem**: Using global variables makes code harder to test and reason about.

 **Better approaches**:
+
 1. Pass as parameter
 2. Use class attributes
 3. Use dependency injection
 4. Return values instead

 **Example refactor**:
+
 ```python
 # Bad
 count = 0
@@ -704,21 +739,23 @@ def increment():
 class Counter:
    def __init__(self):
        self.count = 0
-    
+
    def increment(self):
        self.count += 1
        return self.count
 ```
+
 '''
-        }
-    ]
-    
+}
+]
+
    for pitfall in pitfall_patterns:
        if re.search(pitfall['pattern'], code):
            issues.append(pitfall)
-    
+
    return issues
-```
+
+````

 ### 8. Learning Path Recommendations

@@ -736,7 +773,7 @@ def generate_learning_path(self, analysis):
        'recommended_topics': [],
        'resources': []
    }
-    
+
    # Identify knowledge gaps
    if 'async' in analysis['concepts'] and analysis['difficulty_level'] == 'beginner':
        learning_path['identified_gaps'].append('Asynchronous programming fundamentals')
@@ -746,7 +783,7 @@ def generate_learning_path(self, analysis):
            'Async/await syntax',
            'Concurrent programming patterns'
        ])
-    
+
    # Add resources
    learning_path['resources'] = [
        {
@@ -765,7 +802,7 @@ def generate_learning_path(self, analysis):
            'format': 'visual learning'
        }
    ]
-    
+
    # Create structured learning plan
    learning_path['structured_plan'] = f"""
 ## Your Personalized Learning Path
@@ -790,9 +827,9 @@ def generate_learning_path(self, analysis):
 2. **Intermediate**: {self._suggest_intermediate_project(analysis)}
 3. **Advanced**: {self._suggest_advanced_project(analysis)}
 """
-    
+
    return learning_path
-```
+````

 ## Output Format

@@ -805,4 +842,4 @@ def generate_learning_path(self, analysis):
 7. **Learning Resources**: Curated resources for deeper understanding
 8. **Practice Exercises**: Hands-on challenges to reinforce learning

-Focus on making complex code accessible through clear explanations, visual aids, and practical examples that build understanding progressively.
+Focus on making complex code accessible through clear explanations, visual aids, and practical examples that build understanding progressively.
--- a/plugins/code-documentation/commands/doc-generate.md
+++ b/plugins/code-documentation/commands/doc-generate.md
@@ -3,14 +3,17 @@
 You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user guides, and technical references using AI-powered analysis and industry best practices.

 ## Context
+
 The user needs automated documentation generation that extracts information from code, creates clear explanations, and maintains consistency across documentation types. Focus on creating living documentation that stays synchronized with code.

 ## Requirements
+
 $ARGUMENTS

 ## How to Use This Tool

 This tool provides both **concise instructions** (what to create) and **detailed reference examples** (how to create it). Structure:
+
 - **Instructions**: High-level guidance and documentation types to generate
 - **Reference Examples**: Complete implementation patterns to adapt and use as templates

@@ -19,30 +22,35 @@ This tool provides both **concise instructions** (what to create) and **detailed
 Generate comprehensive documentation by analyzing the codebase and creating the following artifacts:

 ### 1. **API Documentation**
+
 - Extract endpoint definitions, parameters, and responses from code
 - Generate OpenAPI/Swagger specifications
 - Create interactive API documentation (Swagger UI, Redoc)
 - Include authentication, rate limiting, and error handling details

 ### 2. **Architecture Documentation**
+
 - Create system architecture diagrams (Mermaid, PlantUML)
 - Document component relationships and data flows
 - Explain service dependencies and communication patterns
 - Include scalability and reliability considerations

 ### 3. **Code Documentation**
+
 - Generate inline documentation and docstrings
 - Create README files with setup, usage, and contribution guidelines
 - Document configuration options and environment variables
 - Provide troubleshooting guides and code examples

 ### 4. **User Documentation**
+
 - Write step-by-step user guides
 - Create getting started tutorials
 - Document common workflows and use cases
 - Include accessibility and localization notes

 ### 5. **Documentation Automation**
+
 - Configure CI/CD pipelines for automatic doc generation
 - Set up documentation linting and validation
 - Implement documentation coverage checks
@@ -51,6 +59,7 @@ Generate comprehensive documentation by analyzing the codebase and creating the
 ### Quality Standards

 Ensure all generated documentation:
+
 - Is accurate and synchronized with current code
 - Uses consistent terminology and formatting
 - Includes practical examples and use cases
@@ -62,6 +71,7 @@ Ensure all generated documentation:
 ### Example 1: Code Analysis for Documentation

 **API Documentation Extraction**
+
 ```python
 import ast
 from typing import Dict, List
@@ -103,6 +113,7 @@ class APIDocExtractor:
 ```

 **Schema Extraction**
+
 ```python
 def extract_pydantic_schemas(file_path):
    """Extract Pydantic model definitions for API documentation"""
@@ -135,6 +146,7 @@ def extract_pydantic_schemas(file_path):
 ### Example 2: OpenAPI Specification Generation

 **OpenAPI Template**
+
 ```yaml
 openapi: 3.0.0
 info:
@@ -173,7 +185,7 @@ paths:
            default: 20
            maximum: 100
      responses:
-        '200':
+        "200":
          description: Successful response
          content:
            application/json:
@@ -183,11 +195,11 @@ paths:
                  data:
                    type: array
                    items:
-                      $ref: '#/components/schemas/User'
+                      $ref: "#/components/schemas/User"
                  pagination:
-                    $ref: '#/components/schemas/Pagination'
-        '401':
-          $ref: '#/components/responses/Unauthorized'
+                    $ref: "#/components/schemas/Pagination"
+        "401":
+          $ref: "#/components/responses/Unauthorized"

 components:
  schemas:
@@ -213,6 +225,7 @@ components:
 ### Example 3: Architecture Diagrams

 **System Architecture (Mermaid)**
+
 ```mermaid
 graph TB
    subgraph "Frontend"
@@ -249,12 +262,14 @@ graph TB
 ```

 **Component Documentation**
-```markdown
+
+````markdown
 ## User Service

 **Purpose**: Manages user accounts, authentication, and profiles

 **Technology Stack**:
+
 - Language: Python 3.11
 - Framework: FastAPI
 - Database: PostgreSQL
@@ -262,12 +277,14 @@ graph TB
 - Authentication: JWT

 **API Endpoints**:
+
 - `POST /users` - Create new user
 - `GET /users/{id}` - Get user details
 - `PUT /users/{id}` - Update user
 - `POST /auth/login` - User login

 **Configuration**:
+
 ```yaml
 user_service:
  port: 8001
@@ -278,7 +295,9 @@ user_service:
    secret: ${JWT_SECRET}
    expiry: 3600
 ```
-```
+````
+
+````

 ### Example 4: README Generation

@@ -306,7 +325,7 @@ ${FEATURES_LIST}

 ```bash
 pip install ${PACKAGE_NAME}
-```
+````

 ### From source

@@ -326,11 +345,11 @@ ${QUICK_START_CODE}

 ### Environment Variables

-| Variable | Description | Default | Required |
-|----------|-------------|---------|----------|
-| DATABASE_URL | PostgreSQL connection string | - | Yes |
-| REDIS_URL | Redis connection string | - | Yes |
-| SECRET_KEY | Application secret key | - | Yes |
+| Variable     | Description                  | Default | Required |
+| ------------ | ---------------------------- | ------- | -------- |
+| DATABASE_URL | PostgreSQL connection string | -       | Yes      |
+| REDIS_URL    | Redis connection string      | -       | Yes      |
+| SECRET_KEY   | Application secret key       | -       | Yes      |

 ## Development

@@ -372,7 +391,8 @@ pytest --cov=your_package
 ## License

 This project is licensed under the ${LICENSE} License - see the [LICENSE](LICENSE) file for details.
-```
+
+````

 ### Example 5: Function Documentation Generator

@@ -415,7 +435,7 @@ def {func.__name__}({", ".join(params)}){return_type}:
    """
 '''
    return doc_template
-```
+````

 ### Example 6: User Guide Template

@@ -435,7 +455,6 @@ def {func.__name__}({", ".join(params)}){return_type}:
   You'll find the "Create New" button in the top right corner.

 3. **Fill in the Details**
-
   - **Name**: Enter a descriptive name
   - **Description**: Add optional details
   - **Settings**: Configure as needed
@@ -463,43 +482,48 @@ def {func.__name__}({", ".join(params)}){return_type}:

 ### Troubleshooting

-| Error | Meaning | Solution |
-|-------|---------|----------|
-| "Name required" | The name field is empty | Enter a name |
-| "Permission denied" | You don't have access | Contact admin |
-| "Server error" | Technical issue | Try again later |
+| Error               | Meaning                 | Solution        |
+| ------------------- | ----------------------- | --------------- |
+| "Name required"     | The name field is empty | Enter a name    |
+| "Permission denied" | You don't have access   | Contact admin   |
+| "Server error"      | Technical issue         | Try again later |
 ```

 ### Example 7: Interactive API Playground

 **Swagger UI Setup**
+
 ```html
 <!DOCTYPE html>
 <html>
-<head>
+  <head>
    <title>API Documentation</title>
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@latest/swagger-ui.css">
-</head>
-<body>
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@latest/swagger-ui.css"
+    />
+  </head>
+  <body>
    <div id="swagger-ui"></div>

    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@latest/swagger-ui-bundle.js"></script>
    <script>
-        window.onload = function() {
-            SwaggerUIBundle({
-                url: "/api/openapi.json",
-                dom_id: '#swagger-ui',
-                deepLinking: true,
-                presets: [SwaggerUIBundle.presets.apis],
-                layout: "StandaloneLayout"
-            });
-        }
+      window.onload = function () {
+        SwaggerUIBundle({
+          url: "/api/openapi.json",
+          dom_id: "#swagger-ui",
+          deepLinking: true,
+          presets: [SwaggerUIBundle.presets.apis],
+          layout: "StandaloneLayout",
+        });
+      };
    </script>
-</body>
+  </body>
 </html>
 ```

 **Code Examples Generator**
+
 ```python
 def generate_code_examples(endpoint):
    """Generate code examples for API endpoints in multiple languages"""
@@ -539,6 +563,7 @@ curl -X {endpoint['method']} https://api.example.com{endpoint['path']} \\
 ### Example 8: Documentation CI/CD

 **GitHub Actions Workflow**
+
 ```yaml
 name: Generate Documentation

@@ -546,39 +571,39 @@ on:
  push:
    branches: [main]
    paths:
-      - 'src/**'
-      - 'api/**'
+      - "src/**"
+      - "api/**"

 jobs:
  generate-docs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3

-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: '3.11'
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"

-    - name: Install dependencies
-      run: |
-        pip install -r requirements-docs.txt
-        npm install -g @redocly/cli
+      - name: Install dependencies
+        run: |
+          pip install -r requirements-docs.txt
+          npm install -g @redocly/cli

-    - name: Generate API documentation
-      run: |
-        python scripts/generate_openapi.py > docs/api/openapi.json
-        redocly build-docs docs/api/openapi.json -o docs/api/index.html
+      - name: Generate API documentation
+        run: |
+          python scripts/generate_openapi.py > docs/api/openapi.json
+          redocly build-docs docs/api/openapi.json -o docs/api/index.html

-    - name: Generate code documentation
-      run: sphinx-build -b html docs/source docs/build
+      - name: Generate code documentation
+        run: sphinx-build -b html docs/source docs/build

-    - name: Deploy to GitHub Pages
-      uses: peaceiris/actions-gh-pages@v3
-      with:
-        github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_dir: ./docs/build
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs/build
 ```

 ### Example 9: Documentation Coverage Validation