loop-mcp 0.1.0__tar.gz

loop_mcp-0.1.0/.gitignore

@@ -0,0 +1,56 @@
+# Secrets (never commit)
+.pypirc
+.npmrc
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+venv/
+env/
+ENV/
+
+# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+dist/
+build/
+*.tsbuildinfo
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Loop state (local only)
+.loop/
+
+# Testing
+.pytest_cache/
+coverage/
+.nyc_output/
+*.log
+
+\IMPLEMENTATION_COMPLETE.md

loop_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: loop-mcp
+Version: 0.1.0
+Summary: MCP server for automated loop engineering in AI coding workflows
+Project-URL: Homepage, https://github.com/yourusername/loop-engineering
+Project-URL: Documentation, https://github.com/yourusername/loop-engineering#readme
+Project-URL: Repository, https://github.com/yourusername/loop-engineering
+Project-URL: Issues, https://github.com/yourusername/loop-engineering/issues
+Author: Loop Engineering Contributors
+License-Expression: MIT
+Keywords: ai,automation,coding,loop-engineering,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: croniter>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=0.9.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Loop Engineering MCP Server (Python)
+
+Python implementation of the Loop Engineering MCP server.
+
+## Installation
+
+### Using uvx (recommended - no installation needed)
+
+```bash
+uvx loop-mcp
+```
+
+### Using pip
+
+```bash
+pip install loop-mcp
+```
+
+## Configuration
+
+Add to your MCP configuration file:
+
+**Cursor** (`.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+**Kiro** (`.kiro/settings/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+**Claude Desktop**:
+- Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+cd python
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

loop_mcp-0.1.0/README.md

@@ -0,0 +1,72 @@
+# Loop Engineering MCP Server (Python)
+
+Python implementation of the Loop Engineering MCP server.
+
+## Installation
+
+### Using uvx (recommended - no installation needed)
+
+```bash
+uvx loop-mcp
+```
+
+### Using pip
+
+```bash
+pip install loop-mcp
+```
+
+## Configuration
+
+Add to your MCP configuration file:
+
+**Cursor** (`.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+**Kiro** (`.kiro/settings/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+**Claude Desktop**:
+- Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "loop-engineering": {
+      "command": "uvx",
+      "args": ["loop-mcp"]
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+cd python
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

loop_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "loop-mcp"
+version = "0.1.0"
+description = "MCP server for automated loop engineering in AI coding workflows"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["mcp", "ai", "coding", "automation", "loop-engineering"]
+authors = [
+    { name = "Loop Engineering Contributors" }
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "mcp>=0.9.0",
+    "pydantic>=2.0.0",
+    "aiofiles>=23.0.0",
+    "httpx>=0.27.0",
+    "croniter>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/loop-engineering"
+Documentation = "https://github.com/yourusername/loop-engineering#readme"
+Repository = "https://github.com/yourusername/loop-engineering"
+Issues = "https://github.com/yourusername/loop-engineering/issues"
+
+[project.scripts]
+loop-mcp = "loop_engineering_mcp.__main__:main"
+loop-mcp-worker = "loop_engineering_mcp.worker:main"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/loop_engineering_mcp"]
+
+[tool.black]
+line-length = 100
+target-version = ["py310"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

loop_mcp-0.1.0/src/loop_engineering_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""Loop Engineering MCP Server - Python Implementation."""
+
+__version__ = "0.1.0"
+
+from .server import create_server
+
+__all__ = ["create_server", "__version__"]

loop_mcp-0.1.0/src/loop_engineering_mcp/__main__.py

@@ -0,0 +1,37 @@
+"""Entry point for the Loop Engineering MCP server."""
+
+import asyncio
+import sys
+from mcp.server.stdio import stdio_server
+from .server import create_server
+
+
+async def _run_server():
+    """Run the MCP server with stdio transport."""
+    async with stdio_server() as (read_stream, write_stream):
+        server = create_server(start_scheduler=True)
+        scheduler = getattr(server, "_loop_scheduler", None)
+        if scheduler:
+            scheduler.start()
+        try:
+            init_options = server.create_initialization_options()
+            await server.run(read_stream, write_stream, init_options)
+        finally:
+            if scheduler:
+                await scheduler.stop()
+
+
+def main():
+    """Run the MCP server."""
+    try:
+        asyncio.run(_run_server())
+    except KeyboardInterrupt:
+        print("\nShutting down Loop Engineering MCP server...", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error running server: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

loop_mcp-0.1.0/src/loop_engineering_mcp/github_client.py

@@ -0,0 +1,130 @@
+"""GitHub API integration for PR creation."""
+
+import os
+import subprocess
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+
+from .retry import retry_async
+
+
+@dataclass
+class PullRequestResult:
+    """Result of creating a pull request."""
+
+    success: bool
+    pr_number: Optional[int] = None
+    pr_url: Optional[str] = None
+    branch: Optional[str] = None
+    error: Optional[str] = None
+
+
+class GitHubClient:
+    """Creates branches and pull requests via the GitHub REST API."""
+
+    API_BASE = "https://api.github.com"
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        repo: Optional[str] = None,
+        default_branch: str = "main",
+    ):
+        self.token = token or os.environ.get("GITHUB_TOKEN")
+        self.repo = repo or os.environ.get("GITHUB_REPO") or self._detect_repo()
+        self.default_branch = default_branch or os.environ.get("GITHUB_DEFAULT_BRANCH", "main")
+
+    def _detect_repo(self) -> Optional[str]:
+        try:
+            result = subprocess.run(
+                ["git", "remote", "get-url", "origin"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return None
+            url = result.stdout.strip()
+            # Handle git@github.com:owner/repo.git and https://github.com/owner/repo.git
+            if "github.com" in url:
+                parts = url.rstrip(".git").split("/")
+                if len(parts) >= 2:
+                    return f"{parts[-2]}/{parts[-1]}"
+            return None
+        except Exception:
+            return None
+
+    def _headers(self) -> dict[str, str]:
+        if not self.token:
+            raise ValueError("GITHUB_TOKEN environment variable is required")
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+
+    async def create_pull_request(
+        self,
+        *,
+        title: str,
+        body: str,
+        branch: str,
+        base: Optional[str] = None,
+    ) -> PullRequestResult:
+        """Create a pull request on GitHub."""
+        if not self.repo:
+            return PullRequestResult(
+                success=False,
+                error="Could not detect GitHub repo. Set GITHUB_REPO=owner/repo",
+            )
+
+        base_branch = base or self.default_branch
+
+        async def _create() -> PullRequestResult:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    f"{self.API_BASE}/repos/{self.repo}/pulls",
+                    headers=self._headers(),
+                    json={
+                        "title": title,
+                        "body": body,
+                        "head": branch,
+                        "base": base_branch,
+                    },
+                )
+                if response.status_code == 422:
+                    data = response.json()
+                    errors = data.get("errors", [])
+                    msg = errors[0].get("message") if errors else data.get("message", "Validation failed")
+                    return PullRequestResult(success=False, error=msg)
+                response.raise_for_status()
+                data = response.json()
+                return PullRequestResult(
+                    success=True,
+                    pr_number=data["number"],
+                    pr_url=data["html_url"],
+                    branch=branch,
+                )
+
+        try:
+            return await retry_async(_create, max_attempts=3)
+        except Exception as e:
+            return PullRequestResult(success=False, error=str(e))
+
+    async def push_branch(self, branch: str, cwd: Optional[str] = None) -> tuple[bool, str]:
+        """Push the current branch to origin."""
+        try:
+            result = subprocess.run(
+                ["git", "push", "-u", "origin", branch],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                cwd=cwd,
+            )
+            if result.returncode != 0:
+                return False, result.stderr or result.stdout
+            return True, "Branch pushed successfully"
+        except Exception as e:
+            return False, str(e)

loop_mcp-0.1.0/src/loop_engineering_mcp/logger.py

@@ -0,0 +1,60 @@
+"""Structured logging for loop engineering."""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+class LoopLogger:
+    """Writes structured JSON logs to .loop/logs/."""
+
+    def __init__(self, logs_dir: Path):
+        self.logs_dir = logs_dir
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
+        self._logger = logging.getLogger("loop_engineering")
+        if not self._logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+            self._logger.addHandler(handler)
+            self._logger.setLevel(logging.INFO)
+
+    def _write_json(self, filename: str, entry: dict[str, Any]) -> None:
+        log_file = self.logs_dir / filename
+        with open(log_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, default=str) + "\n")
+
+    def _entry(
+        self,
+        level: str,
+        event: str,
+        loop_name: Optional[str] = None,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        return {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "level": level,
+            "event": event,
+            "loop_name": loop_name,
+            **extra,
+        }
+
+    def info(self, event: str, loop_name: Optional[str] = None, **extra: Any) -> None:
+        entry = self._entry("INFO", event, loop_name, **extra)
+        self._write_json("loop-engineering.log", entry)
+        self._logger.info(f"[{loop_name or 'system'}] {event}")
+
+    def warning(self, event: str, loop_name: Optional[str] = None, **extra: Any) -> None:
+        entry = self._entry("WARNING", event, loop_name, **extra)
+        self._write_json("loop-engineering.log", entry)
+        self._logger.warning(f"[{loop_name or 'system'}] {event}")
+
+    def error(self, event: str, loop_name: Optional[str] = None, **extra: Any) -> None:
+        entry = self._entry("ERROR", event, loop_name, **extra)
+        self._write_json("loop-engineering.log", entry)
+        self._logger.error(f"[{loop_name or 'system'}] {event}")
+
+    def run_log(self, loop_name: str, run_id: str, data: dict[str, Any]) -> None:
+        entry = self._entry("INFO", "loop_run", loop_name, run_id=run_id, **data)
+        self._write_json(f"{loop_name}-runs.log", entry)