devloop 0.3.1__tar.gz → 0.3.3__tar.gz

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

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

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

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

{devloop-0.3.1 → devloop-0.3.3}/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.1 → devloop-0.3.3}/src/devloop/cli/templates/claude_commands/agent-summary.md

@@ -4,7 +4,7 @@ description: Show intelligent summary of recent dev-agent findings
 
 Generate a summary of recent devloop agent findings by running:
 ```bash
-poetry run devloop summary agent-summary recent
+devloop summary agent-summary recent
 ```
 
 The summary should include:

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

@@ -0,0 +1,70 @@
+#!/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 (only in Poetry projects)
+if [ -f "poetry.lock" ]; then
+    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
+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.3/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.3/src/devloop/cli/templates/git_hooks/pre-push

@@ -0,0 +1,114 @@
+#!/bin/bash
+# Pre-push hook: Verify CI passes before pushing to remote
+# Prevents pushing code that fails local checks
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${YELLOW}[CI Check] Running pre-push verification...${NC}"
+
+# Check if gh CLI is available
+if ! command -v gh &> /dev/null; then
+    echo -e "${YELLOW}[CI Check] gh CLI not found, skipping remote CI check${NC}"
+    echo -e "${YELLOW}[CI Check] Install GitHub CLI to enable CI verification: https://cli.github.com${NC}"
+    exit 0
+fi
+
+# Check if jq is available
+if ! command -v jq &> /dev/null; then
+    echo -e "${YELLOW}[CI Check] jq not found, skipping remote CI check${NC}"
+    echo -e "${YELLOW}[CI Check] Install jq to enable CI verification: https://jqlang.github.io/jq/download/${NC}"
+    exit 0
+fi
+
+# Get the branch being pushed
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+echo -e "${YELLOW}[CI Check] Checking CI status for branch: $BRANCH${NC}"
+
+# Check recent CI runs on this branch (get last completed run)
+LAST_RUN=$(gh run list --branch "$BRANCH" --limit 1 --json status,conclusion --jq '.[0]' 2>/dev/null || echo "")
+
+if [ -z "$LAST_RUN" ]; then
+    echo -e "${YELLOW}[CI Check] No previous CI runs found${NC}"
+    exit 0
+fi
+
+STATUS=$(echo "$LAST_RUN" | jq -r '.status' 2>/dev/null || echo "")
+CONCLUSION=$(echo "$LAST_RUN" | jq -r '.conclusion' 2>/dev/null || echo "")
+
+# If run is in progress, wait for completion (up to 2 minutes)
+if [ "$STATUS" != "completed" ]; then
+    echo -e "${YELLOW}[CI Check] Previous CI run in progress, waiting for completion...${NC}"
+
+    WAIT_TIME=0
+    MAX_WAIT=120  # 2 minutes
+    POLL_INTERVAL=5
+
+    while [ $WAIT_TIME -lt $MAX_WAIT ]; do
+        sleep $POLL_INTERVAL
+        WAIT_TIME=$((WAIT_TIME + POLL_INTERVAL))
+
+        LAST_RUN=$(gh run list --branch "$BRANCH" --limit 1 --json status,conclusion --jq '.[0]' 2>/dev/null || echo "")
+        STATUS=$(echo "$LAST_RUN" | jq -r '.status' 2>/dev/null || echo "")
+        CONCLUSION=$(echo "$LAST_RUN" | jq -r '.conclusion' 2>/dev/null || echo "")
+
+        if [ "$STATUS" = "completed" ]; then
+            echo -e "${YELLOW}[CI Check] CI completed with status: $CONCLUSION${NC}"
+            break
+        fi
+
+        echo -e "${YELLOW}[CI Check] Still waiting... ($WAIT_TIME/$MAX_WAIT seconds)${NC}"
+    done
+
+    # If still not completed, inform user
+    if [ "$STATUS" != "completed" ]; then
+        echo -e "${YELLOW}[CI Check] CI still running after 2 minutes${NC}"
+        echo -e "${YELLOW}[CI Check] You can push and monitor at: https://github.com/$(git config --get remote.origin.url | sed 's/.*github.com[:/]\(.*\)\.git/\1/')/actions${NC}"
+        exit 0
+    fi
+fi
+
+# Check conclusion
+if [ "$CONCLUSION" = "failure" ] || [ "$CONCLUSION" = "timed_out" ] || [ "$CONCLUSION" = "cancelled" ]; then
+    echo -e "${RED}[CI Check] ❌ Last CI run failed with status: $CONCLUSION${NC}"
+    echo -e "${RED}[CI Check] View the failed run: gh run list --branch $BRANCH${NC}"
+    echo -e "${RED}[CI Check] Please fix CI issues before pushing${NC}"
+    exit 1
+fi
+
+if [ "$CONCLUSION" = "success" ]; then
+    echo -e "${GREEN}[CI Check] ✅ Latest CI run passed${NC}"
+
+    # After CI passes, extract DevLoop findings and create Beads issues
+    echo -e "${YELLOW}[Findings] Extracting DevLoop findings...${NC}"
+
+    # Find the extract-findings-to-beads script
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    FINDINGS_SCRIPT="$SCRIPT_DIR/../../.agents/hooks/extract-findings-to-beads"
+
+    if [ -x "$FINDINGS_SCRIPT" ]; then
+        # Get current git commit hash to link findings
+        CURRENT_COMMIT=$(git rev-parse HEAD)
+
+        # Extract findings and create Beads issues
+        if "$FINDINGS_SCRIPT"; then
+            echo -e "${GREEN}[Findings] ✅ DevLoop findings processed${NC}"
+        else
+            echo -e "${YELLOW}[Findings] ⚠️  Could not process DevLoop findings (non-blocking)${NC}"
+        fi
+    else
+        echo -e "${YELLOW}[Findings] 📝 Extract-findings script not found (optional)${NC}"
+    fi
+
+    exit 0
+fi
+
+# For any other status, allow push
+echo -e "${YELLOW}[CI Check] Unable to verify CI status (status: $CONCLUSION), allowing push${NC}"
+exit 0

{devloop-0.3.1 → devloop-0.3.3}/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: