devloop 0.3.1__tar.gz → 0.3.2__tar.gz

{devloop-0.3.1 → devloop-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devloop
-Version: 0.3.1
+Version: 0.3.2
 Summary: Intelligent background agents for development workflow automation
 License: MIT
 License-File: LICENSE

{devloop-0.3.1 → devloop-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "devloop"
-version = "0.3.1"
+version = "0.3.2"
 description = "Intelligent background agents for development workflow automation"
 authors = ["DevLoop Contributors <devloop@example.com>"]
 license = "MIT"

{devloop-0.3.1 → devloop-0.3.2}/src/devloop/cli/main.py

@@ -69,7 +69,7 @@ def amp_context():
     from pathlib import Path
 
     # Try to read the context index
-    context_dir = Path(".devloop/context")
+    context_dir = Path.cwd() / ".devloop/context"
     index_file = context_dir / "index.json"
 
     if index_file.exists():
@@ -289,8 +289,13 @@ async def watch_async(path: Path, config_path: Path | None):
     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)
+    # Get global config for resource limits
+    global_config = config.get_global_config()
+
+    # Create agent manager with project directory and resource limits
+    agent_manager = AgentManager(
+        event_bus, project_dir=path, resource_limits=global_config.resource_limits
+    )
 
     # Create filesystem collector
     fs_config = {"watch_paths": [str(path)]}
@@ -558,10 +563,37 @@ This project uses background agents and Beads for task management.
                 commands_copied.append(template_file.stem)
 
         if commands_copied:
-            console.print(f"\n[green]✓[/green] Created Claude Code slash commands:")
+            console.print("\n[green]✓[/green] Created Claude Code slash commands:")
             for cmd in commands_copied:
                 console.print(f"  • /{cmd}")
 
+    # Install git hooks if this is a git repository
+    git_dir = path / ".git"
+    if git_dir.exists() and git_dir.is_dir():
+        hooks_template_dir = Path(__file__).parent / "templates" / "git_hooks"
+        hooks_dest_dir = git_dir / "hooks"
+
+        if hooks_template_dir.exists():
+            hooks_installed = []
+            for template_file in hooks_template_dir.iterdir():
+                if template_file.is_file():
+                    dest_file = hooks_dest_dir / template_file.name
+
+                    # Backup existing hook if present
+                    if dest_file.exists():
+                        backup_file = hooks_dest_dir / f"{template_file.name}.backup"
+                        shutil.copy2(dest_file, backup_file)
+
+                    # Install new hook
+                    shutil.copy2(template_file, dest_file)
+                    dest_file.chmod(0o755)  # Make executable
+                    hooks_installed.append(template_file.name)
+
+            if hooks_installed:
+                console.print("\n[green]✓[/green] Installed git hooks:")
+                for hook in hooks_installed:
+                    console.print(f"  • {hook}")
+
     console.print("\n[green]✓[/green] Initialized!")
     console.print("\nNext steps:")
     console.print(f"  1. Review/edit: [cyan]{claude_dir / 'agents.json'}[/cyan]")
@@ -633,5 +665,54 @@ def version():
     console.print(f"DevLoop v{__version__}")
 
 
+@app.command()
+def update_hooks(path: Path = typer.Argument(Path.cwd(), help="Project directory")):
+    """Update git hooks from latest templates."""
+    import shutil
+
+    git_dir = path / ".git"
+
+    if not git_dir.exists() or not git_dir.is_dir():
+        console.print(
+            f"[red]✗[/red] Not a git repository: {path}\n"
+            "[yellow]Git hooks can only be installed in git repositories.[/yellow]"
+        )
+        return
+
+    hooks_template_dir = Path(__file__).parent / "templates" / "git_hooks"
+    hooks_dest_dir = git_dir / "hooks"
+
+    if not hooks_template_dir.exists():
+        console.print(f"[red]✗[/red] Hook templates not found at: {hooks_template_dir}")
+        return
+
+    hooks_dest_dir.mkdir(parents=True, exist_ok=True)
+    hooks_updated = []
+
+    for template_file in hooks_template_dir.iterdir():
+        if template_file.is_file():
+            dest_file = hooks_dest_dir / template_file.name
+
+            # Backup existing hook if present
+            if dest_file.exists():
+                backup_file = hooks_dest_dir / f"{template_file.name}.backup"
+                shutil.copy2(dest_file, backup_file)
+                console.print(
+                    f"[dim]  Backed up existing hook: {template_file.name} -> {template_file.name}.backup[/dim]"
+                )
+
+            # Install new hook
+            shutil.copy2(template_file, dest_file)
+            dest_file.chmod(0o755)  # Make executable
+            hooks_updated.append(template_file.name)
+
+    if hooks_updated:
+        console.print("\n[green]✓[/green] Updated git hooks:")
+        for hook in hooks_updated:
+            console.print(f"  • {hook}")
+    else:
+        console.print("[yellow]No hooks found to update[/yellow]")
+
+
 if __name__ == "__main__":
     app()

devloop-0.3.2/src/devloop/cli/templates/git_hooks/pre-commit

@@ -0,0 +1,68 @@
+#!/bin/sh
+#
+# Combined pre-commit hook
+#
+# Checks:
+# 1. Poetry lock file sync with pyproject.toml
+# 2. Code quality checks (Black, Ruff, mypy, pytest)
+# 3. bd (beads) pre-commit flush
+# 4. Any existing pre-commit.old hook
+#
+
+# Check if pyproject.toml changed but poetry.lock didn't
+if git diff --cached --name-only | grep -q "pyproject.toml"; then
+    if ! git diff --cached --name-only | grep -q "poetry.lock"; then
+        echo "ERROR: pyproject.toml changed but poetry.lock not updated"
+        echo "This will cause CI failure: 'poetry.lock was last generated' error"
+        echo ""
+        echo "Fix: Run 'poetry lock' and stage both files"
+        echo "  poetry lock"
+        echo "  git add poetry.lock"
+        exit 1
+    fi
+fi
+
+# Run type checks and tests (only if there are Python changes)
+if git diff --cached --name-only | grep -qE '\.py$'; then
+    if [ -x ".git/hooks/pre-commit-checks" ]; then
+        ".git/hooks/pre-commit-checks"
+        EXIT_CODE=$?
+        if [ $EXIT_CODE -ne 0 ]; then
+            exit $EXIT_CODE
+        fi
+    fi
+fi
+
+# Run existing hook if present
+if [ -x ".git/hooks/pre-commit.old" ]; then
+    ".git/hooks/pre-commit.old" "$@"
+    EXIT_CODE=$?
+    if [ $EXIT_CODE -ne 0 ]; then
+        exit $EXIT_CODE
+    fi
+fi
+
+# Check if bd is available
+if ! command -v bd >/dev/null 2>&1; then
+    echo "Warning: bd command not found, skipping pre-commit flush" >&2
+    exit 0
+fi
+
+# Check if we're in a bd workspace
+if [ ! -d .beads ]; then
+    exit 0
+fi
+
+# Flush pending changes to JSONL
+if ! bd sync --flush-only >/dev/null 2>&1; then
+    echo "Error: Failed to flush bd changes to JSONL" >&2
+    echo "Run 'bd sync --flush-only' manually to diagnose" >&2
+    exit 1
+fi
+
+# If the JSONL file was modified, stage it
+if [ -f .beads/issues.jsonl ]; then
+    git add .beads/issues.jsonl 2>/dev/null || true
+fi
+
+exit 0

devloop-0.3.2/src/devloop/cli/templates/git_hooks/pre-commit-checks

@@ -0,0 +1,72 @@
+#!/bin/bash
+#
+# Pre-commit checks: Formatting, linting, type checking, and tests
+# Prevents committing code that has formatting/linting/type errors or failing tests
+#
+# This is called from the main pre-commit hook after lock file checks
+#
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+echo -e "${YELLOW}[Pre-commit] Running code quality checks and tests...${NC}"
+
+# Check if poetry is available
+if ! command -v poetry &> /dev/null; then
+    echo -e "${YELLOW}[Pre-commit] poetry not found, skipping checks${NC}"
+    exit 0
+fi
+
+# Navigate to src directory where pyproject.toml is located
+if [ ! -d "src" ]; then
+    echo -e "${YELLOW}[Pre-commit] src directory not found, skipping checks${NC}"
+    exit 0
+fi
+
+# Run Black formatter check
+echo -e "${YELLOW}[Pre-commit] Checking code formatting (Black)...${NC}"
+if ! poetry run black --check src/ > /tmp/black-output.txt 2>&1; then
+    echo -e "${RED}[Pre-commit] ❌ Black formatting check failed:${NC}"
+    cat /tmp/black-output.txt
+    echo -e "${YELLOW}Fix with: poetry run black src/${NC}"
+    exit 1
+fi
+echo -e "${GREEN}[Pre-commit] ✅ Code formatting passed${NC}"
+
+# Run Ruff linting
+echo -e "${YELLOW}[Pre-commit] Running linter (Ruff)...${NC}"
+if ! poetry run ruff check src/ > /tmp/ruff-output.txt 2>&1; then
+    echo -e "${RED}[Pre-commit] ❌ Ruff linting failed:${NC}"
+    cat /tmp/ruff-output.txt
+    echo -e "${YELLOW}Fix with: poetry run ruff check src/ --fix${NC}"
+    exit 1
+fi
+echo -e "${GREEN}[Pre-commit] ✅ Linting passed${NC}"
+
+cd src
+
+# Run mypy
+echo -e "${YELLOW}[Pre-commit] Type checking (mypy)...${NC}"
+if ! poetry run mypy devloop/core/ devloop/agents/ > /tmp/mypy-output.txt 2>&1; then
+    echo -e "${RED}[Pre-commit] ❌ Type check failed:${NC}"
+    cat /tmp/mypy-output.txt
+    exit 1
+fi
+echo -e "${GREEN}[Pre-commit] ✅ Type checks passed${NC}"
+
+# Run pytest (from parent directory where tests/ exists)
+echo -e "${YELLOW}[Pre-commit] Running tests (pytest)...${NC}"
+cd ..
+if ! poetry run pytest tests/ -q > /tmp/pytest-output.txt 2>&1; then
+    echo -e "${RED}[Pre-commit] ❌ Tests failed:${NC}"
+    # Show last 50 lines of output
+    tail -50 /tmp/pytest-output.txt
+    exit 1
+fi
+echo -e "${GREEN}[Pre-commit] ✅ All tests passed${NC}"
+
+exit 0

{devloop-0.3.1 → devloop-0.3.2}/src/devloop/core/agent.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional
 
 from .event import Event, EventBus
 from .feedback import FeedbackAPI
-from .performance import PerformanceMonitor
+from .performance import AgentResourceTracker, PerformanceMonitor
 
 
 @dataclass
@@ -79,12 +79,14 @@ class Agent(ABC):
         event_bus: EventBus,
         feedback_api: Optional[FeedbackAPI] = None,
         performance_monitor: Optional[PerformanceMonitor] = None,
+        resource_tracker: Optional[AgentResourceTracker] = None,
     ):
         self.name = name
         self.triggers = triggers
         self.event_bus = event_bus
         self.feedback_api = feedback_api
         self.performance_monitor = performance_monitor
+        self.resource_tracker = resource_tracker
         self.enabled = True
         self.logger = logging.getLogger(f"agent.{name}")
         self._running = False
@@ -139,21 +141,33 @@ class Agent(ABC):
             try:
                 operation_name = f"agent.{self.name}.handle"
 
-                if self.performance_monitor:
-                    async with self.performance_monitor.monitor_operation(
-                        operation_name,
-                        metadata={"event_type": event.type, "agent_name": self.name},
-                    ) as metrics:
+                # Mark agent as active for resource tracking
+                if self.resource_tracker:
+                    self.resource_tracker.mark_agent_active(self.name)
+
+                try:
+                    if self.performance_monitor:
+                        async with self.performance_monitor.monitor_operation(
+                            operation_name,
+                            metadata={
+                                "event_type": event.type,
+                                "agent_name": self.name,
+                            },
+                        ) as metrics:
+                            result = await self.handle(event)
+                            metrics.complete(result.success, result.error)
+
+                            # Update result duration from metrics
+                            if metrics.duration:
+                                result.duration = metrics.duration
+                    else:
+                        start_time = time.time()
                         result = await self.handle(event)
-                        metrics.complete(result.success, result.error)
-
-                        # Update result duration from metrics
-                        if metrics.duration:
-                            result.duration = metrics.duration
-                else:
-                    start_time = time.time()
-                    result = await self.handle(event)
-                    result.duration = time.time() - start_time
+                        result.duration = time.time() - start_time
+                finally:
+                    # Mark agent as inactive after handling
+                    if self.resource_tracker:
+                        self.resource_tracker.mark_agent_inactive(self.name)
 
                 # Update performance store if available
                 if self.feedback_api:

{devloop-0.3.1 → devloop-0.3.2}/src/devloop/core/auto_fix.py

@@ -2,8 +2,9 @@
 
 import logging
 from pathlib import Path
-from typing import Dict
+from typing import Dict, List, Optional
 
+from devloop.core.backup_manager import get_backup_manager
 from devloop.core.config import AutonomousFixesConfig, config
 from devloop.core.context_store import Finding, context_store
 
@@ -11,14 +12,29 @@ 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]:
+    """Automatically applies safe fixes based on agent findings.
+
+    Features:
+    - Pre-modification backups for all changes
+    - Atomic operations with rollback support
+    - Safety level enforcement
+    - Opt-in configuration
+    - Comprehensive audit trail
+    """
+
+    def __init__(self, project_root: Optional[Path] = None):
+        self._fix_history: set[str] = set()  # Track applied fixes to avoid duplicates
+        self._backup_manager = get_backup_manager(project_root or Path.cwd())
+        self._applied_fixes: List[Dict] = []  # Track all applied fixes in session
+
+    async def apply_safe_fixes(
+        self, require_confirmation: bool = True
+    ) -> Dict[str, int]:
         """Apply all safe fixes from agent findings.
 
+        Args:
+            require_confirmation: If True, user must explicitly confirm before applying
+
         Returns:
             Dict mapping agent types to number of fixes applied
         """
@@ -31,8 +47,31 @@ class AutoFix:
             logger.info("Autonomous fixes are disabled in configuration")
             return {}
 
+        # Check for explicit opt-in (CRITICAL SECURITY REQUIREMENT)
+        if not global_config.autonomous_fixes.opt_in:
+            logger.warning(
+                "Autonomous fixes require explicit opt-in. "
+                "Set 'autonomousFixes.opt_in: true' in .devloop/agents.json"
+            )
+            return {}
+
         findings = await context_store.get_findings()
         actionable_findings = [f for f in findings if f.auto_fixable]
+
+        if not actionable_findings:
+            logger.info("No auto-fixable findings to apply")
+            return {}
+
+        # User confirmation if required
+        if require_confirmation:
+            logger.info(
+                f"Found {len(actionable_findings)} auto-fixable findings. "
+                "User confirmation required before applying."
+            )
+            # In a real implementation, this would prompt the user
+            # For now, we return empty to be safe
+            return {}
+
         applied_fixes: Dict[str, int] = {}
 
         for finding in actionable_findings:
@@ -51,7 +90,13 @@ class AutoFix:
         finding: Finding,
         autonomous_fixes_config: AutonomousFixesConfig,
     ) -> bool:
-        """Apply a single fix if it's safe to do so."""
+        """Apply a single fix if it's safe to do so.
+
+        This method:
+        1. Creates a backup before modification
+        2. Applies the fix
+        3. Tracks the change for audit/rollback
+        """
         if finding.id in self._fix_history:
             return False  # Already applied
 
@@ -64,10 +109,40 @@ class AutoFix:
             )
             return False
 
+        # CRITICAL: Create backup before any modification
+        file_path = finding.file
+        if file_path:
+            backup_id = self._backup_manager.create_backup(
+                file_path=Path(file_path),
+                fix_type=agent_type,
+                description=finding.message,
+                metadata={
+                    "finding_id": finding.id,
+                    "severity": finding.severity,
+                    "safety_level": autonomous_fixes_config.safety_level,
+                    "context": finding.context,
+                },
+            )
+
+            if not backup_id:
+                logger.error(f"Failed to create backup for {file_path}, aborting fix")
+                return False
+
+            logger.info(f"Created backup {backup_id} before applying fix")
+
         # Apply the fix
         success = await self._execute_fix(agent_type, finding)
         if success:
             self._fix_history.add(finding.id)
+            self._applied_fixes.append(
+                {
+                    "finding_id": finding.id,
+                    "agent_type": agent_type,
+                    "file": file_path,
+                    "backup_id": backup_id if file_path else None,
+                    "message": finding.message,
+                }
+            )
             logger.info(f"Applied {agent_type} fix: {finding.message}")
 
         return success
@@ -213,12 +288,78 @@ class AutoFix:
         # Could use autopep8 or similar
         return False
 
+    def rollback_last(self) -> bool:
+        """Rollback the last applied fix.
+
+        Returns:
+            True if rollback successful
+        """
+        if not self._applied_fixes:
+            logger.warning("No fixes to rollback in current session")
+            return False
+
+        last_fix = self._applied_fixes[-1]
+        backup_id = last_fix.get("backup_id")
+
+        if not backup_id:
+            logger.error("No backup ID found for last fix")
+            return False
+
+        success = self._backup_manager.rollback(backup_id)
+        if success:
+            self._applied_fixes.pop()
+            logger.info(f"Rolled back fix: {last_fix['message']}")
+
+        return success
+
+    def rollback_all_session(self) -> int:
+        """Rollback all fixes from current session.
+
+        Returns:
+            Number of fixes successfully rolled back
+        """
+        rolled_back = 0
+
+        for fix in reversed(self._applied_fixes):
+            backup_id = fix.get("backup_id")
+            if backup_id and self._backup_manager.rollback(backup_id):
+                rolled_back += 1
+
+        if rolled_back > 0:
+            self._applied_fixes.clear()
+            logger.info(f"Rolled back {rolled_back} fixes from current session")
+
+        return rolled_back
+
+    def get_applied_fixes(self) -> List[Dict]:
+        """Get list of fixes applied in current session."""
+        return self._applied_fixes.copy()
+
+    def get_change_history(self, limit: Optional[int] = None) -> List[Dict]:
+        """Get change history from backup manager."""
+        return self._backup_manager.get_change_history(limit=limit)
+
 
 # Global instance
 auto_fix = AutoFix()
 
 
-async def apply_safe_fixes():
+async def apply_safe_fixes(require_confirmation: bool = True):
     """Convenience function to apply safe fixes."""
-    results = await auto_fix.apply_safe_fixes()
+    results = await auto_fix.apply_safe_fixes(require_confirmation=require_confirmation)
     return results
+
+
+def rollback_last() -> bool:
+    """Convenience function to rollback last fix."""
+    return auto_fix.rollback_last()
+
+
+def rollback_all_session() -> int:
+    """Convenience function to rollback all session fixes."""
+    return auto_fix.rollback_all_session()
+
+
+def get_change_history(limit: Optional[int] = None) -> List[Dict]:
+    """Convenience function to get change history."""
+    return auto_fix.get_change_history(limit=limit)