codymaster 4.1.4 → 4.4.1

package/skills/cm-ux-master/cli/uxmaster/template_engine.py

@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""
+UX-Master Template Engine
+
+Advanced template system supporting:
+- YAML-based platform configurations
+- Conditional blocks: {{#if pro}}...{{/if}}
+- Loops: {{#each stacks}}...{{/each}}
+- Partials: {{> quick-reference}}
+- Variables: {{variable_name}}
+"""
+
+import re
+import yaml
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Optional
+from rich.console import Console
+
+console = Console()
+
+
+@dataclass
+class PlatformConfig:
+    """Platform configuration for skill generation."""
+    platform: str
+    display_name: str
+    install_type: str  # 'full', 'reference', 'mcp'
+    folder_structure: dict
+    script_path: str
+    frontmatter: Optional[dict] = None
+    sections: dict = field(default_factory=dict)
+    title: str = "UX Master - Design Intelligence"
+    description: str = ""
+    skill_or_workflow: str = "Skill"
+    # NEW: MCP-specific fields
+    mcp_capabilities: list = field(default_factory=list)
+    tool_endpoints: list = field(default_factory=list)
+    
+    @classmethod
+    def from_yaml(cls, yaml_path: Path) -> "PlatformConfig":
+        """Load platform config from YAML file."""
+        with open(yaml_path, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        return cls(**data)
+
+
+class TemplateEngine:
+    """Advanced template engine with rich features."""
+    
+    def __init__(self, templates_dir: Optional[Path] = None):
+        """Initialize template engine.
+        
+        Args:
+            templates_dir: Directory containing templates
+        """
+        if templates_dir is None:
+            self.templates_dir = Path(__file__).parent.parent / "templates"
+        else:
+            self.templates_dir = Path(templates_dir)
+        
+        self._cache: dict[str, str] = {}
+        self._helpers: dict[str, Callable] = {
+            'upper': str.upper,
+            'lower': str.lower,
+            'title': str.title,
+            'snake_case': self._to_snake_case,
+            'kebab_case': self._to_kebab_case,
+        }
+    
+    def render(self, template: str, context: dict[str, Any]) -> str:
+        """Render template with context.
+        
+        Supports:
+        - Variables: {{name}} or {{name | upper}}
+        - Conditionals: {{#if condition}}...{{/if}}
+        - Unless: {{#unless condition}}...{{/unless}}
+        - Loops: {{#each items}}...{{/each}}
+        - Partials: {{> partial_name}}
+        - Comments: {{! comment }}
+        """
+        result = template
+        
+        # Remove comments first
+        result = self._remove_comments(result)
+        
+        # Process partials
+        result = self._process_partials(result)
+        
+        # Process conditionals (handle nested)
+        result = self._process_conditionals(result, context)
+        
+        # Process loops
+        result = self._process_loops(result, context)
+        
+        # Process variables
+        result = self._process_variables(result, context)
+        
+        return result
+    
+    def render_file(self, template_name: str, context: dict[str, Any]) -> str:
+        """Render template from file."""
+        template_path = self.templates_dir / "base" / f"{template_name}.md"
+        if not template_path.exists():
+            raise FileNotFoundError(f"Template not found: {template_path}")
+        
+        with open(template_path, 'r', encoding='utf-8') as f:
+            template = f.read()
+        
+        return self.render(template, context)
+    
+    def render_platform_config(self, config: PlatformConfig) -> str:
+        """Render complete skill file for a platform."""
+        context = {
+            'platform': config.platform,
+            'display_name': config.display_name,
+            'title': config.title,
+            'description': config.description,
+            'skill_or_workflow': config.skill_or_workflow,
+            'script_path': config.script_path,
+            'frontmatter': config.frontmatter,
+            'sections': config.sections,
+            'mcp_capabilities': config.mcp_capabilities,
+            'tool_endpoints': config.tool_endpoints,
+            'has_ux_laws': True,
+            'has_design_tests': True,
+            'has_validation': True,
+        }
+        
+        # Render frontmatter if exists
+        lines = []
+        if config.frontmatter:
+            lines.append("---")
+            for key, value in config.frontmatter.items():
+                if isinstance(value, list):
+                    lines.append(f"{key}:")
+                    for item in value:
+                        lines.append(f"  - {item}")
+                elif isinstance(value, dict):
+                    lines.append(f"{key}:")
+                    for k, v in value.items():
+                        lines.append(f"  {k}: {v}")
+                else:
+                    lines.append(f"{key}: {value}")
+            lines.append("---")
+            lines.append("")
+        
+        # Render main content
+        content = self.render_file("skill-core", context)
+        lines.append(content)
+        
+        # Add quick reference if enabled
+        if config.sections.get('quick_reference', False):
+            quick_ref = self.render_file("quick-reference", context)
+            lines.append("")
+            lines.append(quick_ref)
+        
+        return "\n".join(lines)
+    
+    def _remove_comments(self, template: str) -> str:
+        """Remove template comments."""
+        return re.sub(r'\{\{!.*?\}\}', '', template, flags=re.DOTALL)
+    
+    def _process_partials(self, template: str) -> str:
+        """Process partial includes."""
+        pattern = r'\{\{>\s*(\w+(-\w+)*)\s*\}\}'
+        
+        def replace_partial(match: re.Match) -> str:
+            partial_name = match.group(1)
+            try:
+                partial_path = self.templates_dir / "partials" / f"{partial_name}.md"
+                if partial_path.exists():
+                    with open(partial_path, 'r', encoding='utf-8') as f:
+                        return f.read()
+                return f"<!-- Partial '{partial_name}' not found -->"
+            except Exception as e:
+                return f"<!-- Error loading partial '{partial_name}': {e} -->"
+        
+        return re.sub(pattern, replace_partial, template)
+    
+    def _process_conditionals(self, template: str, context: dict) -> str:
+        """Process conditional blocks."""
+        # Handle {{#if condition}}...{{/if}}
+        def replace_if(match: re.Match) -> str:
+            condition = match.group(1).strip()
+            content = match.group(2)
+            
+            # Evaluate condition
+            if self._evaluate_condition(condition, context):
+                return self._process_conditionals(content, context)
+            return ""
+        
+        # Handle {{#unless condition}}...{{/unless}}
+        def replace_unless(match: re.Match) -> str:
+            condition = match.group(1).strip()
+            content = match.group(2)
+            
+            if not self._evaluate_condition(condition, context):
+                return self._process_conditionals(content, context)
+            return ""
+        
+        # Handle {{#if condition}}...{{else}}...{{/if}}
+        def replace_if_else(match: re.Match) -> str:
+            condition = match.group(1).strip()
+            if_content = match.group(2)
+            else_content = match.group(4) if match.group(4) else ""
+            
+            if self._evaluate_condition(condition, context):
+                return self._process_conditionals(if_content, context)
+            else:
+                return self._process_conditionals(else_content, context)
+        
+        result = template
+        # Process nested if-else first
+        result = re.sub(
+            r'\{\{#if\s+([^}]+)\}\}(.*?)\{\{else\}\}(.*?)\{\{/if\}\}',
+            replace_if_else, result, flags=re.DOTALL
+        )
+        # Then simple if
+        result = re.sub(
+            r'\{\{#if\s+([^}]+)\}\}(.*?)\{\{/if\}\}',
+            replace_if, result, flags=re.DOTALL
+        )
+        # Then unless
+        result = re.sub(
+            r'\{\{#unless\s+([^}]+)\}\}(.*?)\{\{/unless\}\}',
+            replace_unless, result, flags=re.DOTALL
+        )
+        
+        return result
+    
+    def _process_loops(self, template: str, context: dict) -> str:
+        """Process loop blocks."""
+        pattern = r'\{\{#each\s+(\w+)\}\}(.*?)\{\{/each\}\}'
+        
+        def replace_loop(match: re.Match) -> str:
+            list_name = match.group(1)
+            content = match.group(2)
+            
+            items = context.get(list_name, [])
+            if not items:
+                return ""
+            
+            results = []
+            for i, item in enumerate(items):
+                item_context = {**context, 'this': item, '@index': i, '@first': i == 0, '@last': i == len(items) - 1}
+                # Handle {{this.property}} or just {{this}}
+                item_content = content
+                if isinstance(item, dict):
+                    for key, value in item.items():
+                        item_content = item_content.replace(f'{{{{this.{key}}}}}', str(value))
+                else:
+                    item_content = item_content.replace('{{this}}', str(item))
+                item_content = self._process_variables(item_content, item_context)
+                results.append(item_content)
+            
+            return "".join(results)
+        
+        return re.sub(pattern, replace_loop, template, flags=re.DOTALL)
+    
+    def _process_variables(self, template: str, context: dict) -> str:
+        """Process variable substitutions with optional filters."""
+        # Pattern: {{variable}} or {{variable | filter}} or {{variable.nested}}
+        pattern = r'\{\{\s*([\w.]+)(?:\s*\|\s*(\w+))?\s*\}\}'
+        
+        def replace_var(match: re.Match) -> str:
+            var_path = match.group(1)
+            filter_name = match.group(2)
+            
+            # Get value from context (support nested: obj.prop)
+            value = self._get_nested_value(context, var_path)
+            
+            if value is None:
+                return f"{{{{{var_path}}}}}"  # Keep original if not found
+            
+            result = str(value)
+            
+            # Apply filter if specified
+            if filter_name and filter_name in self._helpers:
+                result = self._helpers[filter_name](result)
+            
+            return result
+        
+        return re.sub(pattern, replace_var, template)
+    
+    def _evaluate_condition(self, condition: str, context: dict) -> bool:
+        """Evaluate a condition string."""
+        condition = condition.strip()
+        
+        # Handle negation
+        if condition.startswith('!'):
+            return not self._evaluate_condition(condition[1:], context)
+        
+        # Handle comparisons
+        if '==' in condition:
+            left, right = condition.split('==', 1)
+            left_val = self._get_nested_value(context, left.strip())
+            right_val = right.strip().strip('"\'')
+            return str(left_val) == right_val
+        
+        if '!=' in condition:
+            left, right = condition.split('!=', 1)
+            left_val = self._get_nested_value(context, left.strip())
+            right_val = right.strip().strip('"\'')
+            return str(left_val) != right_val
+        
+        # Simple truthiness check
+        value = self._get_nested_value(context, condition)
+        return bool(value)
+    
+    def _get_nested_value(self, context: dict, path: str) -> Any:
+        """Get value from nested dict using dot notation."""
+        parts = path.split('.')
+        value = context
+        
+        for part in parts:
+            if isinstance(value, dict):
+                value = value.get(part)
+            else:
+                return None
+            if value is None:
+                return None
+        
+        return value
+    
+    def _to_snake_case(self, s: str) -> str:
+        """Convert string to snake_case."""
+        s = re.sub(r'(?<!^)(?=[A-Z])', '_', s).lower()
+        s = re.sub(r'[\s-]+', '_', s)
+        return s
+    
+    def _to_kebab_case(self, s: str) -> str:
+        """Convert string to kebab-case."""
+        s = re.sub(r'(?<!^)(?=[A-Z])', '-', s).lower()
+        s = re.sub(r'[\s_]+', '-', s)
+        return s
+
+
+class PlatformManager:
+    """Manages platform configurations and generation."""
+    
+    # Map AI types to platform config files
+    AI_TO_PLATFORM = {
+        'claude': 'claude',
+        'cursor': 'cursor',
+        'windsurf': 'windsurf',
+        'antigravity': 'antigravity',
+        'copilot': 'copilot',
+        'kiro': 'kiro',
+        'opencode': 'opencode',
+        'roocode': 'roocode',
+        'codex': 'codex',
+        'qoder': 'qoder',
+        'gemini': 'gemini',
+        'trae': 'trae',
+        'continue': 'continue',
+        'codebuddy': 'codebuddy',
+        'droid': 'droid',
+        'cline': 'cline',
+        'all': 'all',
+    }
+    
+    def __init__(self, templates_dir: Optional[Path] = None):
+        self.engine = TemplateEngine(templates_dir)
+        self.platforms_dir = self.engine.templates_dir / "platforms"
+    
+    def load_platform_config(self, ai_type: str) -> PlatformConfig:
+        """Load configuration for an AI assistant type."""
+        platform_name = self.AI_TO_PLATFORM.get(ai_type)
+        if not platform_name:
+            raise ValueError(f"Unknown AI type: {ai_type}. Available: {list(self.AI_TO_PLATFORM.keys())}")
+        
+        config_path = self.platforms_dir / f"{platform_name}.yaml"
+        if not config_path.exists():
+            raise FileNotFoundError(f"Platform config not found: {config_path}")
+        
+        return PlatformConfig.from_yaml(config_path)
+    
+    def generate_skill(self, ai_type: str, output_dir: Path) -> list[str]:
+        """Generate skill files for a platform."""
+        config = self.load_platform_config(ai_type)
+        
+        # Determine output path
+        skill_dir = output_dir / config.folder_structure['root'] / config.folder_structure['skillPath']
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Render skill content
+        content = self.engine.render_platform_config(config)
+        
+        # Write skill file
+        skill_file = skill_dir / config.folder_structure['filename']
+        with open(skill_file, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        created = [str(skill_file)]
+        
+        # Copy data and scripts if full install
+        if config.install_type == 'full':
+            created.extend(self._copy_data_and_scripts(skill_dir))
+        
+        return created
+    
+    def generate_all_platforms(self, output_dir: Path) -> list[str]:
+        """Generate skill files for all platforms."""
+        all_created = []
+        for ai_type in self.AI_TO_PLATFORM.keys():
+            if ai_type == 'all':
+                continue
+            try:
+                created = self.generate_skill(ai_type, output_dir)
+                all_created.extend(created)
+            except Exception as e:
+                console.print(f"[yellow]Warning: Failed to generate for {ai_type}: {e}[/yellow]")
+        
+        return all_created
+    
+    def list_supported_platforms(self) -> dict[str, str]:
+        """List all supported AI platforms."""
+        platforms = {}
+        for ai_type, platform_name in self.AI_TO_PLATFORM.items():
+            if ai_type == 'all':
+                continue
+            try:
+                config = self.load_platform_config(ai_type)
+                platforms[ai_type] = config.display_name
+            except:
+                platforms[ai_type] = platform_name
+        
+        return platforms
+    
+    def _copy_data_and_scripts(self, skill_dir: Path) -> list[str]:
+        """Copy data and scripts to skill directory."""
+        created = []
+        
+        # Find source directories
+        cli_dir = self.engine.templates_dir.parent
+        
+        # Copy data (relative to existing ux-master structure)
+        data_source = cli_dir.parent / "data"
+        if data_source.exists():
+            import shutil
+            data_target = skill_dir / "data"
+            if data_target.exists():
+                shutil.rmtree(data_target)
+            shutil.copytree(data_source, data_target)
+            created.append(str(data_target))
+        
+        # Copy scripts
+        scripts_source = cli_dir.parent / "scripts"
+        if scripts_source.exists():
+            import shutil
+            scripts_target = skill_dir / "scripts"
+            if scripts_target.exists():
+                shutil.rmtree(scripts_target)
+            shutil.copytree(scripts_source, scripts_target)
+            created.append(str(scripts_target))
+        
+        return created

package/skills/cm-ux-master/cli/uxmaster/utils/__init__.py

@@ -0,0 +1,9 @@
+"""Utility functions for UX-Master CLI."""
+
+from .console import console, print_banner, print_success, print_error
+from .detect import detect_ai_type, get_ai_type_description
+
+__all__ = [
+    "console", "print_banner", "print_success", "print_error",
+    "detect_ai_type", "get_ai_type_description"
+]

package/skills/cm-ux-master/cli/uxmaster/utils/console.py

@@ -0,0 +1,42 @@
+"""Console utilities for rich output."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def print_banner():
+    """Print UX-Master banner."""
+    banner_text = Text()
+    banner_text.append("UX-Master ", style="bold cyan")
+    banner_text.append("v2.0.0", style="dim")
+    
+    panel = Panel(
+        banner_text,
+        subtitle="Ultimate UX Design Intelligence",
+        subtitle_align="center",
+        border_style="cyan"
+    )
+    console.print(panel)
+
+
+def print_success(message: str):
+    """Print success message."""
+    console.print(f"[bold green]✓[/bold green] {message}")
+
+
+def print_error(message: str):
+    """Print error message."""
+    console.print(f"[bold red]✗[/bold red] {message}")
+
+
+def print_warning(message: str):
+    """Print warning message."""
+    console.print(f"[bold yellow]⚠[/bold yellow] {message}")
+
+
+def print_info(message: str):
+    """Print info message."""
+    console.print(f"[blue]ℹ[/blue] {message}")

package/skills/cm-ux-master/cli/uxmaster/utils/detect.py

@@ -0,0 +1,83 @@
+"""AI assistant detection utilities."""
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+# AI type descriptions
+AI_DESCRIPTIONS = {
+    "claude": "Claude Code (Anthropic)",
+    "cursor": "Cursor IDE",
+    "windsurf": "Windsurf IDE",
+    "antigravity": "Antigravity (VS Code extension)",
+    "copilot": "GitHub Copilot",
+    "kiro": "Kiro (VS Code extension)",
+    "opencode": "OpenCode CLI",
+    "roocode": "Roo Code (VS Code extension)",
+    "codex": "Codex CLI (OpenAI)",
+    "qoder": "Qoder IDE",
+    "gemini": "Gemini CLI (Google)",
+    "trae": "Trae IDE",
+    "continue": "Continue (VS Code extension)",
+    "codebuddy": "CodeBuddy IDE",
+    "droid": "Droid (Factory)",
+    "cline": "Cline (VS Code extension)",
+}
+
+
+def detect_ai_type() -> Tuple[list[str], Optional[str]]:
+    """Detect which AI assistants are installed.
+    
+    Returns:
+        Tuple of (detected_types, suggested_type)
+    """
+    detected = []
+    suggested = None
+    
+    # Check for common configuration directories
+    cwd = Path.cwd()
+    home = Path.home()
+    
+    # Check current project
+    indicators = {
+        ".claude": "claude",
+        ".cursor": "cursor",
+        ".windsurf": "windsurf",
+        ".antigravity": "antigravity",
+        ".kiro": "kiro",
+        ".opencode": "opencode",
+        ".roocode": "roocode",
+        ".codex": "codex",
+        ".qoder": "qoder",
+        ".trae": "trae",
+        ".continue": "continue",
+        ".factory": "droid",
+    }
+    
+    for folder, ai_type in indicators.items():
+        if (cwd / folder).exists():
+            detected.append(ai_type)
+            if suggested is None:
+                suggested = ai_type
+    
+    # Check global configs
+    global_indicators = {
+        home / ".claude": "claude",
+        home / ".cursor": "cursor",
+        home / ".config" / "claude": "claude",
+    }
+    
+    for path, ai_type in global_indicators.items():
+        if path.exists() and ai_type not in detected:
+            detected.append(ai_type)
+    
+    return detected, suggested
+
+
+def get_ai_type_description(ai_type: str) -> str:
+    """Get human-readable description for AI type."""
+    return AI_DESCRIPTIONS.get(ai_type, ai_type.title())
+
+
+def list_all_ai_types() -> dict[str, str]:
+    """List all supported AI types."""
+    return AI_DESCRIPTIONS.copy()

package/skills/cm-ux-master/data/accessibility-advanced.csv

@@ -0,0 +1,26 @@
+Category,WCAG_Criterion,Keywords,Description,Do,Don't,Code_Good,Code_Bad,Severity,Level
+Focus,2.4.7 Focus Visible,focus visible indicator keyboard outline ring,Ensure focus indicator is clearly visible on all interactive elements,Use focus-visible with 2px+ outline offset from element,Remove outline without replacement,":focus-visible { outline: 2px solid #2563eb; outline-offset: 2px; }",":focus { outline: none; }",High,AA
+Focus,2.4.11 Focus Not Obscured,focus obscured covered hidden sticky,Ensure focused element is not obscured by sticky/fixed elements,scroll-margin-top to account for sticky headers,Fixed headers covering focused form fields,"scroll-margin-top: 80px; /* height of sticky header */","/* No scroll-margin with position:sticky header */",High,AA
+Focus,2.4.12 Focus Not Obscured Enhanced,focus visible enhanced fully visible,Focused element must be fully visible (not partially hidden),Ensure entire focused element is in viewport,Allowing partial visibility of focused element,"scrollIntoView({ block: 'center' })","/* Focus hidden behind modal overlay */",Medium,AAA
+Focus,2.4.13 Focus Appearance,focus appearance thickness area contrast,Focus indicator must have sufficient size and contrast,3:1 contrast ratio + 2px thickness + covers full perimeter,Thin single-side border change as only indicator,":focus-visible { outline: 3px solid #1e40af; outline-offset: 3px; }",":focus { border-bottom: 1px solid gray; }",High,AAA
+Target,2.5.8 Target Size Minimum,target size minimum 24px touch click,Interactive targets must be at least 24×24px CSS pixels,min-width: 24px min-height: 24px for all interactive elements,Inline links or buttons smaller than 24px,"min-height: 24px; min-width: 24px;","font-size: 12px; /* tiny link */",High,AA
+Target,2.5.5 Target Size Enhanced,target size enhanced 44px touch mobile,Interactive targets should be at least 44×44px for comfortable touch,44×44px minimum on mobile + adequate spacing between targets,Small targets close together on touch screens,"min-height: 44px; min-width: 44px; gap: 8px;","height: 20px; /* icon button */",Medium,AAA
+Motion,2.3.3 Animation from Interactions,animation interaction motion triggered,Animations triggered by interaction can be disabled by users,Provide prefers-reduced-motion override for all animations,Animations that cannot be paused or disabled,"@media (prefers-reduced-motion: reduce) { * { animation: none !important; transition-duration: 0.01ms !important; } }","/* No reduced-motion media query */",High,AAA
+Motion,2.2.2 Pause Stop Hide,pause stop hide auto-play carousel animation moving,Content that auto-plays can be paused stopped or hidden,Provide visible pause/stop controls for auto-playing content,Auto-playing carousels or videos without controls,"<button aria-label='Pause slideshow'>⏸</button>","<div class='carousel auto-play'> /* no pause */",High,AA
+Color,1.4.1 Use of Color,color alone information status,Color is not the only means of conveying information,Use icons + text + color for states like error/success,Red border only to indicate error,"<span class='error'>❌ Invalid email</span>","<input style='border-color:red'> /* color only */",High,AA
+Color,1.4.3 Contrast Minimum,contrast ratio text background 4.5 3,Text has minimum contrast ratio against background,4.5:1 for normal text + 3:1 for large text (18pt+/14pt bold),Low contrast gray text on light backgrounds,"color: #1e293b; background: #ffffff; /* 14.5:1 ratio */","color: #9ca3af; background: #f3f4f6; /* 2.2:1 ratio */",High,AA
+Color,1.4.6 Contrast Enhanced,contrast enhanced 7 ratio strict,Enhanced contrast ratios for maximum readability,7:1 for normal text + 4.5:1 for large text,Decorative text below 7:1 ratio on content pages,"color: #0f172a; background: #ffffff; /* 17.8:1 ratio */","color: #6b7280; background: #ffffff; /* 4.6:1 ratio */",Medium,AAA
+Color,1.4.11 Non-Text Contrast,non-text contrast ui component border icon,UI components and graphical objects have 3:1 contrast against adjacent colors,3:1 contrast for borders icons focus indicators,Low contrast borders or icons on similar backgrounds,"border: 2px solid #6b7280; /* 5.9:1 vs white */","border: 1px solid #e5e7eb; /* 1.4:1 vs white */",High,AA
+Structure,1.3.1 Info and Relationships,semantic html structure heading landmark,Programmatically communicate structure and relationships,Use semantic HTML elements and ARIA landmarks,"<div> soup without semantic meaning","<nav aria-label='Main'><ul>...</ul></nav>","<div class='nav'><div>...</div></div>",High,AA
+Structure,1.3.2 Meaningful Sequence,reading order dom visual logical,DOM order matches visual and logical reading order,Ensure CSS layout doesn't reorder content visually vs DOM,CSS order or flex-direction that breaks reading flow,"/* DOM matches visual order */","order: -1; /* visually first but last in DOM */",High,AA
+Structure,2.4.6 Headings and Labels,headings labels descriptive hierarchy,Headings and labels describe topic or purpose,Descriptive headings in logical hierarchy (h1→h2→h3),Vague headings or skipped heading levels,"<h1>Dashboard</h1><h2>Revenue</h2><h3>Monthly</h3>","<h1>Page</h1><h3>Section</h3> /* skipped h2 */",Medium,AA
+Forms,3.3.2 Labels or Instructions,label input form instruction required,Inputs have visible labels explaining required format,Visible <label> associated with each input,Placeholder-only inputs without labels,"<label for='email'>Email address</label><input id='email'>","<input placeholder='Email'> /* no label */",High,AA
+Forms,3.3.1 Error Identification,error identification form validation message,Errors are clearly identified and described in text,Specific error message near the field + aria-describedby,Generic "form has errors" at top of page,"<p id='email-error' role='alert'>Enter a valid email address</p>","<p>Form has errors</p> /* at top */",High,AA
+Forms,3.3.3 Error Suggestion,error suggestion correction format example,Suggest corrections when input errors are detected,Show expected format or example values near errors,Only showing "invalid" without help,"<p>Expected format: MM/DD/YYYY (e.g. 12/25/2025)</p>","<p>Invalid date</p> /* no help */",Medium,AA
+Forms,3.3.8 Accessible Authentication,accessible authentication captcha password,Authentication doesn't rely solely on cognitive function tests,Allow paste in password fields + support password managers,Blocking paste in password fields or using text CAPTCHAs,"<input type='password' autocomplete='current-password'>","<input onpaste='return false'> /* blocks paste */",High,AA
+Cognitive,3.2.6 Consistent Help,consistent help location support contact,Help mechanisms appear in same relative order across pages,Place help link/chat in consistent location (e.g. footer or FAB),Help in different locations on different pages,"/* Help always in bottom-right corner */","/* Help in header on page A footer on page B */",Medium,AA
+Cognitive,2.4.1 Bypass Blocks,skip navigation link bypass repeated,Provide skip links to bypass repeated content blocks,Hidden skip link that appears on focus before main nav,No skip navigation link,"<a href='#main' class='sr-only focus:not-sr-only'>Skip to content</a>","/* No skip link */",High,AA
+Screen Reader,4.1.2 Name Role Value,aria name role value state widget,Custom components expose name role and value to assistive technology,ARIA attributes on custom widgets matching behavior,Custom widgets without ARIA,<button aria-expanded='true' aria-controls='menu'>Menu</button>,<div onclick='toggleMenu()'>Menu</div>,High,AA
+Screen Reader,1.1.1 Text Alternatives,alt text image description decorative,Non-text content has text alternatives,Descriptive alt text for informative images + alt='' for decorative,"Missing alt attributes or alt='image'","<img alt='Revenue chart showing 23% growth in Q4'>","<img alt='chart'> or <img> /* no alt */",High,AA
+Screen Reader,4.1.3 Status Messages,status message aria-live polite assertive,Status messages are announced by screen readers without focus change,aria-live regions for dynamic content updates,Status changes that aren't announced,"<div role='status' aria-live='polite'>3 results found</div>","<div>3 results found</div> /* not announced */",High,AA
+Media,1.2.1 Audio/Video Alternatives,audio video captions transcript alternative,Pre-recorded audio/video has alternatives,Captions for video + transcripts for audio,Auto-play video without captions,"<video><track kind='captions' src='captions.vtt' srclang='en'></video>","<video autoplay> /* no captions */",High,AA