codymaster 4.1.4 → 4.4.1

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""UX-Master CLI - Entry point."""
+
+import sys
+from uxmaster.cli import cli
+
+def main():
+    """Main entry point."""
+    try:
+        cli()
+    except KeyboardInterrupt:
+        print("\n\n✋ Cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,349 @@
+#!/usr/bin/env python3
+"""
+UX-Master CLI
+Main command-line interface with rich output and interactive prompts.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.tree import Tree
+from rich import box
+
+from .template_engine import PlatformManager
+from .search_engine import SearchEngine
+
+console = Console()
+
+
+def print_banner():
+    """Print UX-Master banner."""
+    banner_text = """
+[bold cyan]    ██╗   ██╗██╗  ██╗[/bold cyan] [bold white]███╗   ███╗ █████╗ ███████╗████████╗███████╗██████╗ [/bold white]
+[bold cyan]    ██║   ██║╚██╗██╔╝[/bold cyan] [bold white]████╗ ████║██╔══██╗██╔════╝╚══██╔══╝██╔════╝██╔══██╗[/bold white]
+[bold cyan]    ██║   ██║ ╚███╔╝ [/bold cyan] [bold white]██╔████╔██║███████║███████╗   ██║   █████╗  ██████╔╝[/bold white]
+[bold cyan]    ██║   ██║ ██╔██╗ [/bold cyan] [bold white]██║╚██╔╝██║██╔══██║╚════██║   ██║   ██╔══╝  ██╔══██╗[/bold white]
+[bold cyan]    ╚██████╔╝██╔╝ ██╗[/bold cyan] [bold white]██║ ╚═╝ ██║██║  ██║███████║   ██║   ███████╗██║  ██║[/bold white]
+[bold cyan]     ╚═════╝ ╚═╝  ╚═╝[/bold cyan] [bold white]╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝   ╚═╝   ╚══════╝╚═╝  ╚═╝[/bold white]
+    """
+    console.print(banner_text)
+    console.print("[dim]                    Ultimate UX Design Intelligence v2.0.0[/dim]\n")
+
+
+@click.group()
+@click.version_option(version="2.0.0", prog_name="uxmaster")
+def cli():
+    """UX-Master CLI - Ultimate UX Design Intelligence.
+    
+    Features:
+    - 48 UX Laws for psychology-driven design
+    - 37 Design Tests with pass/fail criteria
+    - 16+ AI assistant integrations
+    - MCP server for AI tool integration
+    - Figma & Google Stitch integrations
+    """
+    pass
+
+
+@cli.command()
+@click.option('--ai', '-a', 
+              type=click.Choice([
+                  'claude', 'cursor', 'windsurf', 'antigravity', 
+                  'copilot', 'kiro', 'opencode', 'roocode',
+                  'codex', 'qoder', 'gemini', 'trae',
+                  'continue', 'codebuddy', 'droid', 'cline', 'all'
+              ]),
+              help='AI assistant to install for')
+@click.option('--global', '-g', 'global_install', is_flag=True,
+              help='Install to global/user config directory')
+@click.option('--force', '-f', is_flag=True,
+              help='Overwrite existing files')
+@click.option('--output', '-o', type=click.Path(),
+              help='Output directory (default: current directory)')
+@click.option('--dry-run', is_flag=True,
+              help='Show what would be generated without creating files')
+def init(ai: Optional[str], global_install: bool, force: bool, output: Optional[str], dry_run: bool):
+    """Install UX-Master skill for AI assistants.
+    
+    Examples:
+        uxm init --ai claude              # Install for Claude Code
+        uxm init --ai cursor --force      # Overwrite existing
+        uxm init --ai all                 # Install for all platforms
+        uxm init --ai figma --dry-run     # Preview Figma integration
+    """
+    from .commands.init import init_command
+    
+    print_banner()
+    
+    output_dir = Path(output) if output else (Path.home() / ".config" if global_install else Path.cwd())
+    
+    try:
+        created = init_command(ai, global_install, force, output_dir, dry_run)
+        
+        if dry_run:
+            console.print(f"\n[bold]Would create:[/bold]")
+            for path in created:
+                console.print(f"  [green]+[/green] {path}")
+        else:
+            console.print(f"\n[bold green]✓ Installation complete![/bold green]")
+            console.print(f"\n[bold]Created files:[/bold]")
+            for path in created:
+                console.print(f"  [green]+[/green] {path}")
+            
+            console.print(f"\n[bold cyan]Next steps:[/bold cyan]")
+            if ai == 'all':
+                console.print("  1. Restart your AI coding assistant")
+                console.print("  2. Try: [dim]\"Create a landing page for my SaaS\"[/dim]")
+            else:
+                console.print(f"  1. Restart your AI assistant")
+                console.print("  2. Try: [dim]\"Design a mobile app with proper touch targets\"[/dim]")
+                
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Installation failed:[/bold red] {e}")
+        raise click.ClickException(str(e))
+
+
+@cli.command()
+@click.argument('query')
+@click.option('--domain', '-d',
+              type=click.Choice([
+                  'ux-laws', 'design-tests', 'style', 'color', 
+                  'typography', 'product', 'landing', 'chart',
+                  'animation', 'responsive', 'accessibility', 'devices'
+              ]),
+              help='Search domain')
+@click.option('--stack', '-s',
+              type=click.Choice([
+                  'html-tailwind', 'react', 'nextjs', 'vue', 'nuxtjs',
+                  'nuxt-ui', 'svelte', 'astro', 'swiftui', 'react-native',
+                  'flutter', 'shadcn', 'jetpack-compose', 'angular',
+                  'htmx', 'electron', 'tauri'
+              ]),
+              help='Technology stack')
+@click.option('--max-results', '-n', default=3, help='Maximum results to show')
+@click.option('--design-system', '-ds', is_flag=True,
+              help='Generate complete design system recommendation')
+@click.option('--project-name', '-p', help='Project name for design system')
+@click.option('--format', '-f', 'output_format',
+              type=click.Choice(['ascii', 'markdown', 'json']),
+              default='ascii', help='Output format')
+@click.option('--persist', is_flag=True,
+              help='Save to design-system/MASTER.md')
+@click.option('--page', help='Create page-specific override file')
+def search(query: str, domain: Optional[str], stack: Optional[str], max_results: int,
+           design_system: bool, project_name: Optional[str], output_format: str,
+           persist: bool, page: Optional[str]):
+    """Search UX-Master knowledge base.
+    
+    Examples:
+        uxm search "fintech dashboard" --design-system
+        uxm search "mobile touch targets" --domain ux-laws
+        uxm search "glassmorphism" --domain style -n 5
+        uxm search "form validation" --stack react
+    """
+    from .commands.search import search_command
+    
+    print_banner()
+    
+    engine = SearchEngine()
+    
+    try:
+        if design_system:
+            result = engine.generate_design_system(
+                query=query,
+                project_name=project_name,
+                output_format=output_format
+            )
+            console.print(result)
+        elif stack:
+            results = engine.search_stack(query, stack, max_results)
+            _display_search_results(results, stack)
+        else:
+            results = engine.search(query, domain, max_results)
+            _display_search_results(results, domain)
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+
+def _display_search_results(results: list, source: Optional[str]):
+    """Display search results in a rich table."""
+    if not results:
+        console.print("[yellow]No results found[/yellow]")
+        return
+    
+    table = Table(
+        title=f"Search Results: {source or 'General'}",
+        box=box.ROUNDED,
+        show_header=True,
+        header_style="bold cyan"
+    )
+    
+    if results:
+        for key in results[0].keys():
+            if not key.startswith('_'):
+                table.add_column(key.replace('_', ' ').title(), overflow="fold")
+    
+    for result in results[:5]:
+        row_values = []
+        for key, value in result.items():
+            if not key.startswith('_'):
+                text = str(value)
+                if len(text) > 80:
+                    text = text[:77] + "..."
+                row_values.append(text)
+        table.add_row(*row_values)
+    
+    console.print(table)
+
+
+@cli.command()
+@click.argument('url')
+@click.option('--output', '-o', type=click.Path(), help='Output file')
+@click.option('--format', '-f', 
+              type=click.Choice(['json', 'yaml', 'css', 'tailwind']),
+              default='json', help='Output format')
+@click.option('--depth', '-d', default=1, help='Crawl depth (1-3)')
+@click.option('--figma', is_flag=True, help='Export to Figma variables')
+@click.option('--stitch', is_flag=True, help='Export to Google Stitch')
+@click.option('--screenshots', is_flag=True, help='Capture screenshots')
+def extract(url: str, output: Optional[str], format: str, depth: int, 
+            figma: bool, stitch: bool, screenshots: bool):
+    """Extract design system from website.
+    
+    Examples:
+        uxm extract https://stripe.com --output stripe-tokens.json
+        uxm extract https://linear.app --format tailwind
+        uxm extract https://vercel.com --figma
+    """
+    from .commands.extract import extract_command
+    
+    print_banner()
+    
+    console.print(f"[bold]Extracting from:[/bold] {url}")
+    console.print(f"[dim]Format: {format} | Depth: {depth}[/dim]\n")
+    
+    try:
+        result = extract_command(url, format)
+        console.print("[green]Extraction complete![/green]")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+
+@cli.command()
+@click.argument('target')
+@click.option('--suite', '-s',
+              type=click.Choice(['all', 'mobile', 'landing', 'dashboard', 'a11y', 'color', 'typography']),
+              default='all', help='Test suite to run (37 Design Tests)')
+@click.option('--format', '-f',
+              type=click.Choice(['rich', 'json', 'markdown', 'html']),
+              default='rich', help='Output format')
+@click.option('--output', '-o', type=click.Path(), help='Save report to file')
+@click.option('--url', '-u', is_flag=True, help='Target is a URL (use Harvester v4)')
+@click.option('--component', '-c', 
+              type=click.Choice(['button', 'input', 'card', 'modal', 'navigation', 'table']),
+              help='Validate specific component type')
+def validate(target: str, suite: str, format: str, output: Optional[str], url: bool, component: Optional[str]):
+    """Validate UI against 37 Design Tests using Validation Engine v4.
+    
+    Validates HTML files, URLs, or components against UX-Master's 37 Design Tests
+    including Fitts's Law, WCAG contrast, typography hierarchy, and more.
+    
+    Examples:
+        # Validate local HTML file
+        uxm validate index.html --suite mobile
+        
+        # Validate a live website
+        uxm validate https://stripe.com --url
+        
+        # Validate specific component
+        uxm validate button.json --component button
+        
+        # Generate HTML report
+        uxm validate index.html --suite all --format html --output report.html
+        
+        # Quick accessibility check
+        uxm validate https://example.com --url --suite a11y
+    """
+    from .commands.validate import validate_command, validate_url_command, validate_component_command
+    
+    print_banner()
+    
+    try:
+        if url:
+            console.print(f"[bold]Validating URL:[/bold] {target}")
+            console.print(f"[dim]Using Harvester v4 + Validation Engine | Suite: {suite}[/dim]\n")
+            result = validate_url_command(target, suite, Path(output) if output else None)
+        elif component:
+            console.print(f"[bold]Validating Component:[/bold] {component}")
+            console.print(f"[dim]File: {target} | Suite: {suite}[/dim]\n")
+            result = validate_component_command(component, Path(target))
+        else:
+            console.print(f"[bold]Validating File:[/bold] {target}")
+            console.print(f"[dim]Suite: {suite} | Format: {format}[/dim]\n")
+            result = validate_command(Path(target), suite, Path(output) if output else None, format)
+        
+        if result.get('error'):
+            console.print(f"[bold red]✗ Validation failed:[/bold red] {result['error']}")
+        else:
+            score = result.get('score', 0)
+            score_color = 'green' if score >= 80 else 'yellow' if score >= 60 else 'red'
+            console.print(f"\n[bold {score_color}]Score: {score:.0f}/100[/bold {score_color}]")
+            
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+
+@cli.command()
+def platforms():
+    """List supported AI platforms."""
+    print_banner()
+    
+    manager = PlatformManager()
+    platforms_dict = manager.list_supported_platforms()
+    
+    table = Table(
+        title="Supported AI Platforms",
+        box=box.ROUNDED,
+        show_header=True,
+        header_style="bold cyan"
+    )
+    
+    table.add_column("CLI Flag", style="dim")
+    table.add_column("Platform Name", style="bright_white")
+    table.add_column("Status", style="green")
+    
+    for key, name in sorted(platforms_dict.items()):
+        table.add_row(f"--ai {key}", name, "✓ Supported")
+    
+    console.print(table)
+    console.print(f"\n[dim]Total: {len(platforms_dict)} platforms[/dim]")
+
+
+@cli.command()
+def docs():
+    """Open UX-Master documentation."""
+    click.launch("https://ux-master.dev/docs")
+
+
+# Import and add MCP commands
+try:
+    from .commands.mcp import mcp as mcp_group
+    cli.add_command(mcp_group, name="mcp")
+except ImportError:
+    # MCP dependencies not installed
+    @cli.group()
+    def mcp():
+        """MCP server commands (install with: pip install uxmaster[mcp])"""
+        console.print("[yellow]MCP support not installed.[/yellow]")
+        console.print("[dim]Install with: pip install uxmaster[mcp][/dim]")
+        raise click.Abort()
+
+
+# Entry point
+if __name__ == "__main__":
+    cli()

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

@@ -0,0 +1,8 @@
+"""CLI commands for UX-Master."""
+
+from .init import init_command
+from .search import search_command
+from .extract import extract_command
+from .validate import validate_command
+
+__all__ = ["init_command", "search_command", "extract_command", "validate_command"]

package/skills/cm-ux-master/cli/uxmaster/commands/extract.py

@@ -0,0 +1,18 @@
+"""Extract command implementation."""
+
+from ..utils.console import console
+
+
+def extract_command(url: str, output_format: str = "json") -> dict:
+    """Extract design system from URL.
+    
+    Args:
+        url: Website URL
+        output_format: Output format
+        
+    Returns:
+        Extracted design tokens
+    """
+    # Placeholder - will integrate with harvester module
+    console.print(f"[yellow]Extraction from {url} - implementation pending[/yellow]")
+    return {}

package/skills/cm-ux-master/cli/uxmaster/commands/init.py

@@ -0,0 +1,58 @@
+"""Init command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.prompt import Confirm
+
+from ..template_engine import PlatformManager
+from ..utils.console import print_banner, print_success, print_error
+
+console = Console()
+
+
+def init_command(
+    ai: Optional[str],
+    global_install: bool = False,
+    force: bool = False,
+    output: Optional[Path] = None,
+    dry_run: bool = False
+) -> list[str]:
+    """Initialize UX-Master for an AI assistant.
+    
+    Args:
+        ai: AI assistant type
+        global_install: Install to global config
+        force: Overwrite existing files
+        output: Output directory
+        dry_run: Preview without creating files
+        
+    Returns:
+        List of created file paths
+    """
+    manager = PlatformManager()
+    
+    if ai is None:
+        raise click.UsageError("Please specify --ai or run interactively")
+    
+    # Determine output directory
+    if output:
+        output_dir = output
+    elif global_install:
+        output_dir = Path.home() / ".config"
+    else:
+        output_dir = Path.cwd()
+    
+    # Generate files
+    if dry_run:
+        console.print(f"[yellow]DRY RUN: Would generate for {ai}[/yellow]")
+        return []
+    
+    if ai == "all":
+        created = manager.generate_all_platforms(output_dir)
+    else:
+        created = manager.generate_skill(ai, output_dir)
+    
+    return created

package/skills/cm-ux-master/cli/uxmaster/commands/mcp.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+MCP (Model Context Protocol) command for UX-Master CLI
+
+Manages MCP server lifecycle and configuration.
+"""
+
+import subprocess
+import sys
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+
+@click.group()
+def mcp():
+    """Manage MCP (Model Context Protocol) server."""
+    pass
+
+
+@mcp.command()
+@click.option('--port', '-p', default=3000, help='Server port')
+@click.option('--host', '-h', default='0.0.0.0', help='Server host')
+@click.option('--detach', '-d', is_flag=True, help='Run in background')
+def start(port: int, host: str, detach: bool):
+    """Start the MCP server.
+    
+    Examples:
+        uxm mcp start              # Start on default port 3000
+        uxm mcp start -p 8080      # Start on port 8080
+        uxm mcp start -d           # Run in background
+    """
+    from ..utils.console import print_banner
+    print_banner()
+    
+    env = os.environ.copy()
+    env['PORT'] = str(port)
+    env['HOST'] = host
+    
+    if detach:
+        # Run in background
+        if sys.platform == 'darwin' or sys.platform.startswith('linux'):
+            subprocess.Popen(
+                [sys.executable, '-m', 'mcp.server'],
+                env=env,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            console.print(f"[green]✓[/green] MCP Server started in background on {host}:{port}")
+        else:
+            console.print("[yellow]Background mode not supported on this platform[/yellow]")
+    else:
+        # Run in foreground
+        console.print(f"[blue]Starting MCP Server on {host}:{port}...[/blue]")
+        console.print("[dim]Press Ctrl+C to stop[/dim]\n")
+        
+        try:
+            subprocess.run(
+                [sys.executable, '-m', 'mcp.server'],
+                env=env
+            )
+        except KeyboardInterrupt:
+            console.print("\n[yellow]MCP Server stopped[/yellow]")
+
+
+@mcp.command()
+def stop():
+    """Stop the running MCP server."""
+    import psutil
+    
+    killed = False
+    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+        try:
+            cmdline = proc.info.get('cmdline', [])
+            if cmdline and 'mcp.server' in ' '.join(cmdline):
+                proc.terminate()
+                killed = True
+                console.print(f"[green]✓[/green] Stopped MCP server (PID: {proc.info['pid']})")
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    
+    if not killed:
+        console.print("[yellow]No MCP server found running[/yellow]")
+
+
+@mcp.command()
+def status():
+    """Check MCP server status."""
+    import requests
+    
+    try:
+        response = requests.get('http://localhost:3000/health', timeout=2)
+        if response.status_code == 200:
+            data = response.json()
+            
+            panel = Panel(
+                f"[green]●[/green] Server is running\n"
+                f"[dim]Version:[/dim] {data.get('version', 'unknown')}\n"
+                f"[dim]URL:[/dim] http://localhost:3000\n"
+                f"[dim]API:[/dim] /mcp/v1/",
+                title="MCP Server Status",
+                border_style="green"
+            )
+            console.print(panel)
+            
+            # Show tools
+            tools_response = requests.post('http://localhost:3000/mcp/v1/tools/list', timeout=2)
+            if tools_response.status_code == 200:
+                tools = tools_response.json().get('tools', [])
+                
+                table = Table(title="Available Tools")
+                table.add_column("Tool", style="cyan")
+                table.add_column("Description", style="white")
+                
+                for tool in tools:
+                    table.add_row(
+                        tool.get('name', ''),
+                        tool.get('description', '')[:60] + '...'
+                    )
+                
+                console.print(table)
+        else:
+            console.print("[yellow]⚠ Server responded with error[/yellow]")
+    except requests.ConnectionError:
+        console.print("[red]✗[/red] MCP Server is not running")
+        console.print("[dim]Start with: uxm mcp start[/dim]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+
+@mcp.command()
+def config():
+    """Show MCP configuration."""
+    config_path = Path(__file__).parent.parent.parent.parent / "mcp" / "mcp-config.json"
+    
+    if config_path.exists():
+        import json
+        with open(config_path) as f:
+            config = json.load(f)
+        
+        console.print(Panel(
+            f"[bold]{config.get('name')}[/bold] v{config.get('version')}\n"
+            f"{config.get('description')}",
+            title="MCP Configuration",
+            border_style="blue"
+        ))
+        
+        console.print(f"\n[dim]Config file:[/dim] {config_path}")
+        console.print(f"[dim]Tools:[/dim] {len(config.get('tools', []))}")
+        console.print(f"[dim]Resources:[/dim] {len(config.get('resources', []))}")
+    else:
+        console.print("[red]Config file not found[/red]")
+
+
+@mcp.command()
+@click.argument('tool')
+@click.option('--data', '-d', help='JSON data for tool arguments')
+def call(tool: str, data: str):
+    """Call an MCP tool directly.
+    
+    Example:
+        uxm mcp call search_ux_laws -d '{"query": "mobile touch targets"}'
+    """
+    import requests
+    import json
+    
+    try:
+        arguments = json.loads(data) if data else {}
+        
+        response = requests.post(
+            'http://localhost:3000/mcp/v1/tools/call',
+            json={"name": tool, "arguments": arguments},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            console.print_json(json.dumps(result, indent=2))
+        else:
+            console.print(f"[red]Error:[/red] {response.status_code}")
+            console.print(response.text)
+    except requests.ConnectionError:
+        console.print("[red]MCP Server not running. Start with: uxm mcp start[/red]")
+    except json.JSONDecodeError:
+        console.print("[red]Invalid JSON in --data argument[/red]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")

package/skills/cm-ux-master/cli/uxmaster/commands/search.py

@@ -0,0 +1,23 @@
+"""Search command implementation."""
+
+from ..search_engine import SearchEngine
+from ..utils.console import console
+
+
+def search_command(
+    query: str,
+    domain: str | None,
+    max_results: int = 3
+) -> list[dict]:
+    """Execute search command.
+    
+    Args:
+        query: Search query
+        domain: Domain to search
+        max_results: Maximum results
+        
+    Returns:
+        List of search results
+    """
+    engine = SearchEngine()
+    return engine.search(query, domain, max_results)