loop-mcp 0.1.0__py3-none-any.whl

loop_engineering_mcp/loop_manager.py

@@ -0,0 +1,191 @@
+"""Loop management functionality."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+import aiofiles
+
+
+class LoopManager:
+    """Manages loop creation, execution, and configuration."""
+    
+    def __init__(self, loop_dir: Path):
+        """Initialize the loop manager."""
+        self.loop_dir = loop_dir
+        self.loops_file = loop_dir / "loops.json"
+        
+    async def _load_loops(self) -> dict:
+        """Load loops configuration."""
+        if not self.loops_file.exists():
+            return {}
+        async with aiofiles.open(self.loops_file, 'r') as f:
+            content = await f.read()
+            return json.loads(content) if content else {}
+    
+    async def _save_loops(self, loops: dict):
+        """Save loops configuration."""
+        async with aiofiles.open(self.loops_file, 'w') as f:
+            await f.write(json.dumps(loops, indent=2))
+    
+    async def create_loop(
+        self,
+        name: str,
+        description: str,
+        schedule: str,
+        skill_instructions: str,
+        goal: str,
+        verification_command: Optional[str] = None
+    ) -> str:
+        """Create a new loop."""
+        loops = await self._load_loops()
+        
+        if name in loops:
+            return f"❌ Loop '{name}' already exists. Use a different name or delete the existing loop first."
+        
+        loop_config = {
+            "name": name,
+            "description": description,
+            "schedule": schedule,
+            "skill_instructions": skill_instructions,
+            "verification_command": verification_command or "echo 'No verification configured'",
+            "goal": goal,
+            "status": "stopped",
+            "created_at": datetime.now().isoformat(),
+            "last_run": None
+        }
+        
+        loops[name] = loop_config
+        await self._save_loops(loops)
+        
+        return f"""✅ Loop '{name}' created successfully!
+
+**Configuration:**
+- Schedule: {schedule}
+- Goal: {goal}
+- Verification: {verification_command or 'None configured'}
+- Status: Stopped (use start_loop to activate)
+
+**Files created:**
+- Configuration: .loop/loops.json
+- Skill: .loop/skills/{name}.md
+- State: .loop/state/{name}.json
+
+**Next steps:**
+1. Review the skill file at .loop/skills/{name}.md
+2. Start the loop with: start_loop("{name}")
+3. Monitor with: view_state("{name}")"""
+    
+    async def start_loop(self, name: str) -> str:
+        """Start a loop."""
+        loops = await self._load_loops()
+        
+        if name not in loops:
+            return f"❌ Loop '{name}' not found. Create it first with create_loop."
+        
+        loops[name]["status"] = "active"
+        loops[name]["started_at"] = datetime.now().isoformat()
+        await self._save_loops(loops)
+        
+        schedule = loops[name]["schedule"]
+        return f"""✅ Loop '{name}' started!
+
+**Status:** Active
+**Schedule:** {schedule}
+**Next run:** Based on schedule
+
+The loop will now run automatically according to its schedule.
+Monitor progress with: view_state("{name}")"""
+    
+    async def stop_loop(self, name: str) -> str:
+        """Stop a loop."""
+        loops = await self._load_loops()
+        
+        if name not in loops:
+            return f"❌ Loop '{name}' not found."
+        
+        loops[name]["status"] = "stopped"
+        loops[name]["stopped_at"] = datetime.now().isoformat()
+        await self._save_loops(loops)
+        
+        return f"""✅ Loop '{name}' stopped.
+
+**Status:** Stopped
+**Last run:** {loops[name].get('last_run', 'Never')}
+
+The loop is paused but not deleted.
+Restart with: start_loop("{name}")"""
+    
+    async def list_loops(self) -> str:
+        """List all loops with their status."""
+        loops = await self._load_loops()
+        
+        if not loops:
+            return """📊 No loops configured yet.
+
+Create your first loop with create_loop()
+
+**Good first loops:**
+- CI failure triage
+- Dependency updates
+- Lint & format fixes
+- Documentation updates"""
+        
+        output = ["📊 **Loop Status**\n"]
+        
+        active_loops = [l for l in loops.values() if l["status"] == "active"]
+        stopped_loops = [l for l in loops.values() if l["status"] == "stopped"]
+        
+        if active_loops:
+            output.append("**Active Loops:**")
+            for loop in active_loops:
+                output.append(f"\n{loop['name']}")
+                output.append(f"  Description: {loop['description']}")
+                output.append(f"  Schedule: {loop['schedule']}")
+                output.append(f"  Last run: {loop.get('last_run', 'Never')}")
+                output.append(f"  Status: 🟢 Active")
+        
+        if stopped_loops:
+            output.append("\n**Stopped Loops:**")
+            for loop in stopped_loops:
+                output.append(f"\n{loop['name']}")
+                output.append(f"  Description: {loop['description']}")
+                output.append(f"  Status: ⏸️ Stopped")
+        
+        return "\n".join(output)
+    
+    async def delete_loop(self, name: str) -> str:
+        """Delete a loop permanently."""
+        loops = await self._load_loops()
+        
+        if name not in loops:
+            return f"❌ Loop '{name}' not found."
+        
+        del loops[name]
+        await self._save_loops(loops)
+        
+        return f"""✅ Loop '{name}' deleted permanently.
+
+**Cleaned up:**
+- Loop configuration
+- Associated skill file
+- State history
+
+This action cannot be undone."""
+    
+    async def configure_verification(self, loop_name: str, command: str) -> str:
+        """Configure verification command for a loop."""
+        loops = await self._load_loops()
+        
+        if loop_name not in loops:
+            return f"❌ Loop '{loop_name}' not found."
+        
+        loops[loop_name]["verification_command"] = command
+        await self._save_loops(loops)
+        
+        return f"""✅ Verification configured for '{loop_name}'
+
+**Command:** {command}
+
+This command will run before any PR is opened to verify changes.
+If it fails (non-zero exit code), the PR won't be created."""

loop_engineering_mcp/retry.py

@@ -0,0 +1,36 @@
+"""Retry utilities with exponential backoff."""
+
+import asyncio
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+async def retry_async(
+    fn: Callable[[], T],
+    *,
+    max_attempts: int = 3,
+    base_delay: float = 1.0,
+    max_delay: float = 30.0,
+    retryable: Callable[[Exception], bool] | None = None,
+) -> T:
+    """Retry an async callable with exponential backoff."""
+    last_error: Exception | None = None
+
+    for attempt in range(1, max_attempts + 1):
+        try:
+            result = fn()
+            if asyncio.iscoroutine(result):
+                return await result
+            return result
+        except Exception as e:
+            last_error = e
+            if attempt == max_attempts:
+                break
+            if retryable and not retryable(e):
+                raise
+            delay = min(base_delay * (2 ** (attempt - 1)), max_delay)
+            await asyncio.sleep(delay)
+
+    assert last_error is not None
+    raise last_error

loop_engineering_mcp/scheduler.py

@@ -0,0 +1,105 @@
+"""Cron-like scheduler for active loops."""
+
+import asyncio
+from datetime import datetime
+from pathlib import Path
+from typing import Callable, Awaitable, Optional, Any
+
+from croniter import croniter
+
+from .logger import LoopLogger
+from .loop_manager import LoopManager
+
+
+class LoopScheduler:
+    """Background worker that runs active loops on their cron schedule."""
+
+    def __init__(
+        self,
+        loop_manager: LoopManager,
+        logger: LoopLogger,
+        run_callback: Callable[..., Awaitable[str]],
+        poll_interval: int = 60,
+    ):
+        self.loop_manager = loop_manager
+        self.logger = logger
+        self.run_callback = run_callback
+        self.poll_interval = poll_interval
+        self._task: Optional[asyncio.Task] = None
+        self._running = False
+        self._last_run: dict[str, datetime] = {}
+        self._in_progress: set[str] = set()
+
+    def _is_due(self, schedule: str, loop_name: str) -> bool:
+        """Check if a loop is due to run based on its cron schedule."""
+        try:
+            now = datetime.now()
+            cron = croniter(schedule, now)
+            prev_run = cron.get_prev(datetime)
+            last = self._last_run.get(loop_name)
+            if last is None or prev_run > last:
+                return True
+            return False
+        except (ValueError, KeyError) as e:
+            self.logger.warning("invalid_cron", loop_name, schedule=schedule, error=str(e))
+            return False
+
+    async def _tick(self) -> None:
+        """Check all active loops and run any that are due."""
+        loops = await self.loop_manager._load_loops()
+        for name, config in loops.items():
+            if config.get("status") != "active":
+                continue
+            if name in self._in_progress:
+                continue
+            if not self._is_due(config.get("schedule", ""), name):
+                continue
+
+            self._in_progress.add(name)
+            try:
+                self.logger.info("scheduler_triggered", name, schedule=config.get("schedule"))
+                await self.run_callback(name)
+                self._last_run[name] = datetime.now()
+            except Exception as e:
+                self.logger.error("scheduler_run_failed", name, error=str(e))
+            finally:
+                self._in_progress.discard(name)
+
+    async def _loop(self) -> None:
+        """Main scheduler loop."""
+        self._running = True
+        self.logger.info("scheduler_started", poll_interval=self.poll_interval)
+        while self._running:
+            try:
+                await self._tick()
+            except Exception as e:
+                self.logger.error("scheduler_tick_failed", error=str(e))
+            await asyncio.sleep(self.poll_interval)
+
+    def start(self) -> None:
+        """Start the background scheduler."""
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._loop())
+
+    async def stop(self) -> None:
+        """Stop the background scheduler."""
+        self._running = False
+        if self._task and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        self.logger.info("scheduler_stopped")
+
+    async def run_now(self, loop_name: str, **kwargs: Any) -> str:
+        """Manually trigger a loop run immediately."""
+        if loop_name in self._in_progress:
+            return f"⏳ Loop '{loop_name}' is already running."
+        self._in_progress.add(loop_name)
+        try:
+            result = await self.run_callback(loop_name, **kwargs)
+            self._last_run[loop_name] = datetime.now()
+            return result
+        finally:
+            self._in_progress.discard(loop_name)