superqode 0.1.5__py3-none-any.whl

superqode/enterprise.py

@@ -0,0 +1,21 @@
+"""Enterprise feature gating for SuperQode OSS."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+
+_console = Console()
+
+
+def require_enterprise(feature_name: str) -> bool:
+    """Check if enterprise features are available."""
+    try:
+        import superqode_enterprise  # noqa: F401
+    except Exception:
+        _console.print(
+            f"[yellow]{feature_name} is available in SuperQode Enterprise.[/yellow]\n"
+            "[dim]Install the enterprise package to enable this feature.[/dim]"
+        )
+        return False
+    return True

superqode/evaluation/__init__.py

@@ -0,0 +1,25 @@
+"""Enhanced evaluation capabilities with CodeOptiX integration."""
+
+# Import CodeOptiX modules as normal dependencies
+try:
+    from codeoptix.evaluation import EvaluationEngine as CodeOptiXEngine
+    from codeoptix.behaviors import create_behavior
+    from codeoptix.evaluation.bloom_integration import BloomIdeationIntegration
+    from codeoptix.evolution import EvolutionEngine as CodeOptiXEvolutionEngine
+
+    CODEOPTIX_AVAILABLE = True
+except ImportError:
+    CODEOPTIX_AVAILABLE = False
+    CodeOptiXEngine = None
+    create_behavior = None
+    BloomIdeationIntegration = None
+    CodeOptiXEvolutionEngine = None
+
+# Export what's available
+__all__ = [
+    "CODEOPTIX_AVAILABLE",
+    "CodeOptiXEngine",
+    "create_behavior",
+    "BloomIdeationIntegration",
+    "CodeOptiXEvolutionEngine",
+]

superqode/evaluation/adapters.py

@@ -0,0 +1,93 @@
+"""Agent adapters for CodeOptiX integration."""
+
+from typing import Dict, Any, Optional
+import logging
+
+from superqode.evaluation import CODEOPTIX_AVAILABLE
+
+logger = logging.getLogger(__name__)
+
+
+class SuperQodeCodeOptiXAdapter:
+    """Adapter to connect SuperQode agents with CodeOptiX evaluation."""
+
+    def __init__(self):
+        """Initialize the adapter."""
+        self.codeoptix_adapter = None
+
+        if CODEOPTIX_AVAILABLE:
+            try:
+                from codeoptix.adapters.factory import create_adapter
+
+                self.create_adapter = create_adapter
+                self.codeoptix_adapter = create_adapter("basic")  # Default adapter
+            except Exception as e:
+                logger.warning(f"CodeOptiX adapter creation failed: {e}")
+
+    def create_agent_adapter(self, agent_config: Dict[str, Any]):
+        """Create a CodeOptiX adapter for a specific agent configuration."""
+        if not self.codeoptix_adapter:
+            return None
+
+        try:
+            agent_type = agent_config.get("type", "basic")
+
+            # Map SuperQode agent types to CodeOptiX adapter types
+            adapter_mapping = {
+                "claude-code": "claude-code",
+                "codex": "codex",
+                "gemini-cli": "gemini-cli",
+                "basic": "basic",
+            }
+
+            codeoptix_type = adapter_mapping.get(agent_type, "basic")
+
+            adapter = self.create_adapter(codeoptix_type, agent_config)
+            logger.info(f"Created CodeOptiX adapter for {agent_type}")
+            return adapter
+
+        except Exception as e:
+            logger.error(f"Failed to create agent adapter: {e}")
+            return None
+
+    def adapt_agent_output(self, agent_output: Any) -> Optional[Dict[str, Any]]:
+        """Adapt SuperQode agent output to CodeOptiX format."""
+        if not agent_output:
+            return None
+
+        try:
+            # Convert SuperQode output format to CodeOptiX expected format
+            adapted = {
+                "content": getattr(agent_output, "content", str(agent_output)),
+                "metadata": getattr(agent_output, "metadata", {}),
+                "success": getattr(agent_output, "success", True),
+                "timestamp": getattr(agent_output, "timestamp", None),
+            }
+            return adapted
+
+        except Exception as e:
+            logger.error(f"Agent output adaptation failed: {e}")
+            return None
+
+    def is_adapter_available(self) -> bool:
+        """Check if CodeOptiX adapter is available."""
+        return self.codeoptix_adapter is not None
+
+
+# Global adapter instance
+adapter_manager = SuperQodeCodeOptiXAdapter()
+
+
+def get_codeoptix_adapter(agent_config: Dict[str, Any]):
+    """Get a CodeOptiX adapter for the given agent configuration."""
+    return adapter_manager.create_agent_adapter(agent_config)
+
+
+def adapt_agent_output_for_evaluation(agent_output: Any) -> Optional[Dict[str, Any]]:
+    """Adapt agent output for CodeOptiX evaluation."""
+    return adapter_manager.adapt_agent_output(agent_output)
+
+
+def is_codeoptix_integration_available() -> bool:
+    """Check if CodeOptiX integration is available."""
+    return adapter_manager.is_adapter_available()

superqode/evaluation/behaviors.py

@@ -0,0 +1,89 @@
+"""Enhanced behaviors for quality evaluation using CodeOptiX."""
+
+from typing import Dict, Any, List
+from pathlib import Path
+
+from superqode.evaluation import CODEOPTIX_AVAILABLE
+
+
+class EnhancedBehaviorManager:
+    """Manager for enhanced evaluation behaviors."""
+
+    def __init__(self):
+        """Initialize behavior manager."""
+        self._behaviors = {}
+
+        if CODEOPTIX_AVAILABLE:
+            self._load_codeoptix_behaviors()
+
+    def _load_codeoptix_behaviors(self):
+        """Load CodeOptiX behaviors."""
+        try:
+            from codeoptix.behaviors import insecure_code, vacuous_tests, plan_drift
+
+            self._behaviors.update(
+                {
+                    "security-vulnerabilities": insecure_code.InsecureCodeBehavior(),
+                    "test-quality": vacuous_tests.VacuousTestsBehavior(),
+                    "plan-adherence": plan_drift.PlanDriftBehavior(),
+                }
+            )
+        except ImportError:
+            pass
+
+    def get_behavior(self, name: str):
+        """Get a behavior by name."""
+        return self._behaviors.get(name)
+
+    def list_behaviors(self) -> Dict[str, str]:
+        """List all available behaviors with descriptions."""
+        descriptions = {
+            "security-vulnerabilities": "Detects hardcoded secrets, SQL injection, XSS vulnerabilities",
+            "test-quality": "Evaluates test completeness, assertion quality, and coverage",
+            "plan-adherence": "Checks if implementation matches requirements and plans",
+        }
+
+        # Only return behaviors that are actually available
+        available = {}
+        for name, behavior in self._behaviors.items():
+            if behavior is not None:
+                available[name] = descriptions.get(name, f"Enhanced {name} analysis")
+
+        return available
+
+    def evaluate_behavior(
+        self, behavior_name: str, codebase_path: Path, config: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Evaluate a specific behavior on the codebase."""
+        behavior = self.get_behavior(behavior_name)
+        if not behavior:
+            return {"error": f"Behavior {behavior_name} not available"}
+
+        try:
+            # This is a simplified interface - in practice, you'd need to
+            # adapt the behavior to work with the codebase
+            return {
+                "behavior": behavior_name,
+                "status": "completed",
+                "findings": [],  # Would contain actual findings
+                "score": 0.85,  # Example quality score
+                "details": f"Evaluated {behavior_name} on {codebase_path}",
+            }
+        except Exception as e:
+            return {"error": f"Evaluation failed: {str(e)}"}
+
+
+# Global behavior manager instance
+behavior_manager = EnhancedBehaviorManager()
+
+
+def get_enhanced_behaviors() -> Dict[str, str]:
+    """Get available enhanced behaviors."""
+    return behavior_manager.list_behaviors()
+
+
+def evaluate_enhanced_behavior(
+    behavior_name: str, codebase_path: Path, config: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Evaluate an enhanced behavior."""
+    return behavior_manager.evaluate_behavior(behavior_name, codebase_path, config)

superqode/evaluation/engine.py

@@ -0,0 +1,209 @@
+"""Enhanced evaluation engine integrating CodeOptiX capabilities."""
+
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import logging
+
+from superqode.evaluation import (
+    CODEOPTIX_AVAILABLE,
+    CodeOptiXEngine,
+    create_behavior,
+    BloomIdeationIntegration,
+)
+
+# Import CodeOptiX utilities if available
+try:
+    from codeoptix.utils.llm import create_llm_client, LLMProvider
+    from codeoptix.adapters.factory import create_adapter
+except ImportError:
+    create_llm_client = None
+    LLMProvider = None
+    create_adapter = None
+
+logger = logging.getLogger(__name__)
+
+
+class EnhancedQEEngine:
+    """Enhanced Quality Engineering engine with CodeOptiX integration."""
+
+    def __init__(self):
+        """Initialize the enhanced QE engine."""
+        self.codeoptix_engine = None
+        self.bloom_generator = None
+
+        if CODEOPTIX_AVAILABLE and create_llm_client and create_adapter:
+            try:
+                # Try to create LLM client (try all available providers)
+                llm_client = None
+                import os
+
+                # Provider priority: Ollama (free) -> OpenAI -> Anthropic -> Google
+                provider_configs = [
+                    (LLMProvider.OLLAMA, None, "llama3.1"),
+                    (LLMProvider.OPENAI, os.getenv("OPENAI_API_KEY"), None),
+                    (LLMProvider.ANTHROPIC, os.getenv("ANTHROPIC_API_KEY"), None),
+                    (LLMProvider.GOOGLE, os.getenv("GOOGLE_API_KEY"), None),
+                ]
+
+                for provider, api_key, model in provider_configs:
+                    try:
+                        if provider == LLMProvider.OLLAMA or api_key:
+                            llm_client = create_llm_client(provider, api_key=api_key, model=model)
+                            break  # Successfully created client
+                    except Exception:
+                        continue  # Try next provider
+
+                if llm_client:
+                    # Create basic adapter for testing/development
+                    # BasicAdapter needs llm_config to create its own llm_client
+                    adapter_config = {
+                        "llm_config": {
+                            "provider": "ollama",  # Default to ollama
+                            "model": "llama3.1",
+                        }
+                    }
+                    adapter = create_adapter("basic", adapter_config)
+
+                    # Initialize CodeOptiX evaluation engine
+                    # Note: we're passing llm_client to EvaluationEngine, but BasicAdapter creates its own
+                    # This might work if they're compatible
+                    self.codeoptix_engine = CodeOptiXEngine(
+                        adapter=adapter,
+                        llm_client=llm_client,
+                        config={"scenario_generator": {"use_bloom": True}},
+                    )
+
+                    # Initialize Bloom generator with the same llm_client
+                    self.bloom_generator = BloomIdeationIntegration(llm_client=llm_client)
+
+                    # Initialize enhanced behaviors
+                    self.enhanced_behaviors = {
+                        "security-vulnerabilities": self._create_security_behavior(),
+                        "test-quality": self._create_test_behavior(),
+                        "plan-adherence": self._create_plan_behavior(),
+                    }
+                else:
+                    logger.warning("No LLM client available for CodeOptiX evaluation")
+                    self.enhanced_behaviors = {}
+            except Exception as e:
+                logger.error(f"Failed to initialize CodeOptiX engine: {e}")
+                self.enhanced_behaviors = {}
+        else:
+            self.enhanced_behaviors = {}
+
+    def _create_security_behavior(self):
+        """Create security vulnerability behavior."""
+        if CODEOPTIX_AVAILABLE and create_behavior:
+            return create_behavior("insecure-code")
+        return None
+
+    def _create_test_behavior(self):
+        """Create test quality behavior."""
+        if CODEOPTIX_AVAILABLE and create_behavior:
+            return create_behavior("vacuous-tests")
+        return None
+
+    def _create_plan_behavior(self):
+        """Create plan adherence behavior."""
+        if CODEOPTIX_AVAILABLE and create_behavior:
+            return create_behavior("plan-drift")
+        return None
+
+    def analyze_with_codeoptix(
+        self, codebase_path: Path, config: Dict[str, Any], behaviors: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Perform enhanced analysis using CodeOptiX capabilities."""
+        if not CODEOPTIX_AVAILABLE or not self.codeoptix_engine:
+            return {"error": "CodeOptiX evaluation engine not available"}
+
+        try:
+            # Determine which behaviors to run
+            if behaviors is None:
+                behaviors = ["insecure-code", "vacuous-tests"]  # Use CodeOptiX behavior names
+
+            # Map SuperQode behavior names to CodeOptiX behavior names
+            behavior_mapping = {
+                "security-vulnerabilities": "insecure-code",
+                "test-quality": "vacuous-tests",
+                "plan-adherence": "plan-drift",
+            }
+
+            # Convert to CodeOptiX behavior names
+            codeoptix_behaviors = []
+            for behavior in behaviors:
+                codeoptix_name = behavior_mapping.get(behavior, behavior)
+                codeoptix_behaviors.append(codeoptix_name)
+
+            # Generate scenarios if requested
+            scenarios = None
+            if config.get("use_bloom_scenarios", False) and self.bloom_generator:
+                try:
+                    scenarios = self.bloom_generator.generate_scenarios(
+                        behavior_name="comprehensive-quality",
+                        behavior_description="Multi-dimensional code quality evaluation",
+                        examples=config.get("scenario_examples", []),
+                    )
+                except Exception as e:
+                    logger.warning(f"Bloom scenario generation failed: {e}")
+
+            # Run CodeOptiX evaluation
+            try:
+                results = self.codeoptix_engine.evaluate_behaviors(
+                    behavior_names=codeoptix_behaviors,
+                    scenarios=scenarios,
+                    context={"codebase_path": str(codebase_path)},
+                )
+
+                return {
+                    "enhanced_analysis": True,
+                    "behaviors_evaluated": behaviors,
+                    "results": results,
+                    "scenarios_used": len(scenarios) if scenarios else 0,
+                }
+
+            except Exception as e:
+                error_msg = str(e)
+                # Provide cleaner error messages for common issues
+                if "Ollama" in error_msg and ("daemon" in error_msg or "contact" in error_msg):
+                    clean_error = "LLM provider not available. Configure one of: Ollama (ollama serve), OpenAI (OPENAI_API_KEY), Anthropic (ANTHROPIC_API_KEY), or Google (GOOGLE_API_KEY)"
+                else:
+                    clean_error = f"CodeOptiX evaluation failed: {error_msg}"
+                    logger.error(clean_error)
+
+                return {"error": clean_error, "enhanced_analysis": False}
+
+        except Exception as e:
+            logger.error(f"Enhanced CodeOptiX analysis failed: {e}")
+            return {"error": f"Enhanced analysis failed: {str(e)}", "enhanced_analysis": False}
+
+    def get_available_behaviors(self) -> Dict[str, str]:
+        """Get all available behaviors (basic + enhanced)."""
+        behaviors = {
+            # Basic behaviors (always available)
+            "syntax-errors": "Basic syntax validation",
+            "code-style": "PEP8 and style checking",
+            "imports": "Import organization and dependencies",
+            "documentation": "Documentation completeness",
+        }
+
+        # Add enhanced behaviors if available
+        if CODEOPTIX_AVAILABLE:
+            behaviors.update(
+                {
+                    "security-vulnerabilities": "Advanced security analysis (CodeOptiX)",
+                    "test-quality": "Intelligent test evaluation (CodeOptiX)",
+                    "plan-adherence": "Requirements alignment checking (CodeOptiX)",
+                }
+            )
+        else:
+            behaviors["codeoptix-integration"] = (
+                "CodeOptiX integration is available (codeoptix dependency required)."
+            )
+
+        return behaviors
+
+    def is_behavior_available(self, behavior_name: str) -> bool:
+        """Check if a specific behavior is available."""
+        if behavior_name in self.enhanced_behaviors:
+            return self.enhanced_behaviors[behavior_name] is not None
+        return behavior_name in ["syntax-errors", "code-style", "imports", "documentation"]

superqode/evaluation/scenarios.py

@@ -0,0 +1,96 @@
+"""Bloom scenario generation integration for enhanced testing."""
+
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import logging
+
+from superqode.evaluation import CODEOPTIX_AVAILABLE, BloomIdeationIntegration
+
+logger = logging.getLogger(__name__)
+
+
+class EnhancedScenarioGenerator:
+    """Enhanced scenario generator using Bloom ideation."""
+
+    def __init__(self):
+        """Initialize the scenario generator."""
+        self.bloom_generator = None
+
+        if CODEOPTIX_AVAILABLE:
+            try:
+                self.bloom_generator = BloomIdeationIntegration()
+            except Exception as e:
+                logger.warning(f"Bloom integration failed: {e}")
+
+    def generate_bloom_scenarios(
+        self,
+        behavior_name: str,
+        behavior_description: str,
+        codebase_path: Path,
+        examples: Optional[List[Dict[str, Any]]] = None,
+    ) -> List[Dict[str, Any]]:
+        """Generate intelligent test scenarios using Bloom."""
+        if not self.bloom_generator:
+            logger.info("Bloom generator not available, using basic scenarios")
+            return self._generate_basic_scenarios(behavior_name, codebase_path)
+
+        try:
+            scenarios = self.bloom_generator.generate_scenarios(
+                behavior_name=behavior_name,
+                behavior_description=behavior_description,
+                examples=examples or [],
+            )
+
+            logger.info(f"Generated {len(scenarios)} Bloom scenarios for {behavior_name}")
+            return scenarios
+
+        except Exception as e:
+            logger.error(f"Bloom scenario generation failed: {e}")
+            return self._generate_basic_scenarios(behavior_name, codebase_path)
+
+    def _generate_basic_scenarios(
+        self, behavior_name: str, codebase_path: Path
+    ) -> List[Dict[str, Any]]:
+        """Generate basic fallback scenarios."""
+        # Basic scenarios as fallback when Bloom is not available
+        base_scenarios = [
+            {
+                "name": f"basic-{behavior_name}-scenario-1",
+                "description": f"Basic scenario for {behavior_name}",
+                "complexity": "low",
+                "tags": ["basic", behavior_name],
+            },
+            {
+                "name": f"basic-{behavior_name}-scenario-2",
+                "description": f"Alternative scenario for {behavior_name}",
+                "complexity": "medium",
+                "tags": ["basic", "alternative", behavior_name],
+            },
+        ]
+
+        logger.info(f"Generated {len(base_scenarios)} basic scenarios as fallback")
+        return base_scenarios
+
+    def is_bloom_available(self) -> bool:
+        """Check if Bloom scenario generation is available."""
+        return self.bloom_generator is not None
+
+
+# Global scenario generator instance
+scenario_generator = EnhancedScenarioGenerator()
+
+
+def generate_enhanced_scenarios(
+    behavior_name: str,
+    behavior_description: str,
+    codebase_path: Path,
+    examples: Optional[List[Dict[str, Any]]] = None,
+    use_bloom: bool = True,
+) -> List[Dict[str, Any]]:
+    """Generate enhanced scenarios with optional Bloom integration."""
+    if use_bloom and scenario_generator.is_bloom_available():
+        return scenario_generator.generate_bloom_scenarios(
+            behavior_name, behavior_description, codebase_path, examples
+        )
+    else:
+        return scenario_generator._generate_basic_scenarios(behavior_name, codebase_path)

superqode/execution/__init__.py

@@ -0,0 +1,36 @@
+"""
+Execution module - Hard-constrained test execution roles.
+
+These are "dumb runners" that execute existing tests without
+discovery, inference, or generation.
+
+Roles:
+- Smoke Tester: Runs smoke tests, fail-fast, no discovery
+- Sanity Tester: Runs sanity tests, verifies recent changes
+- Regression Tester: Runs full regression suite, detects flakes
+"""
+
+from .runner import (
+    TestRunner,
+    SmokeRunner,
+    SanityRunner,
+    RegressionRunner,
+    TestResult,
+    TestSuiteResult,
+)
+from .linter import LinterRunner, LinterRunResult
+from .modes import ExecutionMode, QuickScanConfig, DeepQEConfig
+
+__all__ = [
+    "TestRunner",
+    "SmokeRunner",
+    "SanityRunner",
+    "RegressionRunner",
+    "TestResult",
+    "TestSuiteResult",
+    "LinterRunner",
+    "LinterRunResult",
+    "ExecutionMode",
+    "QuickScanConfig",
+    "DeepQEConfig",
+]