agloop 0.6.0__py3-none-any.whl

core/git_lock.py

@@ -0,0 +1,406 @@
+import json
+import logging
+import os
+import random
+import shutil
+import socket
+import time
+import warnings
+from typing import Iterable, Optional
+
+from git import Repo
+from git.exc import GitCommandError
+
+_logger = logging.getLogger("agloop.git_lock")
+
+# Markers git prints when a push is rejected because the remote moved ahead
+# (i.e. another agent won the race). Anything else (network, auth...) is
+# treated as a transient failure and the local commit is kept for later.
+_REJECTION_MARKERS = ("rejected", "non-fast-forward", "fetch first", "failed to push some refs")
+
+
+class GitLock:
+    """
+    Hybrid lock for AgLoop.
+
+    - Local agents (same disk / same working tree) are serialized by an atomic
+      directory lock (`.agloop.lock/`), with stale-lock recovery.
+    - Remote agents (other machines) are synchronized through Git, used as a
+      serverless message broker (fetch / rebase / push).
+
+    Safety rules (the working tree may be shared with other agents writing code):
+      * Only the War Room paths are ever staged / committed.
+      * Never `reset --hard`: other agents' uncommitted work must survive.
+      * Never pull unless the remote actually has new commits.
+    """
+
+    def __init__(self, repo_path: str = ".", lock_timeout: Optional[float] = None, push_retries: int = 3):
+        self.repo_path = repo_path
+        self.repo = Repo(repo_path)
+        try:
+            self.origin = self.repo.remotes.origin
+        except (IndexError, AttributeError):
+            self.origin = None
+
+        if os.getenv("AGENT_LOOP_LOCAL_MODE") is not None:
+            warnings.warn(
+                "AGENT_LOOP_LOCAL_MODE is deprecated and ignored: AgLoop now always runs in "
+                "hybrid mode (local mtime + remote git fetch). You can remove it from .env.",
+                FutureWarning,
+                stacklevel=2,
+            )
+
+        self.lock_dir = os.path.join(repo_path, ".agloop.lock")
+        self.lock_timeout = float(lock_timeout if lock_timeout is not None else os.getenv("AGLOOP_LOCK_TIMEOUT", 300))
+        self.push_retries = push_retries
+        # Status of the last acquire_lock_and_push() call, for the runner's logs:
+        # ok | locked | sync_failed | commit_failed | push_failed | lost_race
+        self.last_status = "ok"
+        self._warned = set()
+
+    # ------------------------------------------------------------------ #
+    # Local lock (atomic mkdir) with stale-lock recovery
+    # ------------------------------------------------------------------ #
+    def _owner_file(self, lock_dir: Optional[str] = None) -> str:
+        return os.path.join(lock_dir or self.lock_dir, "owner.json")
+
+    def _read_owner(self, lock_dir: Optional[str] = None) -> Optional[dict]:
+        try:
+            with open(self._owner_file(lock_dir), "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (OSError, ValueError):
+            return None
+
+    @staticmethod
+    def _pid_alive(pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True  # exists, owned by another user
+        return True
+
+    def _lock_is_stale(self) -> bool:
+        owner = self._read_owner()
+        if owner is None:
+            # Owner file not written yet (or corrupted): fall back to the dir age,
+            # so a process that died right after mkdir doesn't block forever.
+            try:
+                age = time.time() - os.path.getmtime(self.lock_dir)
+            except OSError:
+                return False  # lock vanished meanwhile
+            return age > self.lock_timeout
+
+        if time.time() - float(owner.get("ts", 0)) > self.lock_timeout:
+            return True
+        if owner.get("host") == socket.gethostname():
+            pid = owner.get("pid")
+            if isinstance(pid, int) and not self._pid_alive(pid):
+                return True
+        return False
+
+    def _break_stale_lock(self):
+        # Rename first (atomic) so concurrent breakers don't delete each other's
+        # fresh locks with rmtree; then clean up the renamed directory.
+        tomb = f"{self.lock_dir}.stale.{os.getpid()}.{random.randint(0, 1_000_000)}"
+        try:
+            os.rename(self.lock_dir, tomb)
+        except OSError:
+            return
+        shutil.rmtree(tomb, ignore_errors=True)
+        _logger.warning("stale local lock recovered", extra={"event": "stale_lock_recovered"})
+
+    def _acquire_local_lock(self) -> bool:
+        """Uses atomic directory creation as a local lock."""
+        for _ in range(2):
+            try:
+                os.mkdir(self.lock_dir)
+            except FileExistsError:
+                if self._lock_is_stale():
+                    self._break_stale_lock()
+                    continue
+                return False
+            owner = {"pid": os.getpid(), "host": socket.gethostname(), "ts": time.time()}
+            with open(self._owner_file(), "w", encoding="utf-8") as f:
+                json.dump(owner, f)
+            return True
+        return False
+
+    def _release_local_lock(self):
+        """Releases the local lock, but only if we still own it."""
+        owner = self._read_owner()
+        if owner is not None and (owner.get("pid") != os.getpid() or owner.get("host") != socket.gethostname()):
+            return  # our lock was considered stale and taken over; don't delete theirs
+        shutil.rmtree(self.lock_dir, ignore_errors=True)
+
+    # ------------------------------------------------------------------ #
+    # Git helpers
+    # ------------------------------------------------------------------ #
+    def _warn_once(self, key: str, msg: str):
+        if key not in self._warned:
+            self._warned.add(key)
+            _logger.warning(msg, extra={"event": f"git_{key}_warning"})
+
+    def _branch(self) -> str:
+        try:
+            return self.repo.active_branch.name
+        except (TypeError, ValueError):
+            return "main"
+
+    def _remote_ref(self) -> str:
+        return f"origin/{self._branch()}"
+
+    def _rev_count(self, range_spec: str) -> int:
+        try:
+            return int(self.repo.git.rev_list("--count", range_spec).strip() or 0)
+        except (GitCommandError, ValueError):
+            return 0
+
+    def _commits_ahead(self) -> int:
+        if not self.origin:
+            return 0
+        try:
+            self.repo.git.rev_parse("--verify", "--quiet", self._remote_ref())
+        except GitCommandError:
+            # Branch doesn't exist on the remote yet: everything local is unpushed.
+            return self._rev_count("HEAD")
+        return self._rev_count(f"{self._remote_ref()}..HEAD")
+
+    def _fetch(self) -> bool:
+        if not self.origin:
+            return False
+        try:
+            self.repo.git.fetch("--quiet", "origin", self._branch())
+            self._warned.discard("fetch")
+            return True
+        except GitCommandError as e:
+            # Ref-lock collision with another local fetch, or no network: just skip.
+            self._warn_once("fetch", f"[AgLoop] git fetch failed (will keep trying silently): {e.stderr.strip() if e.stderr else e}")
+            return False
+
+    def has_remote_updates(self) -> bool:
+        """
+        Cheap remote check: fetch + count commits that exist on origin but not locally.
+        Being *ahead* of origin (unpushed commits) does NOT count as an update.
+        """
+        if not self.origin:
+            return False
+        if not self._fetch():
+            return False
+        return self._rev_count(f"HEAD..{self._remote_ref()}") > 0
+
+    def _rebase_onto_remote(self) -> bool:
+        """Rebase local commits onto origin/<branch>, stashing others' dirty files around it."""
+        try:
+            self.repo.git.rebase("--autostash", self._remote_ref())
+            return True
+        except GitCommandError as e:
+            _logger.warning(
+                "rebase onto remote failed: %s",
+                e.stderr.strip() if e.stderr else e,
+                extra={"event": "rebase_failed"},
+            )
+            try:
+                self.repo.git.rebase("--abort")
+            except GitCommandError:
+                pass
+            return False
+
+    def _path_in_tree(self, rev: str, path: str) -> bool:
+        try:
+            self.repo.git.cat_file("-e", f"{rev}:{path}")
+            return True
+        except GitCommandError:
+            return False
+
+    def _resolve_lost_race(self, paths: Iterable[str]) -> bool:
+        """
+        Another agent pushed a War Room update first. Drop OUR unpushed room changes
+        (they were based on stale context), fast-forward to the remote and let the
+        agent re-read and decide again. Only `paths` are reverted; everything else in
+        the working tree (other agents' code) is preserved.
+        """
+        remote = self._remote_ref()
+        try:
+            base = self.repo.git.merge_base("HEAD", remote).strip()
+            self.repo.git.reset("--soft", base)
+            for p in paths:
+                if self._path_in_tree(base, p):
+                    self.repo.git.checkout(base, "--", p)
+                else:
+                    self.repo.git.rm("--cached", "--quiet", "--ignore-unmatch", "--", p)
+                    if os.path.exists(os.path.join(self.repo_path, p)):
+                        os.remove(os.path.join(self.repo_path, p))
+        except GitCommandError as e:
+            _logger.error("could not drop local room changes: %s", e, extra={"event": "lost_race_recovery_failed"})
+            return False
+        return self._rebase_onto_remote()
+
+    # ------------------------------------------------------------------ #
+    # Public API
+    # ------------------------------------------------------------------ #
+    def sync_if_needed(self, paths: Iterable[str] = ()) -> bool:
+        """
+        Pull remote updates ONLY if they exist. In a shared working tree with no remote
+        news, this never touches the disk (fixes 'cannot pull with rebase: You have
+        unstaged changes').
+        """
+        if not self.origin:
+            return True
+        if not self.has_remote_updates():
+            return True  # nothing new, or fetch failed (push will tell us later)
+        if self._rebase_onto_remote():
+            return True
+        # Rebase conflicted: our pending room commit collides with a remote message.
+        return self._resolve_lost_race(paths)
+
+    def pull(self) -> bool:
+        """Backward-compatible alias: syncs with the remote only when needed."""
+        return self.sync_if_needed()
+
+    def _existing_paths(self, paths: Iterable[str]) -> list:
+        result = []
+        for p in paths:
+            full = os.path.join(self.repo_path, p) if not os.path.isabs(p) else p
+            if os.path.exists(full) or self._path_in_tree("HEAD", p):
+                result.append(p)
+        return result
+
+    def has_changes(self, paths: Iterable[str]) -> bool:
+        """Checks if any of `paths` is modified, staged or untracked."""
+        active = self._existing_paths(paths)
+        if not active:
+            return False
+        return bool(self.repo.git.status("--porcelain", "--", *active).strip())
+
+    def has_uncommitted_changes(self) -> bool:
+        """Checks if there are any modified or untracked files (whole working tree)."""
+        return self.repo.is_dirty(untracked_files=True)
+
+    @staticmethod
+    def _author_env(author_name: Optional[str], author_email: Optional[str]) -> dict:
+        if not author_name:
+            return {}
+        slug = author_name.strip().lower().replace(" ", ".")
+        email = author_email or f"{slug}@agloop.local"
+        return {
+            "GIT_AUTHOR_NAME": author_name,
+            "GIT_AUTHOR_EMAIL": email,
+            "GIT_COMMITTER_NAME": author_name,
+            "GIT_COMMITTER_EMAIL": email,
+        }
+
+    def commit(
+        self,
+        message: str,
+        paths: Iterable[str],
+        author_name: Optional[str] = None,
+        author_email: Optional[str] = None,
+    ) -> bool:
+        """
+        Stages and commits ONLY `paths`. `git commit -- <paths>` also ignores anything
+        another agent may have staged in the shared index.
+        When `author_name` is provided, sets `GIT_AUTHOR_*` and `GIT_COMMITTER_*`
+        scoped strictly to the git commit subprocess (never mutates global os.environ).
+        """
+        active = self._existing_paths(paths)
+        if not active:
+            return True
+        try:
+            self.repo.git.add("--", *active)
+            if not self.has_changes(active):
+                return True
+            env = self._author_env(author_name, author_email)
+            with self.repo.git.custom_environment(**env):
+                self.repo.git.commit("-m", message, "--", *active)
+            return True
+        except GitCommandError as e:
+            _logger.error("git commit error: %s", e, extra={"event": "commit_failed"})
+            return False
+
+    def push(self, paths: Iterable[str] = ()) -> bool:
+        """
+        Pushes local commits. On rejection (another agent pushed first):
+          - clean rebase (remote changed other files) -> retry push;
+          - conflicting rebase (remote has a new room message) -> lost race:
+            drop our room changes and fast-forward. Never touches other files.
+        On network/auth errors the commit is kept and pushed on a later iteration.
+        """
+        if not self.origin:
+            return True
+        paths = list(paths)
+        branch = self._branch()
+        for attempt in range(1, self.push_retries + 1):
+            try:
+                self.repo.git.push("origin", branch)
+                return True
+            except GitCommandError as e:
+                err = (e.stderr or str(e)).lower()
+                if not any(m in err for m in _REJECTION_MARKERS):
+                    _logger.warning(
+                        "push failed (kept locally, will retry): %s",
+                        e.stderr.strip() if e.stderr else e,
+                        extra={"event": "push_failed"},
+                    )
+                    self.last_status = "push_failed"
+                    return False
+                _logger.info(
+                    "push rejected, another agent pushed first (attempt %d/%d)",
+                    attempt,
+                    self.push_retries,
+                    extra={"event": "push_rejected"},
+                )
+                if not self._fetch():
+                    self.last_status = "push_failed"
+                    return False
+                if not self._rebase_onto_remote():
+                    self._resolve_lost_race(paths)
+                    self.last_status = "lost_race"
+                    return False
+                time.sleep(random.uniform(0.2, 1.0) * attempt)
+        self.last_status = "push_failed"
+        return False
+
+    def acquire_lock_and_push(
+        self,
+        action_callback,
+        message: str,
+        paths: Iterable[str],
+        author_name: Optional[str] = None,
+        author_email: Optional[str] = None,
+    ) -> bool:
+        """
+        1. acquire local lock (always)
+        2. sync with remote only if it has news
+        3. action_callback() modifies the War Room
+        4. commit only `paths` (with optional isolated per-agent Git author/committer)
+        5. push any unpushed commit (including leftovers from earlier failures)
+        6. release local lock
+        Check `self.last_status` for the reason of a False return.
+        """
+        paths = list(paths)
+        if not self._acquire_local_lock():
+            self.last_status = "locked"
+            return False
+
+        try:
+            if not self.sync_if_needed(paths):
+                self.last_status = "sync_failed"
+                return False
+
+            action_callback()
+
+            if self.has_changes(paths) and not self.commit(
+                message, paths, author_name=author_name, author_email=author_email
+            ):
+                self.last_status = "commit_failed"
+                return False
+
+            if self._commits_ahead() > 0 and not self.push(paths):
+                return False  # push() sets last_status
+
+            self.last_status = "ok"
+            return True
+        finally:
+            self._release_local_lock()

core/init_scaffold.py

@@ -0,0 +1,59 @@
+"""
+AgLoop Init Scaffold (E07.2).
+
+`agloop init`: copies the War Room + governance templates bundled under
+`core/templates/` into the user's repository, without ever overwriting a
+file that already exists at the destination.
+"""
+
+import os
+import shutil
+from typing import List, Tuple
+
+_TEMPLATES_DIR = os.path.join(os.path.dirname(__file__), "templates")
+
+# (template path relative to _TEMPLATES_DIR, destination path relative to repo_root)
+_FILES: Tuple[Tuple[str, str], ...] = (
+    ("war_room.md", "war_room.md"),
+    ("HISTORICO.md", "HISTORICO.md"),
+    ("gestao/roadmap.md", "docs/gestao/roadmap.md"),
+    ("gestao/backlog-produto.md", "docs/gestao/backlog-produto.md"),
+    ("gestao/matriz-riscos.md", "docs/gestao/matriz-riscos.md"),
+)
+
+_EMPTY_DIRS: Tuple[str, ...] = ("docs/arquitetura/decisoes",)
+
+
+def run_init(repo_root: str = ".") -> str:
+    """Scaffolds War Room governance files into `repo_root`. Returns a plain-text report."""
+    root = os.path.realpath(repo_root)
+    created: List[str] = []
+    skipped: List[str] = []
+
+    for template_rel, dest_rel in _FILES:
+        dest_path = os.path.join(root, dest_rel)
+        if os.path.exists(dest_path):
+            skipped.append(dest_rel)
+            continue
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        shutil.copyfile(os.path.join(_TEMPLATES_DIR, template_rel), dest_path)
+        created.append(dest_rel)
+
+    for dir_rel in _EMPTY_DIRS:
+        dir_path = os.path.join(root, dir_rel)
+        if os.path.isdir(dir_path):
+            skipped.append(f"{dir_rel}/")
+        else:
+            os.makedirs(dir_path, exist_ok=True)
+            created.append(f"{dir_rel}/")
+
+    lines = ["AgLoop - Inicializacao da Sala de Guerra", "=" * 42, ""]
+    lines.append(f"[criado] {len(created)} item(ns):")
+    for item in created:
+        lines.append(f"  - {item}")
+    if skipped:
+        lines.append(f"\n[ja existia, preservado] {len(skipped)} item(ns):")
+        for item in skipped:
+            lines.append(f"  - {item}")
+
+    return "\n".join(lines)

core/mcp_server.py

@@ -0,0 +1,224 @@
+"""
+AgLoop MCP Server (E04.2 / LGPD-03).
+
+Lightweight MCP (Model Context Protocol) server over JSON-RPC 2.0 on stdio —
+no external MCP SDK, reusing the existing `WarRoom`, `GitLock` and the
+workspace-confinement primitives from `core.agent` (DRY, same safety model
+already enforced for `read_file`/`list_dir`).
+
+Exposes 3 tools, all confined to the War Room files only (never an arbitrary
+path inside the repository — LGPD-03):
+  * `read_war_room`         — read the recent transcript, PII-sanitized.
+  * `post_war_room_message` — append a message to `war_room.md` (commit+push via GitLock).
+  * `get_lock_status`       — inspect GitLock / War Room state.
+"""
+
+import json
+import os
+import sys
+from typing import Any, Dict, Optional
+
+from core.agent import _is_sensitive_path, _is_within_workspace, sanitize_prompt_pii
+from core.git_lock import GitLock
+from core.scan import run_scan
+from core.war_room import WarRoom
+
+MCP_PROTOCOL_VERSION = "2024-11-05"
+SERVER_NAME = "agloop"
+SERVER_VERSION = "0.5.0"
+
+# Only these two files are ever reachable through the MCP tools — fixed by basename,
+# so an attacker-supplied directory prefix (e.g. "../outside/war_room.md") is simply
+# discarded rather than followed (LGPD-03: workspace sandboxing).
+ALLOWED_WAR_ROOM_FILES = {"war_room.md", "HISTORICO.md"}
+
+
+def _resolve_allowed_file(repo_root: str, filepath: str) -> str:
+    """Resolves `filepath` to an absolute path inside `repo_root`, enforcing the allowlist."""
+    basename = os.path.basename(filepath)
+    if basename not in ALLOWED_WAR_ROOM_FILES:
+        raise ValueError(
+            f"Access denied: '{filepath}' is not a War Room file (allowed: {sorted(ALLOWED_WAR_ROOM_FILES)})."
+        )
+    target = os.path.join(repo_root, basename)
+    if not _is_within_workspace(repo_root, target):
+        raise ValueError("Access denied: path is outside the repository workspace.")
+    if _is_sensitive_path(repo_root, target):
+        raise ValueError("Access denied: sensitive path blocked.")
+    return target
+
+
+def read_war_room(max_turns: int = 6, filepath: str = "war_room.md", repo_root: Optional[str] = None) -> str:
+    """Reads the recent War Room transcript (sliding window), PII-sanitized."""
+    root = os.path.realpath(repo_root or os.getcwd())
+    target = _resolve_allowed_file(root, filepath)
+    war_room = WarRoom(filepath=target)
+    return sanitize_prompt_pii(war_room.read_recent(max_turns=max_turns))
+
+
+def post_war_room_message(
+    agent_name: str, message: str, push: bool = True, repo_root: Optional[str] = None
+) -> Dict[str, Any]:
+    """Appends `message` to `war_room.md` as `agent_name`; commits+pushes via `GitLock` when `push`."""
+    root = os.path.realpath(repo_root or os.getcwd())
+    target = _resolve_allowed_file(root, "war_room.md")
+    war_room = WarRoom(filepath=target)
+
+    if not push:
+        war_room.append_message(agent_name, message)
+        return {"pushed": False, "status": "ok"}
+
+    git_lock = GitLock(repo_path=root)
+    ok = git_lock.acquire_lock_and_push(
+        action_callback=lambda: war_room.append_message(agent_name, message),
+        message=f"AgLoop: {agent_name} update in war_room.md (via MCP)",
+        paths=war_room.paths,
+        author_name=agent_name,
+    )
+    return {"pushed": ok, "status": git_lock.last_status}
+
+
+def get_lock_status(filepath: str = "war_room.md", repo_root: Optional[str] = None) -> Dict[str, Any]:
+    """Inspects the local lock and the War Room state for `filepath`."""
+    root = os.path.realpath(repo_root or os.getcwd())
+    target = _resolve_allowed_file(root, filepath)
+
+    git_lock = GitLock(repo_path=root)
+    lock_dir_real = os.path.realpath(git_lock.lock_dir)
+    if not _is_within_workspace(root, lock_dir_real):
+        raise ValueError("Access denied: lock directory is outside the repository workspace.")
+
+    locked = os.path.isdir(git_lock.lock_dir)
+    stale = locked and git_lock._lock_is_stale()
+    war_room = WarRoom(filepath=target)
+    return {
+        "locked": locked,
+        "stale": stale,
+        "last_speaker": war_room.get_last_speaker(),
+        "state": war_room.get_state(),
+        "paths": war_room.paths,
+    }
+
+
+def scan_repository(repo_root: Optional[str] = None) -> str:
+    """Read-only structure + stack scan of the repository, confined to the workspace (E07.3)."""
+    root = os.path.realpath(repo_root or os.getcwd())
+    return run_scan(repo_root=root)
+
+
+TOOLS = [
+    {
+        "name": "read_war_room",
+        "description": "Read the recent War Room transcript (war_room.md or HISTORICO.md), PII-sanitized.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "max_turns": {"type": "integer", "default": 6},
+                "filepath": {"type": "string", "default": "war_room.md"},
+            },
+        },
+    },
+    {
+        "name": "post_war_room_message",
+        "description": "Append a message to war_room.md as agent_name, committing and pushing via GitLock.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "agent_name": {"type": "string"},
+                "message": {"type": "string"},
+                "push": {"type": "boolean", "default": True},
+            },
+            "required": ["agent_name", "message"],
+        },
+    },
+    {
+        "name": "get_lock_status",
+        "description": "Inspect the War Room's GitLock state and last speaker.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "filepath": {"type": "string", "default": "war_room.md"},
+            },
+        },
+    },
+    {
+        "name": "scan_repository",
+        "description": "Read-only scan of the repository: directory structure (bounded) and known stack manifests.",
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+]
+
+_TOOL_FUNCS = {
+    "read_war_room": read_war_room,
+    "post_war_room_message": post_war_room_message,
+    "get_lock_status": get_lock_status,
+    "scan_repository": scan_repository,
+}
+
+
+def _dispatch(method: str, params: Dict[str, Any]) -> Any:
+    if method == "initialize":
+        return {
+            "protocolVersion": MCP_PROTOCOL_VERSION,
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+            "capabilities": {"tools": {}},
+        }
+    if method == "notifications/initialized":
+        return None
+    if method == "tools/list":
+        return {"tools": TOOLS}
+    if method == "tools/call":
+        name = params.get("name")
+        arguments = params.get("arguments") or {}
+        fn = _TOOL_FUNCS.get(name)
+        if fn is None:
+            raise ValueError(f"Unknown tool: {name}")
+        try:
+            result = fn(**arguments)
+        except TypeError as e:
+            raise ValueError(f"Invalid arguments for '{name}': {e}")
+        text = result if isinstance(result, str) else json.dumps(result, ensure_ascii=False)
+        return {"content": [{"type": "text", "text": text}], "isError": False}
+    raise ValueError(f"Unknown method: {method}")
+
+
+def _handle_line(line: str) -> Optional[Dict[str, Any]]:
+    """Parses one JSON-RPC 2.0 request/notification and returns the reply (or None for notifications)."""
+    try:
+        request = json.loads(line)
+    except json.JSONDecodeError as e:
+        return {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": f"Parse error: {e}"}}
+
+    req_id = request.get("id")
+    method = request.get("method", "")
+    params = request.get("params") or {}
+    is_notification = "id" not in request
+
+    try:
+        result = _dispatch(method, params)
+    except ValueError as e:
+        return None if is_notification else {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32602, "message": str(e)}}
+    except Exception as e:
+        return None if is_notification else {
+            "jsonrpc": "2.0", "id": req_id, "error": {"code": -32603, "message": f"Internal error: {e}"}
+        }
+
+    if is_notification:
+        return None
+    return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+
+def main():
+    """Reads JSON-RPC requests from stdin (one per line) and writes replies to stdout."""
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        response = _handle_line(line)
+        if response is not None:
+            sys.stdout.write(json.dumps(response, ensure_ascii=False) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()