nextog-cli 1.0.0__py3-none-any.whl

nextog/training/__init__.py

@@ -0,0 +1 @@
+"""Training and auto-learning modules"""

nextog/training/learner.py

@@ -0,0 +1,269 @@
+"""
+Auto-Training Engine - Learns from user patterns automatically
+All training happens locally - no external data transfer
+"""
+
+import json
+import time
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from pathlib import Path
+from collections import Counter
+from rich.console import Console
+
+console = Console()
+
+
+class TrainingEngine:
+    """Auto-trains from user interaction patterns to optimize testing"""
+    
+    def __init__(self, db, settings):
+        self.db = db
+        self.settings = settings
+        self.patterns: List[Dict] = []
+        self.test_history: List[Dict] = []
+    
+    def get_status(self) -> Dict:
+        """Get training status"""
+        pattern_count = self.db.count_patterns()
+        test_count = self.db.count_test_results()
+        last_trained = self.db.get_metadata("last_trained") or "Never"
+        accuracy = self.db.get_metadata("model_accuracy") or 0
+        
+        return {
+            "patterns": pattern_count,
+            "optimized": self.db.count_optimized_tests(),
+            "last_trained": last_trained,
+            "accuracy": accuracy,
+        }
+    
+    def train(self, iterations: int = 100):
+        """Run training cycle on user data"""
+        console.print("[bold]Loading user data (local only)...[/bold]")
+        
+        # Load all local test history
+        self.test_history = self.db.get_all_test_results()
+        
+        # Phase 1: Extract patterns
+        console.print("  → Extracting patterns...")
+        self._extract_patterns()
+        
+        # Phase 2: Build frequency model
+        console.print("  → Building frequency model...")
+        self._build_frequency_model()
+        
+        # Phase 3: Identify common failures
+        console.print("  → Identifying failure patterns...")
+        self._identify_failure_patterns()
+        
+        # Phase 4: Optimize test order
+        console.print("  → Optimizing test order...")
+        self._optimize_test_order()
+        
+        # Phase 5: Generate suggestions
+        console.print("  → Generating test suggestions...")
+        self._generate_suggestions()
+        
+        # Save training results
+        self._save_training_results(iterations)
+    
+    def _extract_patterns(self):
+        """Extract patterns from test history"""
+        pattern_types = [
+            "element_click", "form_submit", "navigation",
+            "api_call", "error_occurred", "timeout",
+            "element_not_found", "assertion_failed",
+        ]
+        
+        for test in self.test_history:
+            results = test.get("results", {})
+            
+            for pattern_type in pattern_types:
+                occurrences = self._count_pattern(test, pattern_type)
+                
+                if occurrences > 0:
+                    pattern = {
+                        "type": pattern_type,
+                        "frequency": occurrences,
+                        "context": test.get("engine", "unknown"),
+                        "timestamp": test.get("timestamp", ""),
+                        "related_elements": self._extract_elements(test),
+                    }
+                    self.patterns.append(pattern)
+                    self.db.save_pattern(pattern)
+    
+    def _build_frequency_model(self):
+        """Build frequency model of user actions"""
+        action_counts = Counter()
+        
+        for test in self.test_history:
+            engine = test.get("engine", "unknown")
+            action_counts[engine] += 1
+            
+            # Count test types
+            categories = test.get("results", {}).get("categories", {})
+            for cat_name, cat_data in categories.items():
+                action_counts[f"{engine}:{cat_name}"] += cat_data.get("total", 0)
+        
+        # Save frequency model
+        model = {
+            "action_frequencies": dict(action_counts),
+            "total_tests": len(self.test_history),
+            "most_used_engine": action_counts.most_common(1)[0][0] if action_counts else "none",
+        }
+        
+        self.db.save_metadata("frequency_model", model)
+    
+    def _identify_failure_patterns(self):
+        """Identify common failure patterns"""
+        failure_patterns = []
+        
+        for test in self.test_history:
+            results = test.get("results", {})
+            details = results.get("details", [])
+            
+            for detail in details:
+                if isinstance(detail, dict) and detail.get("status") == "failed":
+                    pattern = {
+                        "engine": test.get("engine", "unknown"),
+                        "test_name": detail.get("name", "unknown"),
+                        "error": detail.get("error", ""),
+                        "element": detail.get("element", ""),
+                        "timestamp": test.get("timestamp", ""),
+                    }
+                    failure_patterns.append(pattern)
+        
+        # Group similar failures
+        error_groups = {}
+        for fp in failure_patterns:
+            key = fp["error"][:50]  # Group by error prefix
+            if key not in error_groups:
+                error_groups[key] = []
+            error_groups[key].append(fp)
+        
+        # Save failure patterns
+        self.db.save_metadata("failure_patterns", {
+            "groups": {k: len(v) for k, v in error_groups.items()},
+            "top_failures": sorted(error_groups.items(), key=lambda x: len(x[1]), reverse=True)[:10],
+        })
+    
+    def _optimize_test_order(self):
+        """Optimize test execution order based on failure history"""
+        # Tests that fail more often should run earlier (fail fast)
+        failure_count = Counter()
+        
+        for test in self.test_history:
+            results = test.get("results", {})
+            details = results.get("details", [])
+            
+            for detail in details:
+                if isinstance(detail, dict) and detail.get("status") == "failed":
+                    failure_count[detail.get("name", "unknown")] += 1
+        
+        # Save optimized order
+        optimized_order = [name for name, _ in failure_count.most_common()]
+        self.db.save_metadata("optimized_test_order", optimized_order)
+    
+    def _generate_suggestions(self):
+        """Generate test suggestions based on patterns"""
+        suggestions = []
+        
+        # If many form failures, suggest more form tests
+        form_failures = sum(1 for p in self.patterns if "form" in p.get("type", ""))
+        if form_failures > 5:
+            suggestions.append({
+                "type": "add_tests",
+                "area": "forms",
+                "reason": f"High form failure rate ({form_failures} patterns)",
+                "priority": "high",
+            })
+        
+        # If many timeouts, suggest performance tests
+        timeout_patterns = sum(1 for p in self.patterns if p.get("type") == "timeout")
+        if timeout_patterns > 3:
+            suggestions.append({
+                "type": "add_tests",
+                "area": "performance",
+                "reason": f"Frequent timeouts ({timeout_patterns} occurrences)",
+                "priority": "high",
+            })
+        
+        # If many element_not_found, suggest element coverage review
+        not_found = sum(1 for p in self.patterns if p.get("type") == "element_not_found")
+        if not_found > 5:
+            suggestions.append({
+                "type": "review",
+                "area": "elements",
+                "reason": f"Elements frequently not found ({not_found} times)",
+                "priority": "medium",
+            })
+        
+        self.db.save_metadata("suggestions", suggestions)
+    
+    def _count_pattern(self, test: Dict, pattern_type: str) -> int:
+        """Count occurrences of a pattern in a test result"""
+        results = test.get("results", {})
+        details = results.get("details", [])
+        count = 0
+        
+        for detail in details:
+            if isinstance(detail, dict):
+                if pattern_type in str(detail).lower():
+                    count += 1
+        
+        return count
+    
+    def _extract_elements(self, test: Dict) -> List[str]:
+        """Extract element names from test results"""
+        elements = []
+        details = test.get("results", {}).get("details", [])
+        
+        for detail in details:
+            if isinstance(detail, dict) and "element" in detail:
+                elements.append(detail["element"])
+        
+        return elements
+    
+    def _save_training_results(self, iterations: int):
+        """Save training results"""
+        accuracy = self._calculate_accuracy()
+        
+        self.db.save_metadata("last_trained", datetime.now().isoformat())
+        self.db.save_metadata("model_accuracy", accuracy)
+        self.db.save_metadata("training_iterations", iterations)
+    
+    def _calculate_accuracy(self) -> float:
+        """Calculate model accuracy from pattern matching"""
+        if not self.test_history:
+            return 0.0
+        
+        correct_predictions = 0
+        total_predictions = 0
+        
+        for i, test in enumerate(self.test_history[1:], 1):
+            # Simple prediction: based on previous test patterns
+            prev_test = self.test_history[i - 1]
+            prev_engine = prev_test.get("engine", "")
+            curr_engine = test.get("engine", "")
+            
+            total_predictions += 1
+            if prev_engine == curr_engine:
+                correct_predictions += 1
+        
+        if total_predictions == 0:
+            return 0.0
+        
+        return round((correct_predictions / total_predictions) * 100, 2)
+    
+    def optimize_tests(self):
+        """Apply learned optimizations to test suite"""
+        console.print("[bold]Applying optimizations...[/bold]")
+        
+        optimized_order = self.db.get_metadata("optimized_test_order") or []
+        suggestions = self.db.get_metadata("suggestions") or []
+        
+        console.print(f"  → Reordered {len(optimized_order)} tests for fail-fast execution")
+        console.print(f"  → Generated {len(suggestions)} test suggestions")
+        
+        for suggestion in suggestions:
+            console.print(f"  → [{suggestion['priority']}] {suggestion['reason']}")

nextog/training/patterns.py

@@ -0,0 +1,102 @@
+"""Pattern Recognition for Test Optimization"""
+
+from typing import Dict, List, Any
+from collections import Counter, defaultdict
+
+
+class PatternRecognizer:
+    """Recognizes patterns in test execution for optimization"""
+    
+    def __init__(self):
+        self.patterns: List[Dict] = []
+        self.sequence_patterns: List[Dict] = []
+        self.failure_correlations: Dict[str, List[str]] = defaultdict(list)
+    
+    def analyze_sequences(self, test_results: List[Dict]) -> List[Dict]:
+        """Analyze sequences of test executions to find patterns"""
+        sequences = []
+        
+        for i in range(len(test_results) - 2):
+            seq = [
+                test_results[i].get("engine", ""),
+                test_results[i+1].get("engine", ""),
+                test_results[i+2].get("engine", ""),
+            ]
+            sequences.append(" → ".join(seq))
+        
+        # Find most common sequences
+        seq_counts = Counter(sequences)
+        
+        return [
+            {"pattern": pattern, "count": count, "confidence": count / len(sequences) * 100}
+            for pattern, count in seq_counts.most_common(10)
+        ]
+    
+    def find_failure_correlations(self, test_results: List[Dict]) -> Dict[str, List[str]]:
+        """Find correlations between test failures"""
+        failures_by_engine = defaultdict(list)
+        
+        for test in test_results:
+            engine = test.get("engine", "unknown")
+            results = test.get("results", {})
+            
+            if results.get("failed", 0) > 0:
+                failures_by_engine[engine].append(test.get("timestamp", ""))
+        
+        # Find correlations
+        correlations = {}
+        engines = list(failures_by_engine.keys())
+        
+        for i, eng1 in enumerate(engines):
+            for eng2 in engines[i+1:]:
+                # Check if failures happen at similar times
+                times1 = set(failures_by_engine[eng1])
+                times2 = set(failures_by_engine[eng2])
+                
+                overlap = times1 & times2
+                if len(overlap) > 0:
+                    correlations[f"{eng1}↔{eng2}"] = list(overlap)
+        
+        return correlations
+    
+    def predict_failures(self, test_results: List[Dict], next_test: Dict) -> float:
+        """Predict likelihood of failure for next test based on patterns"""
+        if not test_results:
+            return 0.0
+        
+        # Simple prediction based on recent failure rate
+        recent = test_results[-10:]  # Last 10 tests
+        failures = sum(1 for t in recent if t.get("results", {}).get("failed", 0) > 0)
+        
+        # Same engine failure rate
+        same_engine = [t for t in recent if t.get("engine") == next_test.get("engine")]
+        if same_engine:
+            engine_failures = sum(1 for t in same_engine if t.get("results", {}).get("failed", 0) > 0)
+            return round(engine_failures / len(same_engine) * 100, 2)
+        
+        return round(failures / len(recent) * 100, 2)
+    
+    def suggest_test_coverage(self, test_results: List[Dict]) -> List[Dict]:
+        """Suggest areas that need more test coverage"""
+        coverage_by_area = defaultdict(lambda: {"tested": 0, "total": 0})
+        
+        for test in test_results:
+            engine = test.get("engine", "unknown")
+            results = test.get("results", {})
+            
+            coverage_by_area[engine]["tested"] += results.get("passed", 0)
+            coverage_by_area[engine]["total"] += results.get("total", 0)
+        
+        suggestions = []
+        for area, data in coverage_by_area.items():
+            coverage = (data["tested"] / data["total"] * 100) if data["total"] > 0 else 0
+            
+            if coverage < 60:
+                suggestions.append({
+                    "area": area,
+                    "current_coverage": round(coverage, 2),
+                    "recommended": "Add more test cases",
+                    "priority": "high" if coverage < 40 else "medium",
+                })
+        
+        return suggestions

nextog/utils/__init__.py

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

nextog/utils/helpers.py

@@ -0,0 +1,91 @@
+"""Helper utilities for nextOG CLI"""
+
+import re
+import hashlib
+from typing import Any, Dict, List
+from pathlib import Path
+from datetime import datetime
+
+
+def validate_url(url: str) -> bool:
+    """Validate URL format"""
+    pattern = re.compile(
+        r'^https?://'
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'
+        r'localhost|'
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
+        r'(?::\d+)?'
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE
+    )
+    return bool(pattern.match(url))
+
+
+def validate_email(email: str) -> bool:
+    """Validate email format"""
+    pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
+    return bool(pattern.match(email))
+
+
+def format_timestamp(dt: datetime = None) -> str:
+    """Format timestamp for display"""
+    if dt is None:
+        dt = datetime.now()
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def generate_id(prefix: str = "test") -> str:
+    """Generate unique test ID"""
+    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+    hash_suffix = hashlib.md5(str(datetime.now().microsecond).encode()).hexdigest()[:6]
+    return f"{prefix}_{timestamp}_{hash_suffix}"
+
+
+def format_bytes(size: int) -> str:
+    """Format bytes to human readable"""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
+def truncate(text: str, max_length: int = 100) -> str:
+    """Truncate text with ellipsis"""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - 3] + "..."
+
+
+def ensure_dir(path: Path) -> Path:
+    """Ensure directory exists"""
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def safe_filename(name: str) -> str:
+    """Convert string to safe filename"""
+    return re.sub(r'[^\w\-_.]', '_', name)
+
+
+def merge_dicts(base: Dict, override: Dict) -> Dict:
+    """Deep merge two dictionaries"""
+    result = dict(base)
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge_dicts(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def parse_duration(duration_str: str) -> float:
+    """Parse duration string to seconds"""
+    units = {"s": 1, "m": 60, "h": 3600, "d": 86400}
+    
+    match = re.match(r'^(\d+(?:\.\d+)?)\s*([smhd]?)$', duration_str.lower())
+    if match:
+        value = float(match.group(1))
+        unit = match.group(2) or "s"
+        return value * units.get(unit, 1)
+    
+    return 0.0

nextog/utils/logger.py

@@ -0,0 +1,37 @@
+"""
+Logging module for nextOG CLI
+"""
+
+import logging
+from pathlib import Path
+from rich.logging import RichHandler
+
+
+def get_logger(name: str = "nextog", verbose: bool = False) -> logging.Logger:
+    """Get configured logger"""
+    logger = logging.getLogger(name)
+    
+    if not logger.handlers:
+        # Console handler with rich formatting
+        console_handler = RichHandler(
+            rich_tracebacks=True,
+            markup=True,
+            show_path=verbose,
+        )
+        console_handler.setLevel(logging.DEBUG if verbose else logging.INFO)
+        
+        # File handler
+        log_dir = Path.home() / ".nextog" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        
+        file_handler = logging.FileHandler(log_dir / "nextog.log")
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(
+            logging.Formatter("%(asctime)s | %(name)s | %(levelname)s | %(message)s")
+        )
+        
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
+        logger.setLevel(logging.DEBUG)
+    
+    return logger

nextog/utils/validators.py

@@ -0,0 +1,98 @@
+"""Input validators for nextOG CLI"""
+
+import re
+from typing import Optional
+from pathlib import Path
+
+
+class ValidationError(Exception):
+    """Custom validation error"""
+    pass
+
+
+def validate_project_name(name: str) -> str:
+    """Validate project name"""
+    if not name:
+        raise ValidationError("Project name cannot be empty")
+    if not re.match(r'^[a-zA-Z][a-zA-Z0-9_-]*$', name):
+        raise ValidationError("Project name must start with letter and contain only alphanumeric, -, _")
+    if len(name) > 64:
+        raise ValidationError("Project name must be 64 characters or less")
+    return name
+
+
+def validate_url(url: str) -> str:
+    """Validate URL"""
+    if not url:
+        raise ValidationError("URL cannot be empty")
+    if not re.match(r'^https?://', url):
+        raise ValidationError("URL must start with http:// or https://")
+    return url
+
+
+def validate_port(port: int) -> int:
+    """Validate port number"""
+    if not isinstance(port, int):
+        raise ValidationError("Port must be an integer")
+    if port < 1 or port > 65535:
+        raise ValidationError("Port must be between 1 and 65535")
+    return port
+
+
+def validate_coverage_target(target: int) -> int:
+    """Validate coverage target"""
+    if target < 0 or target > 100:
+        raise ValidationError("Coverage target must be between 0 and 100")
+    return target
+
+
+def validate_role(role: str) -> str:
+    """Validate user role"""
+    valid_roles = ["admin", "tester", "viewer", "ci"]
+    if role not in valid_roles:
+        raise ValidationError(f"Role must be one of: {valid_roles}")
+    return role
+
+
+def validate_file_exists(path: str) -> Path:
+    """Validate file exists"""
+    p = Path(path)
+    if not p.exists():
+        raise ValidationError(f"File not found: {path}")
+    if not p.is_file():
+        raise ValidationError(f"Not a file: {path}")
+    return p
+
+
+def validate_dir_exists(path: str) -> Path:
+    """Validate directory exists"""
+    p = Path(path)
+    if not p.exists():
+        raise ValidationError(f"Directory not found: {path}")
+    if not p.is_dir():
+        raise ValidationError(f"Not a directory: {path}")
+    return p
+
+
+def validate_browser(browser: str) -> str:
+    """Validate browser name"""
+    valid_browsers = ["chromium", "firefox", "webkit"]
+    if browser not in valid_browsers:
+        raise ValidationError(f"Browser must be one of: {valid_browsers}")
+    return browser
+
+
+def validate_platform(platform: str) -> str:
+    """Validate platform name"""
+    valid_platforms = ["android", "ios"]
+    if platform not in valid_platforms:
+        raise ValidationError(f"Platform must be one of: {valid_platforms}")
+    return platform
+
+
+def validate_protocol(protocol: str) -> str:
+    """Validate protocol"""
+    valid_protocols = ["mqtt", "coap", "http", "serial"]
+    if protocol not in valid_protocols:
+        raise ValidationError(f"Protocol must be one of: {valid_protocols}")
+    return protocol