devloop 0.2.0__py3-none-any.whl

devloop/agents/linter.py

@@ -0,0 +1,399 @@
+"""Linter agent - runs linters on file changes."""
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from devloop.core.agent import Agent, AgentResult
+from devloop.core.context_store import Finding, Severity
+from devloop.core.event import Event
+
+
+class LinterConfig:
+    """Configuration for LinterAgent."""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.enabled = config.get("enabled", True)
+        self.auto_fix = config.get("autoFix", False)
+        self.file_patterns = config.get("filePatterns", ["**/*.py"])
+        self.linters = config.get(
+            "linters",
+            {"python": "ruff", "javascript": "eslint", "typescript": "eslint"},
+        )
+        self.debounce = config.get("debounce", 500)  # ms
+
+
+class LinterResult:
+    """Result from running a linter."""
+
+    def __init__(
+        self,
+        success: bool,
+        issues: List[Dict[str, Any]] | None = None,
+        error: str | None = None,
+    ):
+        self.success = success
+        self.issues = issues or []
+        self.error = error
+
+    @property
+    def has_issues(self) -> bool:
+        """Check if there are any issues."""
+        return len(self.issues) > 0
+
+    @property
+    def issue_count(self) -> int:
+        """Get number of issues."""
+        return len(self.issues)
+
+
+class LinterAgent(Agent):
+    """Agent that runs linters on file changes."""
+
+    def __init__(
+        self,
+        name: str,
+        triggers: List[str],
+        event_bus,
+        config: Dict[str, Any] | None = None,
+        feedback_api=None,
+        performance_monitor=None,
+    ):
+        super().__init__(
+            name,
+            triggers,
+            event_bus,
+            feedback_api=feedback_api,
+            performance_monitor=performance_monitor,
+        )
+        self.config = LinterConfig(config or {})
+        self._last_run: Dict[str, float] = {}  # path -> timestamp for debouncing
+
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle file change event by running linter."""
+        # Extract file path
+        file_path = event.payload.get("path")
+        if not file_path:
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0,
+                message="No file path in event",
+            )
+
+        path = Path(file_path)
+
+        # Check if file should be linted
+        if not self._should_lint(path):
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0,
+                message=f"Skipped {path.name} (not in patterns)",
+            )
+
+        # Get appropriate linter for file type
+        linter = self._get_linter_for_file(path)
+        if not linter:
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0,
+                message=f"No linter configured for {path.suffix}",
+            )
+
+        # Run linter
+        result = await self._run_linter(linter, path)
+
+        # Auto-fix if configured and issues found
+        if self.config.auto_fix and result.has_issues:
+            fix_result = await self._auto_fix(linter, path)
+            if fix_result.success:
+                # Re-run linter to get updated results
+                result = await self._run_linter(linter, path)
+
+        # Build result message
+        if result.error:
+            message = f"Linter error on {path.name}: {result.error}"
+            success = False
+        elif result.has_issues:
+            message = f"Found {result.issue_count} issue(s) in {path.name}"
+            success = True
+        else:
+            message = f"No issues in {path.name}"
+            success = True
+
+        agent_result = AgentResult(
+            agent_name=self.name,
+            success=success,
+            duration=0,
+            message=message,
+            data={
+                "file": str(path),
+                "linter": linter,
+                "issues": result.issues,
+                "issue_count": result.issue_count,
+            },
+        )
+
+        # Write findings to context store for Claude Code integration
+        await self._write_findings_to_context(path, result, linter)
+
+        return agent_result
+
+    def _should_lint(self, path: Path) -> bool:
+        """Check if file should be linted based on patterns."""
+        # Skip if file doesn't exist
+        if not path.exists():
+            return False
+
+        # Simple pattern matching (could be improved with fnmatch)
+        suffix = path.suffix
+        for pattern in self.config.file_patterns:
+            if pattern.endswith(suffix):
+                return True
+            if "*" in pattern and suffix in pattern:
+                return True
+
+        return False
+
+    def _get_linter_for_file(self, path: Path) -> Optional[str]:
+        """Get the appropriate linter for a file."""
+        suffix = path.suffix.lstrip(".")
+
+        # Map file extensions to language
+        extension_map = {
+            "py": "python",
+            "js": "javascript",
+            "jsx": "javascript",
+            "ts": "typescript",
+            "tsx": "typescript",
+        }
+
+        language = extension_map.get(suffix)
+        if language:
+            return self.config.linters.get(language)
+
+        return None
+
+    async def _run_linter(self, linter: str, path: Path) -> LinterResult:
+        """Run linter on a file."""
+        try:
+            # Build command based on linter
+            if linter == "ruff":
+                result = await self._run_ruff(path)
+            elif linter == "eslint":
+                result = await self._run_eslint(path)
+            else:
+                result = LinterResult(success=False, error=f"Unknown linter: {linter}")
+
+            return result
+
+        except Exception as e:
+            self.logger.error(f"Error running {linter}: {e}")
+            return LinterResult(success=False, error=str(e))
+
+    async def _run_ruff(self, path: Path) -> LinterResult:
+        """Run ruff on a Python file."""
+        try:
+            # Get updated environment with venv bin in PATH
+            import os
+
+            env = os.environ.copy()
+            venv_bin = Path(__file__).parent.parent.parent.parent / ".venv" / "bin"
+            if venv_bin.exists():
+                env["PATH"] = f"{venv_bin}:{env.get('PATH', '')}"
+
+            # Check if ruff is installed
+            check = await asyncio.create_subprocess_exec(
+                "ruff",
+                "--version",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env,
+            )
+            await check.communicate()
+
+            if check.returncode != 0:
+                return LinterResult(success=False, error="ruff not installed")
+
+            # Run ruff with JSON output
+            proc = await asyncio.create_subprocess_exec(
+                "ruff",
+                "check",
+                "--output-format",
+                "json",
+                str(path),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env,
+            )
+
+            stdout, stderr = await proc.communicate()
+
+            # ruff returns non-zero if issues found, but that's expected
+            if stdout:
+                try:
+                    issues = json.loads(stdout.decode())
+                    return LinterResult(success=True, issues=issues)
+                except json.JSONDecodeError:
+                    # No issues found or invalid JSON
+                    return LinterResult(success=True, issues=[])
+            else:
+                # No output = no issues
+                return LinterResult(success=True, issues=[])
+
+        except FileNotFoundError:
+            return LinterResult(success=False, error="ruff command not found")
+
+    async def _run_eslint(self, path: Path) -> LinterResult:
+        """Run eslint on a JavaScript/TypeScript file."""
+        try:
+            # Check if eslint is installed
+            check = await asyncio.create_subprocess_exec(
+                "eslint",
+                "--version",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            await check.communicate()
+
+            if check.returncode != 0:
+                return LinterResult(success=False, error="eslint not installed")
+
+            # Run eslint with JSON output
+            proc = await asyncio.create_subprocess_exec(
+                "eslint",
+                "--format",
+                "json",
+                str(path),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await proc.communicate()
+
+            if stdout:
+                try:
+                    results = json.loads(stdout.decode())
+                    # ESLint returns array of file results
+                    if results and len(results) > 0:
+                        issues = results[0].get("messages", [])
+                        return LinterResult(success=True, issues=issues)
+                except json.JSONDecodeError:
+                    pass
+
+            return LinterResult(success=True, issues=[])
+
+        except FileNotFoundError:
+            return LinterResult(success=False, error="eslint command not found")
+
+    async def _auto_fix(self, linter: str, path: Path) -> LinterResult:
+        """Attempt to auto-fix issues."""
+        try:
+            # Get updated environment with venv bin in PATH
+            import os
+
+            env = os.environ.copy()
+            venv_bin = Path(__file__).parent.parent.parent.parent / ".venv" / "bin"
+            if venv_bin.exists():
+                env["PATH"] = f"{venv_bin}:{env.get('PATH', '')}"
+
+            if linter == "ruff":
+                proc = await asyncio.create_subprocess_exec(
+                    "ruff",
+                    "check",
+                    "--fix",
+                    str(path),
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    env=env,
+                )
+                await proc.communicate()
+                return LinterResult(success=True)
+
+            elif linter == "eslint":
+                proc = await asyncio.create_subprocess_exec(
+                    "eslint",
+                    "--fix",
+                    str(path),
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    env=env,
+                )
+                await proc.communicate()
+                return LinterResult(success=True)
+
+            return LinterResult(success=False, error="Auto-fix not supported")
+
+        except Exception as e:
+            return LinterResult(success=False, error=str(e))
+
+    async def _write_findings_to_context(
+        self, path: Path, result: LinterResult, linter: str
+    ) -> None:
+        """Write linter findings to context store."""
+        if not result.success or not result.has_issues:
+            return
+
+        from devloop.core.context_store import context_store
+
+        # Convert each linter issue to a Finding
+        for idx, issue in enumerate(result.issues):
+            # Extract issue details (format varies by linter)
+            if linter == "ruff":
+                location = issue.get("location", {})
+                line = location.get("row") if isinstance(location, dict) else None
+                column = location.get("column") if isinstance(location, dict) else None
+                code = issue.get("code", "unknown")
+                message_text = issue.get("message", "")
+                fixable = issue.get("fix", None) is not None
+                # Get severity from code prefix (E, W, F, etc.)
+                severity = "error" if code.startswith(("E", "F")) else "warning"
+            elif linter == "eslint":
+                line = issue.get("line")
+                column = issue.get("column")
+                code = issue.get("ruleId", "unknown")
+                message_text = issue.get("message", "")
+                fixable = issue.get("fix", None) is not None
+                # eslint severity: 1 = warning, 2 = error
+                eslint_severity = issue.get("severity", 1)
+                severity = "error" if eslint_severity == 2 else "warning"
+            else:
+                # Generic format
+                line = None
+                column = None
+                code = "unknown"
+                message_text = str(issue)
+                fixable = False
+                severity = "warning"
+
+            # Create Finding
+            finding = Finding(
+                id=f"{self.name}-{path}-{line}-{code}",
+                agent=self.name,
+                timestamp=str(datetime.now()),
+                file=str(path),
+                line=line,
+                column=column,
+                severity=Severity(severity),
+                message=message_text,
+                category=code,
+                suggestion=(
+                    f"Run {linter} --fix {path}"
+                    if fixable and self.config.auto_fix
+                    else ""
+                ),
+                context={
+                    "linter": linter,
+                    "fixable": fixable,
+                    "auto_fixable": fixable and self.config.auto_fix,
+                },
+            )
+
+            try:
+                await context_store.add_finding(finding)
+            except Exception as e:
+                self.logger.error(f"Failed to write finding to context: {e}")

devloop/agents/performance_profiler.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""Performance Profiler Agent - Analyzes code complexity and performance."""
+
+import asyncio
+import json
+import subprocess  # nosec B404 - Required for running performance analysis tools
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+
+from ..core.agent import Agent, AgentResult
+from ..core.context_store import context_store, Finding
+from ..core.event import Event
+
+
+@dataclass
+class PerformanceConfig:
+    """Configuration for performance profiling."""
+
+    complexity_threshold: int = 10  # McCabe complexity threshold
+    min_lines_threshold: int = 50  # Minimum lines to analyze
+    enabled_tools: Optional[List[str]] = None  # ["radon", "flake8-complexity"]
+    exclude_patterns: Optional[List[str]] = None
+    max_issues: int = 50
+
+    def __post_init__(self):
+        if self.enabled_tools is None:
+            self.enabled_tools = ["radon"]
+        if self.exclude_patterns is None:
+            self.exclude_patterns = ["test*", "*_test.py", "*/tests/*", "__init__.py"]
+
+
+class PerformanceResult:
+    """Performance analysis result."""
+
+    def __init__(
+        self, tool: str, metrics: List[Dict[str, Any]], errors: List[str] = None
+    ):
+        self.tool = tool
+        self.metrics = metrics
+        self.errors = errors or []
+        self.timestamp = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "tool": self.tool,
+            "functions_analyzed": len(self.metrics),
+            "metrics": self.metrics,
+            "errors": self.errors,
+            "complexity_summary": self._get_complexity_summary(),
+            "high_complexity_functions": self._get_high_complexity_functions(),
+        }
+
+    def _get_complexity_summary(self) -> Dict[str, Any]:
+        if not self.metrics:
+            return {
+                "average_complexity": 0,
+                "max_complexity": 0,
+                "high_complexity_count": 0,
+            }
+
+        complexities = [m.get("complexity", 0) for m in self.metrics]
+        high_complexity = [c for c in complexities if c >= 10]
+
+        return {
+            "average_complexity": round(sum(complexities) / len(complexities), 1),
+            "max_complexity": max(complexities),
+            "high_complexity_count": len(high_complexity),
+            "total_functions": len(self.metrics),
+        }
+
+    def _get_high_complexity_functions(self) -> List[Dict[str, Any]]:
+        """Get functions with high complexity."""
+        return [m for m in self.metrics if m.get("complexity", 0) >= 10]
+
+
+class PerformanceProfilerAgent(Agent):
+    """Agent for analyzing code performance and complexity."""
+
+    def __init__(self, config: Dict[str, Any], event_bus):
+        super().__init__(
+            "performance-profiler", ["file:modified", "file:created"], event_bus
+        )
+        self.config = PerformanceConfig(**config)
+
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle file change events by analyzing performance."""
+
+        file_path = event.payload.get("path")
+        if not file_path:
+            return AgentResult(
+                agent_name=self.name,
+                success=False,
+                duration=0.0,
+                message="No file path in event",
+            )
+
+        path = Path(file_path)
+        if not path.exists():
+            return AgentResult(
+                agent_name=self.name,
+                success=False,
+                duration=0.0,
+                message=f"File does not exist: {file_path}",
+            )
+
+        # Only analyze Python files
+        if path.suffix != ".py":
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0.0,
+                message=f"Skipped non-Python file: {file_path}",
+            )
+
+        # Check if file is large enough to analyze
+        if not self._should_analyze_file(path):
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0.0,
+                message=f"File too small to analyze: {file_path}",
+            )
+
+        # Check if file matches exclude patterns
+        if self._should_exclude_file(str(path)):
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0.0,
+                message=f"Excluded file: {file_path}",
+            )
+
+        # Run performance analysis
+        results = await self._run_performance_analysis(path)
+
+        summary = results._get_complexity_summary()
+        high_complexity = results._get_high_complexity_functions()
+
+        agent_result = AgentResult(
+            agent_name=self.name,
+            success=True,
+            duration=0.0,  # Would be calculated in real implementation
+            message=f"Analyzed {path} with {results.tool}",
+            data={
+                "file": str(path),
+                "tool": results.tool,
+                "functions_analyzed": len(results.metrics),
+                "metrics": results.metrics,
+                "complexity_summary": summary,
+                "high_complexity_functions": high_complexity,
+                "errors": results.errors,
+            },
+        )
+
+        # Write to context store for Claude Code integration
+        for func in high_complexity:
+            await context_store.add_finding(
+                Finding(
+                    id=f"{self.name}-{file_path}-{func['name']}",
+                    agent=self.name,
+                    timestamp=str(event.timestamp),
+                    file=str(file_path),
+                    line=func["line_number"],
+                    message=f"High complexity function: {func['name']} (complexity: {func['complexity']})",
+                    context=func,
+                )
+            )
+
+        return agent_result
+
+    def _should_analyze_file(self, file_path: Path) -> bool:
+        """Check if file is large enough to analyze."""
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+                return len(lines) >= self.config.min_lines_threshold
+        except Exception:
+            return False
+
+    def _should_exclude_file(self, file_path: str) -> bool:
+        """Check if file should be excluded from analysis."""
+        if not self.config.exclude_patterns:
+            return False
+        for pattern in self.config.exclude_patterns:
+            if pattern.startswith("*") and pattern.endswith("*"):
+                if pattern[1:-1] in file_path:
+                    return True
+            elif pattern.startswith("*"):
+                if file_path.endswith(pattern[1:]):
+                    return True
+            elif pattern.endswith("*"):
+                if file_path.startswith(pattern[:-1]):
+                    return True
+            elif pattern == file_path:
+                return True
+        return False
+
+    async def _run_performance_analysis(self, file_path: Path) -> PerformanceResult:
+        """Run performance analysis tools."""
+        results = []
+
+        # Try radon first (good for complexity analysis)
+        if self.config.enabled_tools and "radon" in self.config.enabled_tools:
+            radon_result = await self._run_radon(file_path)
+            if radon_result:
+                results.append(radon_result)
+
+        # If no results from primary tools, return empty
+        if results:
+            return results[0]  # Return first successful result
+
+        return PerformanceResult(
+            "none", [], ["No performance analysis tools available"]
+        )
+
+    async def _run_radon(self, file_path: Path) -> Optional[PerformanceResult]:
+        """Run Radon complexity analysis."""
+        try:
+            # Check if radon is available
+            result = subprocess.run(
+                [sys.executable, "-c", "import radon"], capture_output=True, text=True
+            )  # nosec B603 - Running trusted system Python with safe arguments
+            if result.returncode != 0:
+                return PerformanceResult(
+                    "radon", [], ["Radon not installed - run: pip install radon"]
+                )
+
+            # Run radon cc (complexity) command
+            cmd = [
+                sys.executable,
+                "-m",
+                "radon",
+                "cc",
+                "-j",  # JSON output
+                str(file_path),
+            ]
+
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=file_path.parent,
+            )
+
+            stdout, stderr = await process.communicate()
+
+            metrics = []
+
+            if process.returncode == 0:
+                try:
+                    data = json.loads(stdout.decode())
+
+                    # Parse radon output
+                    for file_name, file_data in data.items():
+                        for function_data in file_data:
+                            metrics.append(
+                                {
+                                    "name": function_data.get("name", ""),
+                                    "type": function_data.get("type", ""),
+                                    "complexity": function_data.get("complexity", 0),
+                                    "line_number": function_data.get("lineno", 0),
+                                    "end_line": function_data.get("endline", 0),
+                                    "rank": function_data.get("rank", ""),
+                                    "file": file_name,
+                                }
+                            )
+
+                    return PerformanceResult("radon", metrics[: self.config.max_issues])
+
+                except json.JSONDecodeError:
+                    return PerformanceResult(
+                        "radon",
+                        [],
+                        [f"Failed to parse radon output: {stdout.decode()[:200]}"],
+                    )
+
+            else:
+                error_msg = stderr.decode().strip()
+                return PerformanceResult("radon", [], [f"Radon failed: {error_msg}"])
+
+        except Exception as e:
+            return PerformanceResult("radon", [], [f"Radon execution error: {str(e)}"])