devloop 0.2.0__py3-none-any.whl

devloop/__init__.py

@@ -0,0 +1,3 @@
+"""DevLoop - Background agents for development workflow automation."""
+
+__version__ = "0.2.0"

devloop/agents/__init__.py

@@ -0,0 +1,33 @@
+"""Built-in agents."""
+
+from .agent_health_monitor import AgentHealthMonitorAgent
+from .ci_monitor import CIMonitorAgent
+from .code_rabbit import CodeRabbitAgent
+from .doc_lifecycle import DocLifecycleAgent
+from .echo import EchoAgent
+from .file_logger import FileLoggerAgent
+from .formatter import FormatterAgent
+from .git_commit_assistant import GitCommitAssistantAgent
+from .linter import LinterAgent
+from .performance_profiler import PerformanceProfilerAgent
+from .security_scanner import SecurityScannerAgent
+from .snyk import SnykAgent
+from .test_runner import TestRunnerAgent
+from .type_checker import TypeCheckerAgent
+
+__all__ = [
+    "AgentHealthMonitorAgent",
+    "CIMonitorAgent",
+    "CodeRabbitAgent",
+    "DocLifecycleAgent",
+    "EchoAgent",
+    "FileLoggerAgent",
+    "FormatterAgent",
+    "GitCommitAssistantAgent",
+    "LinterAgent",
+    "PerformanceProfilerAgent",
+    "SecurityScannerAgent",
+    "SnykAgent",
+    "TestRunnerAgent",
+    "TypeCheckerAgent",
+]

devloop/agents/agent_health_monitor.py

@@ -0,0 +1,105 @@
+"""Agent Health Monitor Agent - monitors other agents and triggers fixes on failures."""
+
+import logging
+from typing import Dict, Any
+
+from devloop.core.agent import Agent, AgentResult
+from devloop.core.auto_fix import auto_fix
+from devloop.core.context_store import context_store, Finding
+from devloop.core.event import Event
+
+
+logger = logging.getLogger(__name__)
+
+
+class AgentHealthMonitorAgent(Agent):
+    """Monitors other agents for failures and triggers autonomous fixes."""
+
+    def __init__(
+        self, name: str, triggers: list[str], event_bus, config: Dict[str, Any]
+    ):
+        super().__init__(name, triggers, event_bus)
+        self.config = config
+
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle agent completion events and trigger fixes on failures."""
+        try:
+            payload = event.payload
+
+            # Extract result information
+            agent_name = payload.get("agent_name", "")
+            success = payload.get("success", True)
+            error = payload.get("error", "")
+            message = payload.get("message", "")
+
+            # Skip if this is our own completion event to avoid loops
+            if agent_name == self.name:
+                return AgentResult(
+                    agent_name=self.name,
+                    success=True,
+                    duration=0.0,
+                    message="Skipped monitoring own completion",
+                )
+
+            # Check if the agent failed
+            if not success or error:
+                logger.info(f"Detected failure in {agent_name}: {error or message}")
+
+                # Apply autonomous fixes
+                applied_fixes = await auto_fix.apply_safe_fixes()
+
+                if applied_fixes:
+                    fix_summary = ", ".join(
+                        f"{k}: {v}" for k, v in applied_fixes.items()
+                    )
+                    agent_result = AgentResult(
+                        agent_name=self.name,
+                        success=True,
+                        duration=0.0,
+                        message=f"Applied fixes for {agent_name} failure: {fix_summary}",
+                        data={"applied_fixes": applied_fixes},
+                    )
+                    await context_store.add_finding(
+                        Finding(
+                            id=f"{self.name}-{agent_name}-failure-fix",
+                            agent=self.name,
+                            timestamp=str(event.timestamp),
+                            file="",
+                            message=agent_result.message,
+                            context=agent_result.data or {},
+                        )
+                    )
+                    return agent_result
+                else:
+                    agent_result = AgentResult(
+                        agent_name=self.name,
+                        success=True,
+                        duration=0.0,
+                        message=f"No safe fixes available for {agent_name} failure",
+                        data={"applied_fixes": {}},
+                    )
+                    await context_store.add_finding(
+                        Finding(
+                            id=f"{self.name}-{agent_name}-no-fix",
+                            agent=self.name,
+                            timestamp=str(event.timestamp),
+                            file="",
+                            message=agent_result.message,
+                            context=agent_result.data or {},
+                        )
+                    )
+                    return agent_result
+
+            # Agent succeeded, nothing to do
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0.0,
+                message=f"{agent_name} completed successfully",
+            )
+
+        except Exception as e:
+            logger.error(f"Error in health monitor: {e}")
+            return AgentResult(
+                agent_name=self.name, success=False, duration=0.0, error=str(e)
+            )

devloop/agents/ci_monitor.py

@@ -0,0 +1,237 @@
+"""CI Monitor Agent - Monitors GitHub Actions CI status."""
+
+import json
+import subprocess
+from datetime import datetime, timedelta
+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 CIMonitorAgent(Agent):
+    """Monitors GitHub Actions CI status and reports failures."""
+
+    def __init__(
+        self,
+        name: str,
+        triggers: List[str],
+        event_bus: Any,
+        check_interval: int = 300,
+    ):  # 5 minutes default
+        """
+        Initialize CI monitor agent.
+
+        Args:
+            name: Agent name
+            triggers: Event triggers for this agent
+            event_bus: Event bus for publishing events
+            check_interval: How often to check CI status (in seconds)
+        """
+        super().__init__(name, triggers, event_bus)
+        self.check_interval = check_interval
+        self.last_check: Optional[datetime] = None
+        self.last_status: Optional[dict] = None
+
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle events and check CI status."""
+        # Check if it's time for periodic check
+        should_check = False
+
+        if event.type == "time:tick":
+            should_check = self._should_check_now()
+        elif event.type == "git:post-push":
+            # Always check after push
+            should_check = True
+
+        if not should_check:
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0,
+                message="Not time to check CI yet",
+            )
+
+        # Check CI status
+        try:
+            status = await self._check_ci_status()
+            self.last_check = datetime.now()
+            self.last_status = status
+
+            if not status:
+                return AgentResult(
+                    agent_name=self.name,
+                    success=True,
+                    duration=0,
+                    message="No CI runs found",
+                )
+
+            # Analyze status and create findings
+            findings = self._analyze_ci_status(status)
+
+            if findings:
+                return AgentResult(
+                    agent_name=self.name,
+                    success=False,
+                    duration=0,
+                    message=f"CI issues detected: {len(findings)} workflows need attention",
+                    data={"findings": findings},
+                )
+            else:
+                return AgentResult(
+                    agent_name=self.name,
+                    success=True,
+                    duration=0,
+                    message="CI status: All checks passing",
+                )
+
+        except Exception as e:
+            return AgentResult(
+                agent_name=self.name,
+                success=False,
+                duration=0,
+                error=f"Failed to check CI status: {e}",
+            )
+
+    def _should_check_now(self) -> bool:
+        """Determine if we should check CI now based on interval."""
+        if self.last_check is None:
+            return True
+
+        time_since_check = datetime.now() - self.last_check
+        return time_since_check > timedelta(seconds=self.check_interval)
+
+    async def _check_ci_status(self) -> Optional[dict]:
+        """
+        Check CI status using gh CLI.
+
+        Returns:
+            CI status dict or None if unavailable
+        """
+        # Check if gh CLI is available
+        try:
+            result = subprocess.run(
+                ["gh", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode != 0:
+                return None
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+        # Check if authenticated
+        try:
+            result = subprocess.run(
+                ["gh", "auth", "status"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode != 0:
+                return None
+        except subprocess.TimeoutExpired:
+            return None
+
+        # Get current branch
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=5,
+            )
+            branch = result.stdout.strip()
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+            return None
+
+        # Get latest workflow runs
+        try:
+            result = subprocess.run(
+                [
+                    "gh",
+                    "run",
+                    "list",
+                    "--branch",
+                    branch,
+                    "--limit",
+                    "5",
+                    "--json",
+                    "status,conclusion,name,databaseId,createdAt,workflowName",
+                ],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=10,
+            )
+
+            if result.stdout.strip():
+                runs = json.loads(result.stdout)
+                return {
+                    "branch": branch,
+                    "runs": runs,
+                    "checked_at": datetime.now().isoformat(),
+                }
+        except (
+            subprocess.CalledProcessError,
+            subprocess.TimeoutExpired,
+            json.JSONDecodeError,
+        ):
+            return None
+
+        return None
+
+    def _analyze_ci_status(self, status: dict) -> list[Finding]:
+        """Analyze CI status and create findings for issues."""
+        findings = []
+        runs = status.get("runs", [])
+        branch = status.get("branch", "unknown")
+
+        # Group runs by workflow
+        workflows: Dict[str, list] = {}
+        for run in runs:
+            workflow_name = run.get("workflowName", run.get("name", "Unknown"))
+            if workflow_name not in workflows:
+                workflows[workflow_name] = []
+            workflows[workflow_name].append(run)
+
+        # Check each workflow's latest run
+        for workflow_name, workflow_runs in workflows.items():
+            latest_run = workflow_runs[0]  # Already sorted by createdAt descending
+            conclusion = latest_run.get("conclusion")
+            status_val = latest_run.get("status")
+            run_id = latest_run.get("databaseId", "unknown")
+
+            if conclusion == "failure":
+                findings.append(
+                    Finding(
+                        id=f"ci-{run_id}",
+                        agent="ci-monitor",
+                        timestamp=datetime.now().isoformat(),
+                        file=".github/workflows/ci.yml",
+                        category="ci",
+                        severity=Severity.ERROR,
+                        message=f"CI workflow '{workflow_name}' failed on branch '{branch}' (Run #{run_id})",
+                        suggestion=f"View details: gh run view {run_id}\nRerun: gh run rerun {run_id}",
+                        auto_fixable=False,
+                    )
+                )
+            elif status_val == "in_progress":
+                findings.append(
+                    Finding(
+                        id=f"ci-{run_id}",
+                        agent="ci-monitor",
+                        timestamp=datetime.now().isoformat(),
+                        file=".github/workflows/ci.yml",
+                        category="ci",
+                        severity=Severity.INFO,
+                        message=f"CI workflow '{workflow_name}' is running on branch '{branch}' (Run #{run_id})",
+                        suggestion=f"Watch progress: gh run watch {run_id}",
+                        auto_fixable=False,
+                    )
+                )
+
+        return findings

devloop/agents/code_rabbit.py

@@ -0,0 +1,248 @@
+"""Code Rabbit agent - integrates Code Rabbit CLI for code analysis."""
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+from devloop.core.agent import Agent, AgentResult
+from devloop.core.context_store import Finding, Severity
+from devloop.core.event import Event
+
+
+class CodeRabbitConfig:
+    """Configuration for CodeRabbitAgent."""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.enabled = config.get("enabled", True)
+        self.api_key = config.get("apiKey")
+        self.min_severity = config.get("minSeverity", "warning")
+        self.file_patterns = config.get(
+            "filePatterns", ["**/*.py", "**/*.js", "**/*.ts"]
+        )
+        self.debounce = config.get("debounce", 500)  # ms
+
+
+class CodeRabbitResult:
+    """Result from running Code Rabbit analysis."""
+
+    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 CodeRabbitAgent(Agent):
+    """Agent that runs Code Rabbit analysis 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 = CodeRabbitConfig(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 Code Rabbit analysis."""
+        # 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 analyzed
+        if not self._should_analyze(path):
+            return AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0,
+                message=f"Skipped {path.name} (not in patterns)",
+            )
+
+        # Run Code Rabbit analysis
+        result = await self._run_code_rabbit(path)
+
+        # Build result message
+        if result.error:
+            message = f"Code Rabbit 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),
+                "tool": "code-rabbit",
+                "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)
+
+        return agent_result
+
+    def _should_analyze(self, path: Path) -> bool:
+        """Check if file should be analyzed based on patterns."""
+        # Skip if file doesn't exist
+        if not path.exists():
+            return False
+
+        # Simple pattern matching
+        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
+
+    async def _run_code_rabbit(self, path: Path) -> CodeRabbitResult:
+        """Run Code Rabbit analysis on a file."""
+        try:
+            # Check if code-rabbit CLI is installed
+            check = await asyncio.create_subprocess_exec(
+                "code-rabbit",
+                "--version",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            await check.communicate()
+
+            if check.returncode != 0:
+                return CodeRabbitResult(
+                    success=False, error="code-rabbit CLI not installed"
+                )
+
+            # Run Code Rabbit with JSON output
+            proc = await asyncio.create_subprocess_exec(
+                "code-rabbit",
+                "analyze",
+                "--format",
+                "json",
+                str(path),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await proc.communicate()
+
+            if proc.returncode != 0 and not stdout:
+                return CodeRabbitResult(
+                    success=False,
+                    error=f"code-rabbit failed: {stderr.decode() if stderr else 'unknown error'}",
+                )
+
+            if stdout:
+                try:
+                    data = json.loads(stdout.decode())
+                    issues = data.get("issues", []) if isinstance(data, dict) else data
+                    return CodeRabbitResult(success=True, issues=issues)
+                except json.JSONDecodeError as e:
+                    return CodeRabbitResult(
+                        success=False, error=f"Failed to parse Code Rabbit output: {e}"
+                    )
+
+            return CodeRabbitResult(success=True, issues=[])
+
+        except FileNotFoundError:
+            return CodeRabbitResult(
+                success=False, error="code-rabbit command not found"
+            )
+        except Exception as e:
+            self.logger.error(f"Error running Code Rabbit: {e}")
+            return CodeRabbitResult(success=False, error=str(e))
+
+    async def _write_findings_to_context(
+        self, path: Path, result: CodeRabbitResult
+    ) -> None:
+        """Write Code Rabbit findings to context store."""
+        if not result.success or not result.has_issues:
+            return
+
+        from devloop.core.context_store import context_store
+
+        # Convert each issue to a Finding
+        for idx, issue in enumerate(result.issues):
+            # Extract issue details
+            line = issue.get("line")
+            column = issue.get("column")
+            code = issue.get("code", "unknown")
+            message_text = issue.get("message", "")
+            severity_str = issue.get("severity", "warning").lower()
+
+            # Map severity values
+            severity_map = {
+                "error": Severity.ERROR,
+                "warning": Severity.WARNING,
+                "info": Severity.INFO,
+                "note": Severity.INFO,
+            }
+            severity = severity_map.get(severity_str, 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,
+                message=message_text,
+                category=code,
+                suggestion=issue.get("suggestion", ""),
+                context={
+                    "tool": "code-rabbit",
+                    "issue_type": issue.get("type", "unknown"),
+                },
+            )
+
+            try:
+                await context_store.add_finding(finding)
+            except Exception as e:
+                self.logger.error(f"Failed to write finding to context: {e}")