nextog-cli 1.0.0__py3-none-any.whl

nextog/__init__.py

@@ -0,0 +1,4 @@
+"""nextOG CLI - Full QA Testing Automation Tool"""
+
+__version__ = "1.0.0"
+__app_name__ = "nextOG CLI"

nextog/cli.py

@@ -0,0 +1,545 @@
+"""
+nextOG CLI - Main Entry Point
+Full QA Testing Automation CLI Tool
+"""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from typing import Optional
+from pathlib import Path
+
+from nextog.core.engine import TestEngine
+from nextog.core.permissions import PermissionManager
+from nextog.core.privacy import PrivacyEngine
+from nextog.config.settings import Settings
+from nextog.data.local_db import LocalDatabase
+from nextog.reports import IndustrialReportGenerator
+
+app = typer.Typer(
+    name="nextog",
+    help="🚀 nextOG CLI - Full QA Testing Automation Tool",
+    add_completion=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+settings = Settings()
+db = LocalDatabase()
+permissions = PermissionManager(db)
+privacy = PrivacyEngine(db)
+report_generator = IndustrialReportGenerator(db, settings, privacy)
+
+
+# ──────────────────────────────────────────────────────────────
+# CLI Callback - Version & Config
+# ──────────────────────────────────────────────────────────────
+def version_callback(value: bool):
+    if value:
+        console.print(f"[bold green]nextOG CLI[/bold green] v{__import__('nextog').__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", callback=version_callback, is_eager=True
+    ),
+    config: Optional[Path] = typer.Option(
+        None, "--config", "-c", help="Path to config file"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", help="Enable verbose output"),
+):
+    """nextOG CLI - Full QA Testing Automation Tool"""
+    if config:
+        settings.load_from_file(config)
+    if verbose:
+        settings.set_verbose(True)
+
+
+# ──────────────────────────────────────────────────────────────
+# INIT Command - Initialize Project
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def init(
+    project_name: str = typer.Argument(..., help="Project name"),
+    template: str = typer.Option("full", help="Template: full, web, mobile, api, minimal"),
+):
+    """Initialize a new nextOG testing project"""
+    console.print(Panel(f"[bold]Initializing project: {project_name}[/bold]"))
+    
+    from nextog.core.runner import ProjectInitializer
+    initializer = ProjectInitializer(settings, db)
+    initializer.create_project(project_name, template)
+    
+    console.print("[green]✓[/green] Project initialized successfully!")
+    console.print(f"  → Config: .nextog/config.yaml")
+    console.print(f"  → Tests:  .nextog/tests/")
+    console.print(f"  → Run:    [bold]nextog test web --url <url>[/bold]")
+
+
+# ──────────────────────────────────────────────────────────────
+# TEST Command - Run Tests
+# ──────────────────────────────────────────────────────────────
+test_app = typer.Typer(help="Run various types of tests")
+app.add_typer(test_app, name="test")
+
+
+@test_app.command("web")
+def test_web(
+    url: str = typer.Option(..., "--url", "-u", help="URL to test"),
+    browser: str = typer.Option("chromium", help="Browser: chromium, firefox, webkit"),
+    responsive: bool = typer.Option(True, help="Test responsive design"),
+    accessibility: bool = typer.Option(True, help="Test accessibility"),
+    performance: bool = typer.Option(False, help="Run performance tests"),
+    coverage_target: int = typer.Option(90, help="Target coverage percentage"),
+    headless: bool = typer.Option(True, help="Run in headless mode"),
+):
+    """Run web application tests"""
+    console.print(Panel(f"[bold blue]Web Testing:[/bold blue] {url}"))
+    
+    from nextog.engines.web.browser import WebTestEngine
+    engine = WebTestEngine(settings, db, privacy)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Running web tests...", total=None)
+        results = engine.run_tests(
+            url=url,
+            browser=browser,
+            responsive=responsive,
+            accessibility=accessibility,
+            performance=performance,
+            coverage_target=coverage_target,
+            headless=headless,
+        )
+        progress.update(task, completed=True)
+    
+    _display_results(results, "Web Tests")
+    
+    # Auto-generate industrial Excel report
+    _auto_generate_report(results, "web")
+
+
+@test_app.command("mobile")
+def test_mobile(
+    app_path: str = typer.Option(..., "--app", "-a", help="Path to app (.apk/.ipa)"),
+    platform: str = typer.Option("android", help="Platform: android, ios"),
+    device: str = typer.Option("emulator", help="Device or emulator"),
+    coverage_target: int = typer.Option(90, help="Target coverage percentage"),
+):
+    """Run mobile application tests"""
+    console.print(Panel(f"[bold magenta]Mobile Testing:[/bold magenta] {app_path}"))
+    
+    from nextog.engines.mobile.android import MobileTestEngine
+    engine = MobileTestEngine(settings, db, privacy)
+    
+    results = engine.run_tests(
+        app_path=app_path,
+        platform=platform,
+        device=device,
+        coverage_target=coverage_target,
+    )
+    
+    _display_results(results, "Mobile Tests")
+    
+    # Auto-generate industrial Excel report
+    _auto_generate_report(results, "mobile")
+
+
+@test_app.command("api")
+def test_api(
+    spec: str = typer.Option(..., "--spec", "-s", help="API spec file (OpenAPI/GraphQL)"),
+    base_url: str = typer.Option(..., "--base-url", "-b", help="Base URL for API"),
+    auth: Optional[str] = typer.Option(None, help="Auth token or credentials"),
+    coverage_target: int = typer.Option(90, help="Target coverage percentage"),
+):
+    """Run API tests"""
+    console.print(Panel(f"[bold yellow]API Testing:[/bold yellow] {base_url}"))
+    
+    from nextog.engines.api.rest import APITestEngine
+    engine = APITestEngine(settings, db, privacy)
+    
+    results = engine.run_tests(
+        spec_file=spec,
+        base_url=base_url,
+        auth=auth,
+        coverage_target=coverage_target,
+    )
+    
+    _display_results(results, "API Tests")
+    
+    # Auto-generate industrial Excel report
+    _auto_generate_report(results, "api")
+
+
+@test_app.command("embedded")
+def test_embedded(
+    target: str = typer.Option(..., "--target", "-t", help="Target device/IP"),
+    protocol: str = typer.Option("mqtt", help="Protocol: mqtt, coap, http, serial"),
+    firmware: Optional[str] = typer.Option(None, help="Firmware version"),
+    coverage_target: int = typer.Option(90, help="Target coverage percentage"),
+):
+    """Run embedded systems tests"""
+    console.print(Panel(f"[bold red]Embedded Systems Testing:[/bold red] {target}"))
+    
+    from nextog.engines.embedded.hardware import EmbeddedTestEngine
+    engine = EmbeddedTestEngine(settings, db, privacy)
+    
+    results = engine.run_tests(
+        target=target,
+        protocol=protocol,
+        firmware=firmware,
+        coverage_target=coverage_target,
+    )
+    
+    _display_results(results, "Embedded Tests")
+    
+    # Auto-generate industrial Excel report
+    _auto_generate_report(results, "embedded")
+
+
+@test_app.command("all")
+def test_all(
+    config: str = typer.Option(".nextog/config.yaml", help="Project config file"),
+    coverage_target: int = typer.Option(90, help="Target coverage percentage"),
+    parallel: bool = typer.Option(True, help="Run tests in parallel"),
+):
+    """Run all configured tests"""
+    console.print(Panel("[bold green]Running All Tests[/bold green]"))
+    
+    from nextog.core.runner import TestRunner
+    runner = TestRunner(settings, db, privacy, permissions)
+    
+    results = runner.run_all(
+        config_path=config,
+        coverage_target=coverage_target,
+        parallel=parallel,
+    )
+    
+    _display_results(results, "All Tests")
+    
+    # Auto-generate industrial Excel report
+    _auto_generate_report(results, "full")
+
+
+# ──────────────────────────────────────────────────────────────
+# COVERAGE Command - Coverage Tracking
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def coverage(
+    report: bool = typer.Option(False, help="Generate coverage report"),
+    format: str = typer.Option("table", help="Format: table, html, json, pdf"),
+    project: Optional[str] = typer.Option(None, help="Project name filter"),
+):
+    """View and manage test coverage"""
+    from nextog.core.reporter import CoverageReporter
+    
+    reporter = CoverageReporter(db, settings)
+    data = reporter.get_coverage(project)
+    
+    if report:
+        output = reporter.generate_report(data, format)
+        console.print(f"[green]✓[/green] Report generated: {output}")
+    else:
+        reporter.display_coverage(data)
+
+
+# ──────────────────────────────────────────────────────────────
+# LIVE Command - Live Testing Panel
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def live(
+    port: int = typer.Option(8080, help="Dashboard port"),
+    host: str = typer.Option("127.0.0.1", help="Dashboard host"),
+    open_browser: bool = typer.Option(True, help="Open browser automatically"),
+):
+    """Start live testing dashboard"""
+    console.print(Panel(f"[bold]Live Dashboard starting on http://{host}:{port}[/bold]"))
+    
+    from nextog.live.panel import LivePanel
+    panel = LivePanel(settings, db, privacy)
+    panel.start(host=host, port=port, open_browser=open_browser)
+
+
+# ──────────────────────────────────────────────────────────────
+# USER Command - User & Permission Management
+# ──────────────────────────────────────────────────────────────
+user_app = typer.Typer(help="Manage users and permissions")
+app.add_typer(user_app, name="user")
+
+
+@user_app.command("create")
+def user_create(
+    username: str = typer.Argument(..., help="Username"),
+    role: str = typer.Option("tester", help="Role: admin, tester, viewer, ci"),
+    email: Optional[str] = typer.Option(None, help="User email"),
+):
+    """Create a new user"""
+    permissions.create_user(username, role, email)
+    console.print(f"[green]✓[/green] User '{username}' created with role '{role}'")
+
+
+@user_app.command("list")
+def user_list():
+    """List all users"""
+    users = permissions.list_users()
+    table = Table(title="Users")
+    table.add_column("Username", style="cyan")
+    table.add_column("Role", style="green")
+    table.add_column("Email", style="white")
+    table.add_column("Status", style="yellow")
+    
+    for user in users:
+        table.add_row(user["username"], user["role"], user["email"] or "-", user["status"])
+    
+    console.print(table)
+
+
+@user_app.command("role")
+def user_role(
+    username: str = typer.Argument(..., help="Username"),
+    role: str = typer.Argument(..., help="New role"),
+):
+    """Change user role"""
+    permissions.update_role(username, role)
+    console.print(f"[green]✓[/green] Role updated for '{username}' → '{role}'")
+
+
+# ──────────────────────────────────────────────────────────────
+# TRAIN Command - Auto Training
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def train(
+    action: str = typer.Option("status", help="Action: status, start, stop, optimize"),
+    iterations: int = typer.Option(100, help="Training iterations"),
+):
+    """Manage auto-training from user patterns"""
+    from nextog.training.learner import TrainingEngine
+    
+    trainer = TrainingEngine(db, settings)
+    
+    if action == "status":
+        status = trainer.get_status()
+        console.print(Panel(f"[bold]Training Status[/bold]"))
+        console.print(f"  Patterns learned: {status['patterns']}")
+        console.print(f"  Test cases optimized: {status['optimized']}")
+        console.print(f"  Last trained: {status['last_trained']}")
+        console.print(f"  Model accuracy: {status['accuracy']}%")
+    
+    elif action == "start":
+        console.print("[bold]Starting training...[/bold]")
+        trainer.train(iterations=iterations)
+        console.print("[green]✓[/green] Training complete!")
+    
+    elif action == "optimize":
+        console.print("[bold]Optimizing test cases...[/bold]")
+        trainer.optimize_tests()
+        console.print("[green]✓[/green] Optimization complete!")
+
+
+# ──────────────────────────────────────────────────────────────
+# DATA Command - Privacy & Data Management
+# ──────────────────────────────────────────────────────────────
+data_app = typer.Typer(help="Manage local data & privacy")
+app.add_typer(data_app, name="data")
+
+
+@data_app.command("export")
+def data_export(
+    output: str = typer.Option("nextog-export.json", help="Output file"),
+    encrypt: bool = typer.Option(True, help="Encrypt exported data"),
+):
+    """Export all local data (privacy-first)"""
+    privacy.export_data(output, encrypt)
+    console.print(f"[green]✓[/green] Data exported to: {output}")
+
+
+@data_app.command("purge")
+def data_purge(
+    confirm: bool = typer.Option(False, "--yes", help="Skip confirmation"),
+):
+    """Delete ALL local data permanently"""
+    if not confirm:
+        typer.confirm("⚠️  This will delete ALL local data. Continue?", abort=True)
+    
+    privacy.purge_all_data()
+    console.print("[red]✓[/red] All data purged.")
+
+
+@data_app.command("stats")
+def data_stats():
+    """Show data storage statistics"""
+    stats = privacy.get_storage_stats()
+    console.print(Panel("[bold]Data Storage Stats[/bold]"))
+    console.print(f"  Database size: {stats['db_size']}")
+    console.print(f"  Test results: {stats['test_count']}")
+    console.print(f"  Patterns: {stats['pattern_count']}")
+    console.print(f"  Encryption: {'✓ AES-256' if stats['encrypted'] else '✗ None'}")
+    console.print(f"  External sync: {'DISABLED' if not stats['external_sync'] else 'ENABLED'}")
+
+
+# ──────────────────────────────────────────────────────────────
+# ELEMENTS Command - System Element Detection
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def elements(
+    target: str = typer.Argument(..., help="Target URL or app path"),
+    explain: bool = typer.Option(True, help="Explain each element's use"),
+    output: Optional[str] = typer.Option(None, help="Save to file"),
+):
+    """Detect and explain system elements for testing"""
+    from nextog.engines.web.elements import ElementDetector
+    
+    detector = ElementDetector(settings, db)
+    found = detector.detect(target, explain=explain)
+    
+    table = Table(title=f"Detected Elements: {target}")
+    table.add_column("Element", style="cyan")
+    table.add_column("Type", style="green")
+    table.add_column("Description", style="white")
+    table.add_column("Test Priority", style="yellow")
+    
+    for elem in found:
+        table.add_row(elem["name"], elem["type"], elem["description"], elem["priority"])
+    
+    console.print(table)
+    
+    if output:
+        detector.save_elements(found, output)
+        console.print(f"[green]✓[/green] Elements saved to: {output}")
+
+
+# ──────────────────────────────────────────────────────────────
+# REPORT Command - Generate Excel Reports
+# ──────────────────────────────────────────────────────────────
+@app.command()
+def report(
+    test_type: str = typer.Option("auto", "--type", "-t", help="Test type: web, mobile, api, embedded, full, auto"),
+    last: bool = typer.Option(True, "--last", help="Generate report for last test run"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Custom output path"),
+    open_file: bool = typer.Option(True, "--open", help="Open report after generation"),
+):
+    """Generate industrial Excel report from test results"""
+    console.print(Panel("[bold blue]📊 Generating Industrial Excel Report...[/bold blue]"))
+    
+    # Get latest results from DB
+    results = db.get_latest_results()
+    
+    if not results:
+        console.print("[yellow]⚠ No test results found. Run tests first.[/yellow]")
+        console.print("  → nextog test web --url <url>")
+        console.print("  → nextog test mobile --app <app>")
+        console.print("  → nextog test api --spec <spec>")
+        raise typer.Exit(1)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Building Excel report...", total=None)
+        
+        filepath = report_generator.generate_after_test(
+            test_results=results.get("results", results),
+            test_type=test_type if test_type != "auto" else results.get("engine", "auto"),
+        )
+        progress.update(task, completed=True)
+    
+    console.print(f"\n[green]✅ Report Generated Successfully![/green]")
+    console.print(f"  📄 File: [bold]{filepath}[/bold]")
+    console.print(f"  📊 Sheets: 10 (Summary, Details, Coverage, Elements, Defects, Performance, Charts, Recommendations, Environment, Sign-Off)")
+    console.print(f"  🔐 Privacy: [green]LOCAL ONLY — No data transferred[/green]")
+    
+    if open_file:
+        try:
+            import subprocess, platform
+            if platform.system() == "Darwin":
+                subprocess.run(["open", filepath])
+            elif platform.system() == "Windows":
+                subprocess.run(["start", filepath], shell=True)
+            else:
+                subprocess.run(["xdg-open", filepath])
+        except Exception:
+            pass
+
+
+# ──────────────────────────────────────────────────────────────
+# Helper Functions
+# ──────────────────────────────────────────────────────────────
+def _auto_generate_report(results: dict, test_type: str):
+    """Auto-generate industrial Excel report after any test"""
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("📊 Generating Excel report...", total=None)
+            
+            filepath = report_generator.generate_after_test(
+                test_results=results,
+                test_type=test_type,
+            )
+            progress.update(task, completed=True)
+        
+        console.print(f"\n[green]✅ Excel Report Auto-Generated![/green]")
+        console.print(f"  📄 [bold]{filepath}[/bold]")
+        console.print(f"  📊 10 Sheets: Summary | Details | Coverage | Elements | Defects | Performance | Charts | Recommendations | Environment | Sign-Off")
+        console.print(f"  🔐 All data stored locally — Zero external transfer")
+        
+        # Try to auto-open the report
+        try:
+            import subprocess, platform as plat
+            if plat.system() == "Darwin":
+                subprocess.run(["open", filepath], timeout=3)
+            elif plat.system() == "Windows":
+                subprocess.run(["start", filepath], shell=True, timeout=3)
+            else:
+                subprocess.run(["xdg-open", filepath], timeout=3)
+        except Exception:
+            pass
+    
+    except Exception as e:
+        console.print(f"[yellow]⚠ Could not generate Excel report: {e}[/yellow]")
+        console.print("[dim]Install openpyxl: pip install openpyxl[/dim]")
+def _display_results(results: dict, title: str):
+    """Display test results in a formatted table"""
+    table = Table(title=f"📊 {title} Results")
+    table.add_column("Category", style="cyan")
+    table.add_column("Total", style="white")
+    table.add_column("Passed", style="green")
+    table.add_column("Failed", style="red")
+    table.add_column("Skipped", style="yellow")
+    table.add_column("Coverage", style="bold blue")
+    
+    for category, data in results.get("categories", {}).items():
+        table.add_row(
+            category,
+            str(data["total"]),
+            str(data["passed"]),
+            str(data["failed"]),
+            str(data["skipped"]),
+            f"{data['coverage']}%",
+        )
+    
+    console.print(table)
+    
+    # Summary
+    total_coverage = results.get("total_coverage", 0)
+    console.print(f"\n[bold]Total Coverage: {total_coverage}%[/bold]")
+    
+    if total_coverage >= 80:
+        console.print("[green]✅ Excellent coverage![/green]")
+    elif total_coverage >= 60:
+        console.print("[yellow]⚠️  Good coverage, room for improvement[/yellow]")
+    else:
+        console.print("[red]❌ Low coverage - add more tests[/red]")
+
+
+if __name__ == "__main__":
+    app()

nextog/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration modules"""

nextog/config/settings.py

@@ -0,0 +1,132 @@
+"""
+Settings Manager - Configuration management for nextOG CLI
+"""
+
+from typing import Dict, Any, Optional
+from pathlib import Path
+import yaml
+
+
+class Settings:
+    """Application settings management"""
+    
+    DEFAULTS = {
+        "project": "default",
+        "version": "1.0",
+        "verbose": False,
+        "parallel": True,
+        "coverage_target": 90,
+        "headless": True,
+        "default_browser": "chromium",
+        "default_platform": "android",
+        "default_protocol": "mqtt",
+        "live_panel": {
+            "host": "127.0.0.1",
+            "port": 8080,
+        },
+        "privacy": {
+            "encrypt_local": True,
+            "external_sync": False,  # NEVER enable
+            "auto_backup": True,
+            "backup_count": 5,
+        },
+        "training": {
+            "auto_train": True,
+            "iterations": 100,
+            "pattern_threshold": 3,
+        },
+        "reporting": {
+            "format": "html",
+            "include_screenshots": True,
+            "include_logs": True,
+        },
+        "engines": {
+            "web": {
+                "browser": "chromium",
+                "responsive": True,
+                "accessibility": True,
+                "performance": False,
+                "viewports": ["mobile", "tablet", "desktop"],
+            },
+            "mobile": {
+                "platform": "android",
+                "device": "emulator",
+                "appium_url": "http://127.0.0.1:4723",
+            },
+            "api": {
+                "timeout": 30,
+                "retry_count": 3,
+                "verify_ssl": True,
+            },
+            "embedded": {
+                "protocol": "mqtt",
+                "timeout": 10,
+            },
+        },
+    }
+    
+    def __init__(self):
+        self._config: Dict[str, Any] = dict(self.DEFAULTS)
+        self._load_global_config()
+    
+    def _load_global_config(self):
+        """Load global config from ~/.nextog/config.yaml"""
+        global_config = Path.home() / ".nextog" / "config.yaml"
+        if global_config.exists():
+            with open(global_config) as f:
+                user_config = yaml.safe_load(f) or {}
+                self._deep_merge(self._config, user_config)
+    
+    def load_from_file(self, path: Path):
+        """Load config from file"""
+        if path.exists():
+            with open(path) as f:
+                file_config = yaml.safe_load(f) or {}
+                self._deep_merge(self._config, file_config)
+    
+    def save_to_file(self, path: Path):
+        """Save config to file"""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            yaml.dump(self._config, f, default_flow_style=False)
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a config value by dot-separated key"""
+        keys = key.split(".")
+        value = self._config
+        
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+        
+        return value
+    
+    def set(self, key: str, value: Any):
+        """Set a config value"""
+        keys = key.split(".")
+        config = self._config
+        
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        
+        config[keys[-1]] = value
+    
+    def set_verbose(self, verbose: bool):
+        """Set verbose mode"""
+        self._config["verbose"] = verbose
+    
+    def to_dict(self) -> Dict:
+        """Get all config as dict"""
+        return dict(self._config)
+    
+    def _deep_merge(self, base: Dict, override: Dict):
+        """Deep merge override into base"""
+        for key, value in override.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                self._deep_merge(base[key], value)
+            else:
+                base[key] = value

nextog/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules for nextOG CLI"""