devloop 0.2.0__py3-none-any.whl

devloop/cli/main.py

@@ -0,0 +1,430 @@
+"""CLI entry point - v2 with real agents."""
+
+import asyncio
+import logging
+import signal
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.table import Table
+
+from .commands import custom_agents as custom_agents_cmd
+from .commands import feedback as feedback_cmd
+from .commands import summary as summary_cmd
+from devloop.agents import (
+    AgentHealthMonitorAgent,
+    FormatterAgent,
+    GitCommitAssistantAgent,
+    LinterAgent,
+    PerformanceProfilerAgent,
+    SecurityScannerAgent,
+    TestRunnerAgent,
+    TypeCheckerAgent,
+)
+from devloop.collectors import FileSystemCollector
+from devloop.core import (
+    AgentManager,
+    Config,
+    ConfigWrapper,
+    EventBus,
+    context_store,
+    event_store,
+)
+from devloop.core.amp_integration import check_agent_findings, show_agent_status
+
+app = typer.Typer(
+    help="DevLoop - Development workflow automation", add_completion=False
+)
+console = Console()
+
+app.add_typer(summary_cmd.app, name="summary")
+app.add_typer(custom_agents_cmd.app, name="custom")
+app.add_typer(feedback_cmd.app, name="feedback")
+
+
+@app.command()
+def amp_status():
+    """Show current agent status for Amp."""
+    import asyncio
+
+    result = asyncio.run(show_agent_status())
+    console.print_json(data=result)
+
+
+@app.command()
+def amp_findings():
+    """Show agent findings for Amp."""
+    import asyncio
+
+    result = asyncio.run(check_agent_findings())
+    console.print_json(data=result)
+
+
+@app.command()
+def amp_context():
+    """Show context store index for Amp."""
+    from pathlib import Path
+
+    # Try to read the context index
+    context_dir = Path(".devloop/context")
+    index_file = context_dir / "index.json"
+
+    if index_file.exists():
+        try:
+            import json
+
+            with open(index_file) as f:
+                data = json.load(f)
+            console.print_json(data=data)
+        except Exception as e:
+            console.print(f"[red]Error reading context: {e}[/red]")
+    else:
+        console.print(
+            "[yellow]No context index found. Start agents with 'devloop watch .' first.[/yellow]"
+        )
+
+
+def setup_logging(verbose: bool = False):
+    """Setup logging configuration."""
+    level = logging.DEBUG if verbose else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+    )
+
+
+def run_daemon(path: Path, config_path: Path | None, verbose: bool):
+    """Run devloop in daemon/background mode."""
+    import os
+    import sys
+
+    # Fork to background
+    try:
+        pid = os.fork()
+        if pid > 0:
+            # Parent process - exit
+            console.print(
+                f"[green]✓[/green] DevLoop started in background (PID: {pid})"
+            )
+            console.print("[dim]Run 'devloop stop' to stop the daemon[/dim]")
+            sys.exit(0)
+    except OSError as e:
+        console.print(f"[red]✗[/red] Failed to start daemon: {e}")
+        sys.exit(1)
+
+    # Child process continues
+    # Convert path to absolute before changing directory
+    project_dir = path.resolve()
+
+    os.chdir("/")
+    os.setsid()
+    os.umask(0)
+
+    # Redirect stdout/stderr to log file
+    log_file = project_dir / ".devloop" / "devloop.log"
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(log_file, "a") as f:
+        os.dup2(f.fileno(), sys.stdout.fileno())
+        os.dup2(f.fileno(), sys.stderr.fileno())
+
+    # Setup logging for daemon
+    setup_logging(verbose)
+
+    # Write PID file
+    pid_file = project_dir / ".devloop" / "devloop.pid"
+    with open(pid_file, "w") as f:
+        f.write(str(os.getpid()))
+
+    print(f"DevLoop v2 daemon started (PID: {os.getpid()})")
+    print(f"Watching: {project_dir}")
+
+    # Run the async main loop (will run indefinitely)
+    # Ensure config_path is also absolute if specified
+    abs_config_path = (
+        config_path.resolve()
+        if config_path
+        else project_dir / ".devloop" / "agents.json"
+    )
+    try:
+        asyncio.run(watch_async(project_dir, abs_config_path))
+    except Exception as e:
+        import traceback
+
+        print(f"Daemon error: {e}")
+        traceback.print_exc()
+    finally:
+        # Clean up PID file
+        if pid_file.exists():
+            pid_file.unlink()
+
+
+@app.command()
+def watch(
+    path: Path = typer.Argument(Path.cwd(), help="Path to watch for changes"),
+    config_path: Optional[Path] = typer.Option(
+        None, "--config", help="Path to configuration file"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", help="Verbose logging"),
+    foreground: bool = typer.Option(
+        False, "--foreground", help="Run in foreground (blocking mode) for debugging"
+    ),
+):
+    """
+    Watch a directory for file changes and run agents.
+
+    Agents will automatically lint, format, and test your code as you work.
+
+    Runs in background by default for coding agent integration.
+    Use --foreground for debugging/interactive mode.
+    """
+    if foreground:
+        # Run in foreground for debugging
+        setup_logging(verbose)
+        console.print("[bold green]DevLoop v2[/bold green]")
+        console.print(f"Watching: [cyan]{path.absolute()}[/cyan] (foreground mode)\\n")
+    else:
+        # Run in background (default)
+        run_daemon(path, config_path, verbose)
+        return
+
+    # Run the async main loop
+    try:
+        asyncio.run(watch_async(path, config_path))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Shutting down...[/yellow]")
+
+
+async def watch_async(path: Path, config_path: Path | None):
+    """Async watch implementation."""
+    # Load configuration
+    if config_path:
+        # Ensure it's a Path object and convert to string
+        config_manager = Config(str(Path(config_path).resolve()))
+    else:
+        # Default to project .devloop/agents.json
+        config_manager = Config(str((path / ".devloop" / "agents.json").resolve()))
+    config_dict = config_manager.load()
+    config = ConfigWrapper(config_dict)
+
+    # Create event bus
+    event_bus = EventBus()
+
+    # Initialize context store
+    context_store.context_dir = path / ".devloop" / "context"
+    await context_store.initialize()
+
+    # Initialize event store
+    event_store.db_path = path / ".devloop" / "events.db"
+    await event_store.initialize()
+    console.print(f"[dim]Context store: {context_store.context_dir}[/dim]")
+    console.print(f"[dim]Event store: {event_store.db_path}[/dim]")
+
+    # Create agent manager with project directory
+    agent_manager = AgentManager(event_bus, project_dir=path)
+
+    # Create filesystem collector
+    fs_config = {"watch_paths": [str(path)]}
+    fs_collector = FileSystemCollector(event_bus=event_bus, config=fs_config)
+
+    # Create and register agents based on configuration
+    if config.is_agent_enabled("linter"):
+        linter_config = config.get_agent_config("linter") or {}
+        linter = LinterAgent(
+            name="linter",
+            triggers=linter_config.get("triggers", ["file:modified"]),
+            event_bus=event_bus,
+            config=linter_config.get("config", {}),
+        )
+        agent_manager.register(linter)
+
+    if config.is_agent_enabled("formatter"):
+        formatter_config = config.get_agent_config("formatter") or {}
+        formatter = FormatterAgent(
+            name="formatter",
+            triggers=formatter_config.get("triggers", ["file:modified"]),
+            event_bus=event_bus,
+            config=formatter_config.get("config", {}),
+        )
+        agent_manager.register(formatter)
+
+    if config.is_agent_enabled("test-runner"):
+        test_config = config.get_agent_config("test-runner") or {}
+        test_runner = TestRunnerAgent(
+            name="test-runner",
+            triggers=test_config.get("triggers", ["file:modified"]),
+            event_bus=event_bus,
+            config=test_config.get("config", {}),
+        )
+        agent_manager.register(test_runner)
+
+    if config.is_agent_enabled("agent-health-monitor"):
+        monitor_config = config.get_agent_config("agent-health-monitor") or {}
+        health_monitor = AgentHealthMonitorAgent(
+            name="agent-health-monitor",
+            triggers=monitor_config.get("triggers", ["agent:*:completed"]),
+            event_bus=event_bus,
+            config=monitor_config.get("config", {}),
+        )
+        agent_manager.register(health_monitor)
+
+    if config.is_agent_enabled("type-checker"):
+        type_config = config.get_agent_config("type-checker") or {}
+        type_checker = TypeCheckerAgent(
+            config=type_config.get("config", {}), event_bus=event_bus
+        )
+        agent_manager.register(type_checker)
+
+    if config.is_agent_enabled("security-scanner"):
+        security_config = config.get_agent_config("security-scanner") or {}
+        security_scanner = SecurityScannerAgent(
+            config=security_config.get("config", {}), event_bus=event_bus
+        )
+        agent_manager.register(security_scanner)
+
+    if config.is_agent_enabled("git-commit-assistant"):
+        commit_config = config.get_agent_config("git-commit-assistant") or {}
+        commit_assistant = GitCommitAssistantAgent(
+            config=commit_config.get("config", {}), event_bus=event_bus
+        )
+        agent_manager.register(commit_assistant)
+
+    if config.is_agent_enabled("performance-profiler"):
+        perf_config = config.get_agent_config("performance-profiler") or {}
+        performance_profiler = PerformanceProfilerAgent(
+            config=perf_config.get("config", {}), event_bus=event_bus
+        )
+        agent_manager.register(performance_profiler)
+
+    # Start everything
+    await fs_collector.start()
+    await agent_manager.start_all()
+
+    console.print("[green]✓[/green] Started agents:")
+    for agent_name in agent_manager.list_agents():
+        console.print(f"  • [cyan]{agent_name}[/cyan]")
+
+    console.print("\n[dim]Waiting for file changes... (Ctrl+C to stop)[/dim]\n")
+
+    # Wait for shutdown signal
+    shutdown_event = asyncio.Event()
+
+    def signal_handler(sig, frame):
+        shutdown_event.set()
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Keep running until shutdown
+    await shutdown_event.wait()
+
+    # Stop everything
+    await agent_manager.stop_all()
+    await fs_collector.stop()
+
+
+@app.command()
+def init(
+    path: Path = typer.Argument(Path.cwd(), help="Project directory"),
+    skip_config: bool = typer.Option(
+        False, "--skip-config", help="Skip creating configuration file"
+    ),
+):
+    """Initialize devloop in a project."""
+    claude_dir = path / ".devloop"
+
+    if claude_dir.exists():
+        console.print(f"[yellow]Directory already exists: {claude_dir}[/yellow]")
+    else:
+        claude_dir.mkdir(exist_ok=True)
+        console.print(f"[green]✓[/green] Created: {claude_dir}")
+    # Create default configuration
+    if not skip_config:
+        config_file = claude_dir / "agents.json"
+        if config_file.exists():
+            console.print(
+                f"[yellow]Configuration already exists: {config_file}[/yellow]"
+            )
+        else:
+            config = Config.default_config()
+            config.save(config_file)
+            console.print(f"[green]✓[/green] Created: {config_file}")
+
+    console.print("\n[green]✓[/green] Initialized!")
+    console.print("\nNext steps:")
+    console.print(f"  1. Review/edit: [cyan]{claude_dir / 'agents.json'}[/cyan]")
+    console.print(f"  2. Run: [cyan]devloop watch {path}[/cyan]")
+
+
+@app.command()
+def status():
+    """Show configuration and agent status."""
+    # Load configuration
+    config_manager = Config()
+    config_dict = config_manager.load()
+    config = ConfigWrapper(config_dict)
+
+    table = Table(title="Agent Configuration")
+
+    table.add_column("Agent", style="cyan")
+    table.add_column("Enabled", style="green")
+    table.add_column("Triggers", style="yellow")
+
+    for agent_name, agent_config in config.agents().items():
+        enabled = "✓" if agent_config.get("enabled") else "✗"
+        triggers = ", ".join(agent_config.get("triggers", []))
+        table.add_row(agent_name, enabled, triggers)
+
+    console.print(table)
+
+
+@app.command()
+def stop(path: Path = typer.Argument(Path.cwd(), help="Project directory")):
+    """Stop the background devloop daemon."""
+    import os
+    import signal
+
+    pid_file = path / ".devloop" / "devloop.pid"
+
+    if not pid_file.exists():
+        console.print(f"[yellow]No daemon running in {path}[/yellow]")
+        return
+
+    try:
+        with open(pid_file) as f:
+            pid = int(f.read().strip())
+
+        # Check if process is still running
+        os.kill(pid, 0)  # Signal 0 just checks if process exists
+
+        # Send SIGTERM to gracefully stop
+        os.kill(pid, signal.SIGTERM)
+        console.print(f"[green]✓[/green] Stopped devloop daemon (PID: {pid})")
+
+        # Clean up files
+        pid_file.unlink()
+        log_file = path / ".devloop" / "devloop.log"
+        if log_file.exists():
+            console.print(f"[dim]Logs available at: {log_file}[/dim]")
+
+    except (ValueError, OSError) as e:
+        console.print(f"[red]✗[/red] Failed to stop daemon: {e}")
+        if pid_file.exists():
+            pid_file.unlink()
+
+
+@app.command()
+def version():
+    """Show version information."""
+    from devloop import __version__
+
+    console.print(f"DevLoop v{__version__}")
+
+
+if __name__ == "__main__":
+    app()

devloop/cli/main_v1.py

@@ -0,0 +1,144 @@
+"""CLI entry point - prototype version."""
+
+import asyncio
+import logging
+import signal
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.logging import RichHandler
+
+from devloop.agents import EchoAgent, FileLoggerAgent
+from devloop.collectors import FileSystemCollector
+from devloop.core import EventBus
+
+app = typer.Typer(
+    help="Claude Agents - Development workflow automation (PROTOTYPE)",
+    add_completion=False,
+)
+console = Console()
+
+
+def setup_logging(verbose: bool = False):
+    """Setup logging configuration."""
+    level = logging.DEBUG if verbose else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+    )
+
+
+@app.command()
+def watch(
+    path: Path = typer.Argument(Path.cwd(), help="Path to watch for changes"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose logging"),
+):
+    """
+    Watch a directory for file changes and run agents.
+
+    This is a prototype that demonstrates the core architecture:
+    - FileSystem collector watches for file changes
+    - Events are emitted to the EventBus
+    - Agents subscribe to events and process them
+
+    Press Ctrl+C to stop.
+    """
+    setup_logging(verbose)
+
+    console.print("[bold green]Claude Agents Prototype[/bold green]")
+    console.print(f"Watching: [cyan]{path.absolute()}[/cyan]\n")
+
+    # Run the async main loop
+    try:
+        asyncio.run(watch_async(path))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Shutting down...[/yellow]")
+
+
+async def watch_async(path: Path):
+    """Async watch implementation."""
+    # Create event bus
+    event_bus = EventBus()
+
+    # Create filesystem collector
+    fs_collector = FileSystemCollector(event_bus=event_bus, watch_paths=[str(path)])
+
+    # Create agents
+    echo_agent = EchoAgent(
+        name="echo",
+        triggers=["file:*"],  # Listen to all file events
+        event_bus=event_bus,
+    )
+
+    logger_agent = FileLoggerAgent(
+        name="file-logger",
+        triggers=["file:modified", "file:created"],
+        event_bus=event_bus,
+    )
+
+    # Start everything
+    await fs_collector.start()
+    await echo_agent.start()
+    await logger_agent.start()
+
+    console.print("[green]✓[/green] Agents started:")
+    console.print("  • [cyan]echo[/cyan] - logs all file events")
+    console.print(
+        "  • [cyan]file-logger[/cyan] - writes changes to .devloop/file-changes.log"
+    )
+    console.print("\n[dim]Waiting for file changes... (Ctrl+C to stop)[/dim]\n")
+
+    # Wait for shutdown signal
+    shutdown_event = asyncio.Event()
+
+    def signal_handler(sig, frame):
+        shutdown_event.set()
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Keep running until shutdown
+    await shutdown_event.wait()
+
+    # Stop everything
+    await echo_agent.stop()
+    await logger_agent.stop()
+    await fs_collector.stop()
+
+
+@app.command()
+def events(
+    count: int = typer.Option(10, "--count", "-n", help="Number of events to show")
+):
+    """Show recent events (from last watch session)."""
+    console.print("[yellow]Event history not yet implemented in prototype[/yellow]")
+    console.print("Events are logged to .devloop/file-changes.log")
+
+
+@app.command()
+def init(path: Path = typer.Argument(Path.cwd(), help="Project directory")):
+    """Initialize devloop in a project."""
+    claude_dir = path / ".devloop"
+
+    if claude_dir.exists():
+        console.print(f"[yellow]Directory already exists: {claude_dir}[/yellow]")
+        return
+
+    claude_dir.mkdir(exist_ok=True)
+    console.print(f"[green]✓[/green] Created: {claude_dir}")
+    console.print(f"\nRun [cyan]devloop watch {path}[/cyan] to start watching!")
+
+
+@app.command()
+def version():
+    """Show version information."""
+    from devloop import __version__
+
+    console.print(f"Claude Agents v{__version__} (PROTOTYPE)")
+
+
+if __name__ == "__main__":
+    app()

devloop/collectors/__init__.py

@@ -0,0 +1,17 @@
+"""Event collectors."""
+
+from .base import BaseCollector
+from .filesystem import FileSystemCollector
+from .git import GitCollector
+from .manager import CollectorManager
+from .process import ProcessCollector
+from .system import SystemCollector
+
+__all__ = [
+    "BaseCollector",
+    "FileSystemCollector",
+    "GitCollector",
+    "ProcessCollector",
+    "SystemCollector",
+    "CollectorManager",
+]

devloop/collectors/base.py

@@ -0,0 +1,55 @@
+"""Base collector class."""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from devloop.core.event import Event, EventBus, Priority
+
+
+class BaseCollector(ABC):
+    """Base class for all event collectors."""
+
+    def __init__(
+        self, name: str, event_bus: EventBus, config: Optional[Dict[str, Any]] = None
+    ):
+        self.name = name
+        self.event_bus = event_bus
+        self.config = config or {}
+        self.logger = logging.getLogger(f"collector.{name}")
+        self._running = False
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Start the collector."""
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop the collector."""
+        pass
+
+    @property
+    def is_running(self) -> bool:
+        """Check if collector is running."""
+        return self._running
+
+    def _set_running(self, running: bool) -> None:
+        """Set running state."""
+        self._running = running
+
+    async def _emit_event(
+        self,
+        event_type: str,
+        payload: Dict[str, Any],
+        priority: str = "normal",
+        source: Optional[str] = None,
+    ) -> None:
+        """Emit an event to the event bus."""
+        prio = Priority.NORMAL if priority == "normal" else Priority.HIGH
+        event = Event(
+            type=event_type, payload=payload, source=source or self.name, priority=prio
+        )
+        await self.event_bus.emit(event)