devloop 0.2.0__py3-none-any.whl

devloop/agents/type_checker.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Type Checker Agent - Runs static type checking on code."""
+
+import logging
+import subprocess  # nosec B404 - Required for running type checking tools
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+
+from ..core.agent import Agent, AgentResult
+from ..core.event import Event
+
+
+@dataclass
+class TypeCheckerConfig:
+    """Configuration for type checking."""
+
+    enabled_tools: List[str] = field(default_factory=lambda: ["mypy"])
+    strict_mode: bool = False
+    show_error_codes: bool = True
+    exclude_patterns: List[str] = field(
+        default_factory=lambda: ["test*", "*_test.py", "*/tests/*"]
+    )
+    max_issues: int = 50
+
+
+class TypeCheckResult:
+    """Type check result."""
+
+    def __init__(
+        self, tool: str, issues: List[Dict[str, Any]], errors: List[str] = None
+    ):
+        self.tool = tool
+        self.issues = issues
+        self.errors = errors or []
+        self.timestamp = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "tool": self.tool,
+            "issues_found": len(self.issues),
+            "issues": self.issues,
+            "errors": self.errors,
+            "severity_breakdown": self._get_severity_breakdown(),
+            "summary": f"Found {len(self.issues)} type issues",
+        }
+
+    def _get_severity_breakdown(self) -> Dict[str, int]:
+        breakdown = {"error": 0, "warning": 0, "note": 0, "unknown": 0}
+        for issue in self.issues:
+            severity = issue.get("severity", "unknown").lower()
+            breakdown[severity] = breakdown.get(severity, 0) + 1
+        return breakdown
+
+
+class TypeCheckerAgent(Agent):
+    """Agent for running type checkers on code."""
+
+    def __init__(self, config: Dict[str, Any], event_bus):
+        super().__init__("type-checker", ["file:modified", "file:created"], event_bus)
+        self.config = TypeCheckerConfig(**config)
+        self.logger = logging.getLogger(f"agent.{self.name}")
+
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle file change events by running type checks."""
+        try:
+            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 check Python files for now
+            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 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 type check
+            results = await self._run_type_check(path)
+
+            agent_result = AgentResult(
+                agent_name=self.name,
+                success=True,
+                duration=0.0,  # Would be calculated in real implementation
+                message=f"Type checked {file_path} with {results.tool}",
+                data={
+                    "file": str(path),
+                    "tool": results.tool,
+                    "issues_found": len(results.issues),
+                    "issues": results.issues,
+                    "severity_breakdown": results._get_severity_breakdown(),
+                    "errors": results.errors,
+                },
+            )
+
+            return agent_result
+        except Exception as e:
+            self.logger.error(
+                f"Error handling type check for {event.payload.get('path', 'unknown')}: {e}",
+                exc_info=True,
+            )
+            return AgentResult(
+                agent_name=self.name,
+                success=False,
+                duration=0.0,
+                message=f"Type check failed: {str(e)}",
+                error=str(e),
+            )
+
+    def _should_exclude_file(self, file_path: str) -> bool:
+        """Check if file should be excluded from type checking."""
+        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_type_check(self, file_path: Path) -> TypeCheckResult:
+        """Run type checking tools."""
+        results = []
+
+        # Try mypy first (most common Python type checker)
+        if "mypy" in self.config.enabled_tools:
+            mypy_result = self._run_mypy(file_path)
+            if mypy_result:
+                results.append(mypy_result)
+
+        # If no results from primary tools, return empty
+        if results:
+            return results[0]  # Return first successful result
+
+        return TypeCheckResult("none", [], ["No type checking tools available"])
+
+    def _run_mypy(self, file_path: Path) -> Optional[TypeCheckResult]:
+        """Run MyPy type checker."""
+        try:
+            # Check if mypy is available
+            result = subprocess.run(
+                [sys.executable, "-c", "import mypy"], capture_output=True, text=True
+            )  # nosec B603 - Running trusted system Python with safe arguments
+            if result.returncode != 0:
+                return TypeCheckResult(
+                    "mypy", [], ["MyPy not installed - run: pip install mypy"]
+                )
+
+            cmd = [
+                sys.executable,
+                "-m",
+                "mypy",
+                str(file_path),
+                "--show-error-codes",
+                "--no-error-summary",
+            ]
+
+            if self.config.strict_mode:
+                cmd.append("--strict")
+
+            # Run mypy in subprocess
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                cwd=file_path.parent,
+            )  # nosec B603 - Running mypy with controlled command arguments
+            issues = []
+
+            # Parse mypy output (line by line)
+            output_lines = result.stdout.strip().split("\n")
+            for line in output_lines:
+                if line.strip() and not line.startswith("Success:"):
+                    # Parse mypy error format: file:line: error: message [error-code]
+                    parts = line.split(":", 3)
+                    if len(parts) >= 4:
+                        filename = parts[0].strip()
+                        try:
+                            line_number = int(parts[1].strip())
+                        except ValueError:
+                            line_number = 0
+
+                        error_type = parts[2].strip()
+                        message_and_code = parts[3].strip()
+
+                        # Extract error code if present
+                        error_code = ""
+                        if "[" in message_and_code and "]" in message_and_code:
+                            message, code_part = message_and_code.rsplit("[", 1)
+                            error_code = code_part.rstrip("]")
+                            message = message.strip()
+                        else:
+                            message = message_and_code
+
+                        issues.append(
+                            {
+                                "filename": filename,
+                                "line_number": line_number,
+                                "severity": error_type,
+                                "message": message,
+                                "error_code": error_code,
+                                "tool": "mypy",
+                            }
+                        )
+
+            return TypeCheckResult("mypy", issues[: self.config.max_issues])
+
+        except Exception as e:
+            return TypeCheckResult("mypy", [], [f"MyPy execution error: {str(e)}"])

devloop/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI interface."""

devloop/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands package."""

devloop/cli/commands/custom_agents.py

@@ -0,0 +1,144 @@
+"""CLI commands for custom agent management."""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devloop.core.custom_agent import (
+    AgentBuilder,
+    CustomAgentStore,
+    get_agent_template,
+)
+
+app = typer.Typer(help="Manage custom agents")
+console = Console()
+
+
+@app.command()
+def list_agents(
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """List all custom agents."""
+
+    async def _run():
+        nonlocal project_dir
+        if project_dir is None:
+            project_dir = Path.cwd()
+
+        storage_path = project_dir / ".devloop" / "custom_agents"
+        store = CustomAgentStore(storage_path)
+
+        agents = await store.get_all_agents()
+
+        if not agents:
+            console.print("[yellow]No custom agents found[/yellow]")
+            return
+
+        table = Table(title="Custom Agents")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name", style="green")
+        table.add_column("Type", style="blue")
+        table.add_column("Status", style="yellow")
+
+        for agent_id, agent in agents.items():
+            table.add_row(agent_id, agent.name, agent.agent_type, "Active")
+
+        console.print(table)
+
+    asyncio.run(_run())
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Agent name"),
+    agent_type: str = typer.Option("detector", help="Agent type"),
+    description: str = typer.Option("", help="Agent description"),
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """Create a new custom agent."""
+
+    async def _run():
+        nonlocal project_dir
+        if project_dir is None:
+            project_dir = Path.cwd()
+
+        # Get template
+        template = get_agent_template(agent_type)
+        if not template:
+            console.print(f"[red]Unknown agent type: {agent_type}[/red]")
+            raise typer.Exit(1)
+
+        # Build custom agent
+        builder = AgentBuilder()
+        agent = builder.build(
+            name=name,
+            agent_type=agent_type,
+            description=description or template.get("description", ""),
+            config=template.get("config", {}),
+        )
+
+        # Store it
+        storage_path = project_dir / ".devloop" / "custom_agents"
+        store = CustomAgentStore(storage_path)
+        await store.save_agent(agent)
+
+        console.print(f"[green]✓[/green] Created custom agent: [cyan]{name}[/cyan]")
+        console.print(f"  ID: {agent.id}")
+        console.print(f"  Type: {agent_type}")
+
+    asyncio.run(_run())
+
+
+@app.command()
+def delete(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """Delete a custom agent."""
+
+    async def _run():
+        nonlocal project_dir
+        if project_dir is None:
+            project_dir = Path.cwd()
+
+        storage_path = project_dir / ".devloop" / "custom_agents"
+        store = CustomAgentStore(storage_path)
+
+        await store.delete_agent(agent_id)
+        console.print(f"[green]✓[/green] Deleted agent: [cyan]{agent_id}[/cyan]")
+
+    asyncio.run(_run())
+
+
+@app.command()
+def templates():
+    """Show available agent templates."""
+    templates = {
+        "detector": {
+            "description": "Pattern detection agent",
+            "triggers": ["file:modified"],
+        },
+        "analyzer": {
+            "description": "Code analysis agent",
+            "triggers": ["file:modified"],
+        },
+        "generator": {
+            "description": "Code generation agent",
+            "triggers": ["command:generate"],
+        },
+    }
+
+    table = Table(title="Available Agent Templates")
+    table.add_column("Type", style="cyan")
+    table.add_column("Description", style="green")
+    table.add_column("Default Triggers", style="yellow")
+
+    for template_type, template_data in templates.items():
+        triggers = ", ".join(template_data["triggers"])
+        table.add_row(template_type, template_data["description"], triggers)
+
+    console.print(table)

devloop/cli/commands/feedback.py

@@ -0,0 +1,161 @@
+"""CLI commands for agent feedback and performance monitoring."""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devloop.core.feedback import FeedbackAPI, FeedbackStore
+from devloop.core.performance import PerformanceMonitor
+
+app = typer.Typer(help="Feedback and performance monitoring")
+console = Console()
+
+
+def get_feedback_api(project_dir: Path = None) -> FeedbackAPI:
+    """Get feedback API instance for the project."""
+    if project_dir is None:
+        project_dir = Path.cwd()
+
+    storage_path = project_dir / ".devloop" / "feedback"
+    feedback_store = FeedbackStore(storage_path)
+    return FeedbackAPI(feedback_store)
+
+
+def get_performance_monitor(project_dir: Path = None) -> PerformanceMonitor:
+    """Get performance monitor instance for the project."""
+    if project_dir is None:
+        project_dir = Path.cwd()
+
+    storage_path = project_dir / ".devloop" / "performance"
+    return PerformanceMonitor(storage_path)
+
+
+@app.command()
+def list_feedback(
+    agent: Optional[str] = typer.Option(None, help="Filter by agent name"),
+    limit: int = typer.Option(20, help="Maximum number of feedback items to show"),
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """List recent feedback for agents."""
+
+    async def _run():
+        feedback_api = get_feedback_api(project_dir)
+
+        if agent:
+            # Get feedback for specific agent
+            feedback_items = await feedback_api.feedback_store.get_feedback_for_agent(
+                agent
+            )
+        else:
+            # Get all feedback
+            feedback_items = await feedback_api.feedback_store.get_all_feedback()
+
+        feedback_items = feedback_items[-limit:]  # Get last N items
+
+        if not feedback_items:
+            console.print("[yellow]No feedback found[/yellow]")
+            return
+
+        table = Table(title="Agent Feedback")
+        table.add_column("Timestamp", style="cyan")
+        table.add_column("Agent", style="green")
+        table.add_column("Type", style="blue")
+        table.add_column("Message", style="yellow")
+
+        for item in feedback_items:
+            table.add_row(
+                item.timestamp.isoformat(),
+                item.agent_name,
+                item.feedback_type,
+                item.message[:50] + "..." if len(item.message) > 50 else item.message,
+            )
+
+        console.print(table)
+
+    asyncio.run(_run())
+
+
+@app.command()
+def submit_feedback(
+    agent: str = typer.Option(..., help="Agent name"),
+    feedback_type: str = typer.Option(
+        "suggestion", help="Feedback type: suggestion|bug|improvement|other"
+    ),
+    message: str = typer.Argument(..., help="Feedback message"),
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """Submit feedback for an agent."""
+
+    async def _run():
+        feedback_api = get_feedback_api(project_dir)
+
+        await feedback_api.submit_feedback(agent, feedback_type, message)
+        console.print(f"[green]✓[/green] Feedback submitted for [cyan]{agent}[/cyan]")
+
+    asyncio.run(_run())
+
+
+@app.command()
+def performance_status(
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """Show agent performance metrics."""
+
+    async def _run():
+        monitor = get_performance_monitor(project_dir)
+
+        metrics = await monitor.get_performance_summary()
+
+        table = Table(title="Agent Performance Metrics")
+        table.add_column("Agent", style="cyan")
+        table.add_column("Success Rate", style="green")
+        table.add_column("Avg Duration (ms)", style="blue")
+        table.add_column("Total Runs", style="yellow")
+
+        for agent_name, data in metrics.items():
+            success_rate = (
+                f"{data.get('success_rate', 0):.1%}"
+                if data.get("success_rate") is not None
+                else "N/A"
+            )
+            avg_duration = (
+                f"{data.get('avg_duration', 0):.2f}"
+                if data.get("avg_duration") is not None
+                else "N/A"
+            )
+            total_runs = data.get("total_runs", 0)
+
+            table.add_row(agent_name, success_rate, avg_duration, str(total_runs))
+
+        console.print(table)
+
+    asyncio.run(_run())
+
+
+@app.command()
+def performance_detail(
+    agent: str = typer.Option(..., help="Agent name"),
+    project_dir: Optional[Path] = typer.Option(None, help="Project directory"),
+):
+    """Show detailed performance metrics for an agent."""
+
+    async def _run():
+        monitor = get_performance_monitor(project_dir)
+
+        metrics = await monitor.get_agent_metrics(agent)
+
+        if not metrics:
+            console.print(f"[yellow]No metrics found for agent: {agent}[/yellow]")
+            return
+
+        console.print(f"\n[bold]Performance Metrics for {agent}[/bold]")
+        console.print(f"  Success Rate: {metrics.get('success_rate', 0):.1%}")
+        console.print(f"  Average Duration: {metrics.get('avg_duration', 0):.2f}ms")
+        console.print(f"  Total Runs: {metrics.get('total_runs', 0)}")
+        console.print(f"  Last Run: {metrics.get('last_run', 'Never')}")
+
+    asyncio.run(_run())

devloop/cli/commands/summary.py

@@ -0,0 +1,50 @@
+"""Agent summary CLI command."""
+
+import asyncio
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from devloop.core.context_store import context_store
+from devloop.core.summary_generator import SummaryGenerator
+from devloop.core.summary_formatter import SummaryFormatter
+
+app = typer.Typer()
+console = Console()
+
+
+# Summary formatting is now handled by SummaryFormatter
+
+
+@app.command()
+def agent_summary(
+    scope: str = typer.Argument(
+        "recent", help="Summary scope: recent|today|session|all"
+    ),
+    agent: Optional[str] = typer.Option(None, "--agent", help="Filter by agent name"),
+    severity: Optional[str] = typer.Option(
+        None, "--severity", help="Filter by severity"
+    ),
+    category: Optional[str] = typer.Option(
+        None, "--category", help="Filter by category"
+    ),
+):
+    """Generate intelligent summary of dev-agent findings."""
+    filters = {}
+    if agent and agent is not None:
+        filters["agent"] = str(agent)
+    if severity and severity is not None:
+        filters["severity"] = str(severity)
+    if category and category is not None:
+        filters["category"] = str(category)
+
+    generator = SummaryGenerator(context_store)
+
+    try:
+        report = asyncio.run(generator.generate_summary(scope, filters))
+        markdown_output = SummaryFormatter.format_markdown(report)
+        console.print(markdown_output)
+    except Exception as e:
+        console.print(f"[red]Error generating summary: {e}[/red]")
+        raise typer.Exit(1)