devloop 0.2.0__py3-none-any.whl

devloop/core/auto_fix.py

@@ -0,0 +1,224 @@
+"""Automatic fix application based on agent findings."""
+
+import logging
+from pathlib import Path
+from typing import Dict
+
+from devloop.core.config import AutonomousFixesConfig, config
+from devloop.core.context_store import Finding, context_store
+
+logger = logging.getLogger(__name__)
+
+
+class AutoFix:
+    """Automatically applies safe fixes based on agent findings."""
+
+    def __init__(self):
+        self._fix_history = set()  # Track applied fixes to avoid duplicates
+
+    async def apply_safe_fixes(self) -> Dict[str, int]:
+        """Apply all safe fixes from agent findings.
+
+        Returns:
+            Dict mapping agent types to number of fixes applied
+        """
+        # Check if autonomous fixes are enabled
+        global_config = config.get_global_config()
+        if (
+            not global_config.autonomous_fixes
+            or not global_config.autonomous_fixes.enabled
+        ):
+            logger.info("Autonomous fixes are disabled in configuration")
+            return {}
+
+        findings = await context_store.get_findings()
+        actionable_findings = [f for f in findings if f.auto_fixable]
+        applied_fixes: Dict[str, int] = {}
+
+        for finding in actionable_findings:
+            agent_type = finding.agent
+            if await self._apply_single_fix(
+                agent_type, finding, global_config.autonomous_fixes
+            ):
+                applied_fixes[agent_type] = applied_fixes.get(agent_type, 0) + 1
+                await context_store.clear_findings(file_filter=finding.file)
+
+        return applied_fixes
+
+    async def _apply_single_fix(
+        self,
+        agent_type: str,
+        finding: Finding,
+        autonomous_fixes_config: AutonomousFixesConfig,
+    ) -> bool:
+        """Apply a single fix if it's safe to do so."""
+        if finding.id in self._fix_history:
+            return False  # Already applied
+
+        # Check if fix is safe based on safety level
+        if not self._is_safe_for_config(
+            agent_type, finding, autonomous_fixes_config.safety_level
+        ):
+            logger.info(
+                f"Skipping {agent_type} fix (not safe for current safety level): {finding.message}"
+            )
+            return False
+
+        # Apply the fix
+        success = await self._execute_fix(agent_type, finding)
+        if success:
+            self._fix_history.add(finding.id)
+            logger.info(f"Applied {agent_type} fix: {finding.message}")
+
+        return success
+
+    def _is_safe_for_config(
+        self, agent_type: str, finding: Finding, safety_level: str
+    ) -> bool:
+        """Check if a finding is safe to apply based on the configured safety level."""
+        message = finding.message.lower()
+
+        # Always reject errors/failures
+        if any(
+            keyword in message for keyword in ["error", "failed", "timeout", "conflict"]
+        ):
+            return False
+
+        if safety_level == "safe_only":
+            return self._is_safe_only_fix(agent_type, finding)
+        elif safety_level == "medium_risk":
+            return self._is_medium_risk_fix(agent_type, finding)
+        elif safety_level == "all":
+            return True  # Apply all fixes
+        else:
+            return False  # Unknown safety level, be safe
+
+    def _is_safe_only_fix(self, agent_type: str, finding: Finding) -> bool:
+        """Check if a finding is safe-only level."""
+        message = finding.message.lower()
+
+        if agent_type == "formatter":
+            # Only basic formatting issues
+            return "would format" in message or "needs formatting" in message
+
+        elif agent_type == "linter":
+            # Only very safe linting fixes
+            safe_patterns = [
+                "whitespace",
+                "indentation",
+                "trailing whitespace",
+                "blank line",
+            ]
+            return any(pattern in message for pattern in safe_patterns)
+
+        return False
+
+    def _is_medium_risk_fix(self, agent_type: str, finding: Finding) -> bool:
+        """Check if a finding is medium-risk level."""
+        message = finding.message.lower()
+
+        if agent_type == "formatter":
+            # All formatting fixes
+            return "would format" in message or "needs formatting" in message
+
+        elif agent_type == "linter":
+            # More linting fixes including imports
+            safe_patterns = [
+                "unused import",
+                "import sort",
+                "whitespace",
+                "indentation",
+                "trailing whitespace",
+                "blank line",
+            ]
+            return any(pattern in message for pattern in safe_patterns)
+
+        return False
+
+    async def _execute_fix(self, agent_type: str, finding: Finding) -> bool:
+        """Execute the actual fix."""
+        try:
+            if agent_type == "formatter":
+                return await self._execute_formatter_fix(finding)
+            elif agent_type == "linter":
+                return await self._execute_linter_fix(finding)
+            else:
+                return False
+        except Exception as e:
+            logger.error(f"Error applying {agent_type} fix: {e}")
+            return False
+
+    async def _execute_formatter_fix(self, finding: Finding) -> bool:
+        """Execute a formatter fix."""
+        file_path = finding.file
+        if not file_path:
+            return False
+
+        path = Path(file_path)
+        formatter = finding.context.get("formatter", "black")
+
+        # Import the formatter agent logic
+        from devloop.agents.formatter import FormatterAgent
+
+        # Create a temporary formatter instance to run the fix
+        agent = FormatterAgent(
+            name="auto-formatter",
+            triggers=[],
+            event_bus=None,
+            config={
+                "formatOnSave": True,
+                "reportOnly": False,
+                "filePatterns": ["**/*"],
+                "formatters": {path.suffix.lstrip("."): formatter},
+            },
+        )
+
+        # Run the formatter directly
+        success, error = await agent._run_formatter(formatter, path)
+        return success
+
+    async def _execute_linter_fix(self, finding: Finding) -> bool:
+        """Execute a linter fix."""
+        # For now, we'll implement basic auto-fixes
+        # In a full implementation, this would use ruff --fix or similar
+        file_path = finding.file
+        if not file_path:
+            return False
+
+        message = finding.message.lower()
+
+        # Handle specific fix types
+        if "unused import" in message:
+            return await self._fix_unused_import(file_path, finding.context)
+        elif "import sort" in message:
+            return await self._fix_import_sort(file_path)
+        elif "whitespace" in message or "indentation" in message:
+            return await self._fix_whitespace(file_path, finding.context)
+
+        return False
+
+    async def _fix_unused_import(self, file_path: str, context: Dict) -> bool:
+        """Fix unused import."""
+        # This would need more sophisticated parsing
+        # For now, return False to be safe
+        return False
+
+    async def _fix_import_sort(self, file_path: str) -> bool:
+        """Fix import sorting."""
+        # Could use isort or similar
+        return False
+
+    async def _fix_whitespace(self, file_path: str, context: Dict) -> bool:
+        """Fix whitespace issues."""
+        # Could use autopep8 or similar
+        return False
+
+
+# Global instance
+auto_fix = AutoFix()
+
+
+async def apply_safe_fixes():
+    """Convenience function to apply safe fixes."""
+    results = await auto_fix.apply_safe_fixes()
+    return results

devloop/core/config.py

@@ -0,0 +1,272 @@
+"""Configuration management for devloop."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from dataclasses import dataclass
+
+
+@dataclass
+class AutonomousFixesConfig:
+    """Configuration for autonomous fix application."""
+
+    enabled: bool = False
+    safety_level: str = "safe_only"
+
+    def __post_init__(self):
+        if self.safety_level not in ["safe_only", "medium_risk", "all"]:
+            raise ValueError(f"Invalid safety_level: {self.safety_level}")
+
+
+@dataclass
+class GlobalConfig:
+    """Global configuration."""
+
+    mode: str = "report-only"
+    max_concurrent_agents: int = 5
+    notification_level: str = "summary"
+    context_store_enabled: bool = True
+    context_store_path: str = ".devloop/context"
+    autonomous_fixes: Optional[AutonomousFixesConfig] = None
+
+    def __post_init__(self):
+        if self.mode not in ["report-only", "active"]:
+            raise ValueError(f"Invalid mode: {self.mode}")
+        if self.notification_level not in ["none", "summary", "detailed"]:
+            raise ValueError(f"Invalid notification_level: {self.notification_level}")
+        if self.autonomous_fixes is None:
+            self.autonomous_fixes = AutonomousFixesConfig()
+
+
+class Config:
+    """Main configuration manager."""
+
+    def __init__(self, config_path: str = ".devloop/agents.json"):
+        self.config_path = Path(config_path)
+        self._config: Optional[Dict[str, Any]] = None
+
+    def load(self) -> Dict[str, Any]:
+        """Load configuration from file."""
+        # Always reload for development - remove caching for now
+        if not self.config_path.exists():
+            # Return default config
+            return self._get_default_config()
+        else:
+            try:
+                with open(self.config_path, "r") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError) as e:
+                print(f"Warning: Could not load config from {self.config_path}: {e}")
+                return self._get_default_config()
+
+    def get_global_config(self) -> GlobalConfig:
+        """Get global configuration."""
+        config = self.load()
+        global_config = config.get("global", {})
+
+        autonomous_fixes_config = global_config.get("autonomousFixes", {})
+        autonomous_fixes = AutonomousFixesConfig(
+            enabled=autonomous_fixes_config.get("enabled", False),
+            safety_level=autonomous_fixes_config.get("safetyLevel", "safe_only"),
+        )
+
+        return GlobalConfig(
+            mode=global_config.get("mode", "report-only"),
+            max_concurrent_agents=global_config.get("maxConcurrentAgents", 5),
+            notification_level=global_config.get("notificationLevel", "summary"),
+            context_store_enabled=global_config.get("contextStore", {}).get(
+                "enabled", True
+            ),
+            context_store_path=global_config.get("contextStore", {}).get(
+                "path", ".devloop/context"
+            ),
+            autonomous_fixes=autonomous_fixes,
+        )
+
+    @staticmethod
+    def default_config() -> "Config":
+        """Get default configuration instance."""
+        config = Config()
+        config._config = config._get_default_config()
+        return config
+
+    def save(self, path: Path) -> None:
+        """Save configuration to file."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            json.dump(self._config, f, indent=2)
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration."""
+        return {
+            "version": "1.0.0",
+            "enabled": True,
+            "agents": {
+                "linter": {
+                    "enabled": True,
+                    "triggers": ["file:modified", "file:created"],
+                    "config": {
+                        "autoFix": False,
+                        "reportOnly": True,
+                        "filePatterns": ["**/*.py", "**/*.js", "**/*.ts"],
+                        "linters": {
+                            "python": "ruff",
+                            "javascript": "eslint",
+                            "typescript": "eslint",
+                        },
+                    },
+                },
+                "formatter": {
+                    "enabled": True,
+                    "triggers": ["file:modified"],
+                    "config": {
+                        "formatOnSave": False,
+                        "reportOnly": True,
+                        "filePatterns": ["**/*.py", "**/*.js", "**/*.ts"],
+                        "formatters": {
+                            "python": "black",
+                            "javascript": "prettier",
+                            "typescript": "prettier",
+                        },
+                    },
+                },
+                "test-runner": {
+                    "enabled": True,
+                    "triggers": ["file:modified", "file:created"],
+                    "config": {
+                        "runOnSave": True,
+                        "relatedTestsOnly": True,
+                        "testFrameworks": {
+                            "python": "pytest",
+                            "javascript": "jest",
+                            "typescript": "jest",
+                        },
+                    },
+                },
+                "agent-health-monitor": {
+                    "enabled": True,
+                    "triggers": ["agent:*:completed"],
+                    "config": {"monitorAllAgents": True, "autoFixOnFailure": True},
+                },
+                "type-checker": {
+                    "enabled": True,
+                    "triggers": ["file:modified", "file:created"],
+                    "config": {
+                        "enabled_tools": ["mypy"],
+                        "strict_mode": False,
+                        "show_error_codes": True,
+                        "exclude_patterns": ["test_*", "*_test.py", "*/tests/*"],
+                        "max_issues": 50,
+                    },
+                },
+                "security-scanner": {
+                    "enabled": True,
+                    "triggers": ["file:modified", "file:created"],
+                    "config": {
+                        "enabled_tools": ["bandit"],
+                        "severity_threshold": "medium",
+                        "confidence_threshold": "medium",
+                        "exclude_patterns": ["test_*", "*_test.py", "*/tests/*"],
+                        "max_issues": 50,
+                    },
+                },
+                "git-commit-assistant": {
+                    "enabled": True,
+                    "triggers": ["git:pre-commit", "git:commit"],
+                    "config": {
+                        "conventional_commits": True,
+                        "max_message_length": 72,
+                        "include_breaking_changes": True,
+                        "analyze_file_changes": True,
+                        "auto_generate_scope": True,
+                        "common_types": [
+                            "feat",
+                            "fix",
+                            "docs",
+                            "style",
+                            "refactor",
+                            "test",
+                            "chore",
+                            "perf",
+                            "ci",
+                            "build",
+                        ],
+                    },
+                },
+                "performance-profiler": {
+                    "enabled": True,
+                    "triggers": ["file:modified", "file:created"],
+                    "config": {
+                        "complexity_threshold": 10,
+                        "min_lines_threshold": 50,
+                        "enabled_tools": ["radon"],
+                        "exclude_patterns": [
+                            "test_*",
+                            "*_test.py",
+                            "*/tests/*",
+                            "__init__.py",
+                        ],
+                        "max_issues": 50,
+                    },
+                },
+            },
+            "global": {
+                "mode": "report-only",
+                "maxConcurrentAgents": 5,
+                "notificationLevel": "summary",
+                "resourceLimits": {},
+                "logging": {},
+                "contextStore": {"enabled": True, "path": ".devloop/context"},
+                "autonomousFixes": {"enabled": True, "safetyLevel": "safe_only"},
+            },
+            "eventSystem": {"collectors": {}, "dispatcher": {}, "store": {}},
+        }
+
+
+class ConfigWrapper:
+    """Wrapper around config dictionary to provide object-like access."""
+
+    def __init__(self, config_dict: Dict[str, Any]):
+        self._config = config_dict
+
+    def is_agent_enabled(self, agent_name: str) -> bool:
+        """Check if an agent is enabled."""
+        agents = self._config.get("agents", {})
+        agent_config = agents.get(agent_name, {})
+        return agent_config.get("enabled", False)
+
+    def get_agent_config(self, agent_name: str) -> Optional[Dict[str, Any]]:
+        """Get configuration for a specific agent."""
+        agents = self._config.get("agents", {})
+        return agents.get(agent_name)
+
+    def get_global_config(self) -> GlobalConfig:
+        """Get global configuration."""
+        global_config = self._config.get("global", {})
+        autonomous_fixes_config = global_config.get("autonomousFixes", {})
+        autonomous_fixes = AutonomousFixesConfig(
+            enabled=autonomous_fixes_config.get("enabled", False),
+            safety_level=autonomous_fixes_config.get("safetyLevel", "safe_only"),
+        )
+
+        return GlobalConfig(
+            mode=global_config.get("mode", "report-only"),
+            max_concurrent_agents=global_config.get("maxConcurrentAgents", 5),
+            notification_level=global_config.get("notificationLevel", "summary"),
+            context_store_enabled=global_config.get("contextStore", {}).get(
+                "enabled", True
+            ),
+            context_store_path=global_config.get("contextStore", {}).get(
+                "path", ".devloop/context"
+            ),
+            autonomous_fixes=autonomous_fixes,
+        )
+
+    def agents(self):
+        """Get agents dictionary."""
+        return self._config.get("agents", {})
+
+
+# Global config instance
+config = Config()