axion-code 1.0.0__py3-none-any.whl

axion/runtime/lanes.py

@@ -0,0 +1,282 @@
+"""Lane events, branch lock, stale branch detection, and summary compression.
+
+Maps to: rust/crates/runtime/src/lane_events.rs, branch_lock.rs, stale_branch.rs
+"""
+
+from __future__ import annotations
+
+import enum
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Lane status and events
+# ---------------------------------------------------------------------------
+
+class LaneStatus(enum.Enum):
+    ACTIVE = "active"
+    COMPLETED = "completed"
+    BLOCKED = "blocked"
+    RECONCILED = "reconciled"
+    FAILED = "failed"
+
+
+class LaneEventType(enum.Enum):
+    CREATED = "created"
+    STARTED = "started"
+    TOOL_EXECUTED = "tool_executed"
+    ITERATION_COMPLETED = "iteration_completed"
+    BLOCKED = "blocked"
+    UNBLOCKED = "unblocked"
+    GREEN_LEVEL_CHANGED = "green_level_changed"
+    REVIEW_REQUESTED = "review_requested"
+    REVIEW_APPROVED = "review_approved"
+    REVIEW_REJECTED = "review_rejected"
+    MERGE_REQUESTED = "merge_requested"
+    MERGE_COMPLETED = "merge_completed"
+    RECONCILED = "reconciled"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    ESCALATED = "escalated"
+    RECOVERED = "recovered"
+
+
+@dataclass
+class LaneEvent:
+    """Timestamped event in a lane's lifecycle."""
+
+    lane_id: str
+    event_type: LaneEventType
+    timestamp_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+    details: dict[str, Any] = field(default_factory=dict)
+    green_level: int | None = None
+    message: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {
+            "lane_id": self.lane_id,
+            "event_type": self.event_type.value,
+            "timestamp_ms": self.timestamp_ms,
+        }
+        if self.details:
+            d["details"] = self.details
+        if self.green_level is not None:
+            d["green_level"] = self.green_level
+        if self.message:
+            d["message"] = self.message
+        return d
+
+
+# ---------------------------------------------------------------------------
+# Lane state tracker
+# ---------------------------------------------------------------------------
+
+@dataclass
+class LaneState:
+    """Current state of a lane."""
+
+    lane_id: str
+    status: LaneStatus = LaneStatus.ACTIVE
+    green_level: int = 0
+    branch: str = ""
+    worker_id: str | None = None
+    events: list[LaneEvent] = field(default_factory=list)
+    blocker_reason: str = ""
+    created_at_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+
+    def record_event(
+        self,
+        event_type: LaneEventType,
+        message: str = "",
+        **details: Any,
+    ) -> LaneEvent:
+        event = LaneEvent(
+            lane_id=self.lane_id,
+            event_type=event_type,
+            green_level=self.green_level,
+            message=message,
+            details=details if details else {},
+        )
+        self.events.append(event)
+        return event
+
+
+class LaneEventLog:
+    """Tracks lane events for git workflow coordination."""
+
+    def __init__(self) -> None:
+        self._lanes: dict[str, LaneState] = {}
+        self._all_events: list[LaneEvent] = []
+
+    def create_lane(self, lane_id: str, branch: str = "") -> LaneState:
+        state = LaneState(lane_id=lane_id, branch=branch)
+        state.record_event(LaneEventType.CREATED, f"Lane created for branch {branch}")
+        self._lanes[lane_id] = state
+        return state
+
+    def get_lane(self, lane_id: str) -> LaneState | None:
+        return self._lanes.get(lane_id)
+
+    def record(self, event: LaneEvent) -> None:
+        self._all_events.append(event)
+        lane = self._lanes.get(event.lane_id)
+        if lane:
+            lane.events.append(event)
+
+    def events_for_lane(self, lane_id: str) -> list[LaneEvent]:
+        lane = self._lanes.get(lane_id)
+        return lane.events if lane else []
+
+    def all_events(self) -> list[LaneEvent]:
+        return list(self._all_events)
+
+    def all_lanes(self) -> list[LaneState]:
+        return list(self._lanes.values())
+
+    def active_lanes(self) -> list[LaneState]:
+        return [lane for lane in self._lanes.values() if lane.status == LaneStatus.ACTIVE]
+
+
+# ---------------------------------------------------------------------------
+# Branch lock
+# ---------------------------------------------------------------------------
+
+@dataclass
+class BranchLock:
+    """Lock on a git branch to prevent concurrent modifications."""
+
+    branch: str
+    holder: str
+    acquired_at_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+    expires_at_ms: int | None = None
+    reason: str = ""
+
+    def is_expired(self) -> bool:
+        if self.expires_at_ms is None:
+            return False
+        return int(time.time() * 1000) > self.expires_at_ms
+
+
+class BranchLockManager:
+    """Manages branch locks with expiry and reason tracking."""
+
+    def __init__(self) -> None:
+        self._locks: dict[str, BranchLock] = {}
+
+    def acquire(
+        self,
+        branch: str,
+        holder: str,
+        ttl_ms: int = 300_000,
+        reason: str = "",
+    ) -> bool:
+        """Acquire a branch lock. Returns False if already held by another."""
+        existing = self._locks.get(branch)
+        if existing and not existing.is_expired() and existing.holder != holder:
+            return False
+        now = int(time.time() * 1000)
+        self._locks[branch] = BranchLock(
+            branch=branch,
+            holder=holder,
+            acquired_at_ms=now,
+            expires_at_ms=now + ttl_ms,
+            reason=reason,
+        )
+        return True
+
+    def release(self, branch: str, holder: str) -> bool:
+        lock = self._locks.get(branch)
+        if lock and lock.holder == holder:
+            del self._locks[branch]
+            return True
+        return False
+
+    def is_locked(self, branch: str) -> bool:
+        lock = self._locks.get(branch)
+        return lock is not None and not lock.is_expired()
+
+    def lock_holder(self, branch: str) -> str | None:
+        lock = self._locks.get(branch)
+        if lock and not lock.is_expired():
+            return lock.holder
+        return None
+
+    def all_locks(self) -> list[BranchLock]:
+        # Clean expired locks
+        now = int(time.time() * 1000)
+        self._locks = {
+            k: v for k, v in self._locks.items()
+            if v.expires_at_ms is None or v.expires_at_ms > now
+        }
+        return list(self._locks.values())
+
+
+# ---------------------------------------------------------------------------
+# Stale branch detection
+# ---------------------------------------------------------------------------
+
+DEFAULT_STALE_THRESHOLD_MS = 86_400_000  # 24 hours
+
+
+def is_stale_branch(
+    last_commit_ms: int,
+    threshold_ms: int = DEFAULT_STALE_THRESHOLD_MS,
+) -> bool:
+    """Check if a branch is stale (default: 24 hours since last commit)."""
+    now_ms = int(time.time() * 1000)
+    return (now_ms - last_commit_ms) > threshold_ms
+
+
+def branch_freshness_ms(last_commit_ms: int) -> int:
+    """Get time since last commit in milliseconds."""
+    now_ms = int(time.time() * 1000)
+    return now_ms - last_commit_ms
+
+
+# ---------------------------------------------------------------------------
+# Summary compression (for lane event history)
+# ---------------------------------------------------------------------------
+
+def compress_lane_summary(events: list[LaneEvent], max_events: int = 20) -> str:
+    """Compress a list of lane events into a summary string.
+
+    Keeps the first and last events, plus key transitions.
+    """
+    if not events:
+        return "(no events)"
+
+    if len(events) <= max_events:
+        lines = []
+        for e in events:
+            ts = time.strftime("%H:%M:%S", time.gmtime(e.timestamp_ms / 1000))
+            lines.append(f"[{ts}] {e.event_type.value}: {e.message or '(no message)'}")
+        return "\n".join(lines)
+
+    # Compress: keep first, last, and key transitions
+    key_types = {
+        LaneEventType.CREATED, LaneEventType.COMPLETED, LaneEventType.FAILED,
+        LaneEventType.BLOCKED, LaneEventType.UNBLOCKED,
+        LaneEventType.MERGE_COMPLETED, LaneEventType.ESCALATED,
+        LaneEventType.GREEN_LEVEL_CHANGED,
+    }
+
+    kept: list[LaneEvent] = [events[0]]
+    for e in events[1:-1]:
+        if e.event_type in key_types:
+            kept.append(e)
+    kept.append(events[-1])
+
+    # Truncate if still too long
+    if len(kept) > max_events:
+        kept = kept[:max_events - 1] + [kept[-1]]
+
+    skipped = len(events) - len(kept)
+    lines = []
+    for e in kept:
+        ts = time.strftime("%H:%M:%S", time.gmtime(e.timestamp_ms / 1000))
+        lines.append(f"[{ts}] {e.event_type.value}: {e.message or '(no message)'}")
+    if skipped > 0:
+        lines.insert(-1, f"  ... ({skipped} events compressed)")
+
+    return "\n".join(lines)

axion/runtime/lsp.py

@@ -0,0 +1,425 @@
+"""LSP (Language Server Protocol) client with JSON-RPC communication.
+
+Maps to: rust/crates/runtime/src/lsp_client.rs
+"""
+
+from __future__ import annotations
+
+import asyncio
+import enum
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class LspAction(enum.Enum):
+    DIAGNOSTICS = "diagnostics"
+    HOVER = "hover"
+    DEFINITION = "definition"
+    REFERENCES = "references"
+    COMPLETION = "completion"
+    SYMBOLS = "symbols"
+    FORMAT = "format"
+
+
+class LspServerStatus(enum.Enum):
+    CONNECTED = "connected"
+    DISCONNECTED = "disconnected"
+    STARTING = "starting"
+    ERROR = "error"
+
+
+class LspSeverity(enum.Enum):
+    ERROR = "error"
+    WARNING = "warning"
+    INFORMATION = "information"
+    HINT = "hint"
+
+
+@dataclass
+class LspDiagnostic:
+    path: str
+    line: int
+    character: int
+    severity: LspSeverity
+    message: str
+    source: str = ""
+    code: str | None = None
+    end_line: int | None = None
+    end_character: int | None = None
+
+
+@dataclass
+class LspLocation:
+    path: str
+    line: int
+    character: int
+    end_line: int | None = None
+    end_character: int | None = None
+    preview: str = ""
+
+
+@dataclass
+class LspHoverResult:
+    content: str
+    language: str = ""
+    range_start_line: int | None = None
+    range_start_character: int | None = None
+
+
+@dataclass
+class LspCompletionItem:
+    label: str
+    kind: str = ""
+    detail: str = ""
+    insert_text: str = ""
+    sort_text: str = ""
+
+
+@dataclass
+class LspSymbol:
+    name: str
+    kind: str
+    path: str
+    line: int
+    character: int
+    container_name: str = ""
+
+
+@dataclass
+class LspServerInfo:
+    """Information about a connected LSP server."""
+
+    language: str
+    command: str = ""
+    status: LspServerStatus = LspServerStatus.DISCONNECTED
+    capabilities: dict[str, Any] = field(default_factory=dict)
+    root_uri: str = ""
+    error_message: str = ""
+
+
+# ---------------------------------------------------------------------------
+# LSP JSON-RPC client
+# ---------------------------------------------------------------------------
+
+class LspClient:
+    """JSON-RPC client for a single LSP server process.
+
+    Communicates via stdin/stdout using Content-Length headers.
+    """
+
+    def __init__(self, language: str, command: str, args: list[str] | None = None) -> None:
+        self.language = language
+        self.command = command
+        self.args = args or []
+        self._process: asyncio.subprocess.Process | None = None
+        self._request_id = 0
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._read_task: asyncio.Task[None] | None = None
+        self._capabilities: dict[str, Any] = {}
+
+    async def start(self, root_uri: str = "") -> bool:
+        """Start the LSP server process and initialize."""
+        try:
+            self._process = await asyncio.create_subprocess_exec(
+                self.command, *self.args,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+        except (FileNotFoundError, OSError) as exc:
+            logger.error("Failed to start LSP server %s: %s", self.command, exc)
+            return False
+
+        self._read_task = asyncio.create_task(self._read_loop())
+
+        # Send initialize request
+        result = await self._request("initialize", {
+            "processId": None,
+            "rootUri": root_uri,
+            "capabilities": {
+                "textDocument": {
+                    "completion": {"completionItem": {"snippetSupport": False}},
+                    "hover": {"contentFormat": ["plaintext"]},
+                    "definition": {},
+                    "references": {},
+                    "documentSymbol": {},
+                    "formatting": {},
+                    "publishDiagnostics": {},
+                },
+            },
+        })
+
+        if result:
+            self._capabilities = result.get("capabilities", {})
+
+        # Send initialized notification
+        await self._notify("initialized", {})
+        return True
+
+    async def get_diagnostics(self, uri: str) -> list[LspDiagnostic]:
+        """Get diagnostics for a document. Note: LSP pushes diagnostics, this is a placeholder."""
+        return []
+
+    async def hover(self, uri: str, line: int, character: int) -> LspHoverResult | None:
+        """Get hover information at a position."""
+        result = await self._request("textDocument/hover", {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+        })
+        if not result or "contents" not in result:
+            return None
+
+        contents = result["contents"]
+        if isinstance(contents, str):
+            return LspHoverResult(content=contents)
+        if isinstance(contents, dict):
+            return LspHoverResult(
+                content=contents.get("value", ""),
+                language=contents.get("language", ""),
+            )
+        return None
+
+    async def definition(self, uri: str, line: int, character: int) -> list[LspLocation]:
+        """Go to definition."""
+        result = await self._request("textDocument/definition", {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+        })
+        return self._parse_locations(result)
+
+    async def references(self, uri: str, line: int, character: int) -> list[LspLocation]:
+        """Find all references."""
+        result = await self._request("textDocument/references", {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+            "context": {"includeDeclaration": True},
+        })
+        return self._parse_locations(result)
+
+    async def completion(self, uri: str, line: int, character: int) -> list[LspCompletionItem]:
+        """Get completions at a position."""
+        result = await self._request("textDocument/completion", {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+        })
+        if not result:
+            return []
+
+        items = result.get("items", []) if isinstance(result, dict) else result
+        completions = []
+        for item in items[:50]:  # Limit
+            completions.append(LspCompletionItem(
+                label=item.get("label", ""),
+                kind=str(item.get("kind", "")),
+                detail=item.get("detail", ""),
+                insert_text=item.get("insertText", item.get("label", "")),
+                sort_text=item.get("sortText", ""),
+            ))
+        return completions
+
+    async def document_symbols(self, uri: str) -> list[LspSymbol]:
+        """Get symbols in a document."""
+        result = await self._request("textDocument/documentSymbol", {
+            "textDocument": {"uri": uri},
+        })
+        if not result:
+            return []
+
+        symbols = []
+        for sym in result:
+            location = sym.get("location", {})
+            range_ = location.get("range", sym.get("range", {}))
+            start = range_.get("start", {})
+            symbols.append(LspSymbol(
+                name=sym.get("name", ""),
+                kind=str(sym.get("kind", "")),
+                path=location.get("uri", uri),
+                line=start.get("line", 0),
+                character=start.get("character", 0),
+                container_name=sym.get("containerName", ""),
+            ))
+        return symbols
+
+    async def shutdown(self) -> None:
+        """Shutdown the LSP server."""
+        if self._process:
+            await self._request("shutdown", None)
+            await self._notify("exit", None)
+            if self._read_task:
+                self._read_task.cancel()
+            try:
+                self._process.terminate()
+                await asyncio.wait_for(self._process.wait(), timeout=5.0)
+            except (asyncio.TimeoutError, ProcessLookupError):
+                self._process.kill()
+
+    @staticmethod
+    def _parse_locations(result: Any) -> list[LspLocation]:
+        if not result:
+            return []
+        locs = result if isinstance(result, list) else [result]
+        locations = []
+        for loc in locs:
+            uri = loc.get("uri", "")
+            range_ = loc.get("range", {})
+            start = range_.get("start", {})
+            end = range_.get("end", {})
+            locations.append(LspLocation(
+                path=uri,
+                line=start.get("line", 0),
+                character=start.get("character", 0),
+                end_line=end.get("line"),
+                end_character=end.get("character"),
+            ))
+        return locations
+
+    def _next_id(self) -> int:
+        self._request_id += 1
+        return self._request_id
+
+    async def _request(self, method: str, params: Any) -> Any:
+        if not self._process or not self._process.stdin:
+            return None
+        req_id = self._next_id()
+        msg = {"jsonrpc": "2.0", "id": req_id, "method": method, "params": params}
+
+        future: asyncio.Future[dict[str, Any]] = asyncio.get_event_loop().create_future()
+        self._pending[req_id] = future
+
+        await self._write(msg)
+
+        try:
+            response = await asyncio.wait_for(future, timeout=10.0)
+            return response.get("result")
+        except asyncio.TimeoutError:
+            self._pending.pop(req_id, None)
+            return None
+
+    async def _notify(self, method: str, params: Any) -> None:
+        if not self._process or not self._process.stdin:
+            return
+        msg: dict[str, Any] = {"jsonrpc": "2.0", "method": method}
+        if params is not None:
+            msg["params"] = params
+        await self._write(msg)
+
+    async def _write(self, msg: dict[str, Any]) -> None:
+        assert self._process and self._process.stdin
+        content = json.dumps(msg)
+        header = f"Content-Length: {len(content)}\r\n\r\n"
+        self._process.stdin.write((header + content).encode())
+        await self._process.stdin.drain()
+
+    async def _read_loop(self) -> None:
+        assert self._process and self._process.stdout
+        buffer = b""
+        while True:
+            try:
+                chunk = await self._process.stdout.read(4096)
+                if not chunk:
+                    break
+                buffer += chunk
+
+                while b"\r\n\r\n" in buffer:
+                    header_end = buffer.index(b"\r\n\r\n")
+                    header = buffer[:header_end].decode()
+                    content_length = 0
+                    for line in header.split("\r\n"):
+                        if line.lower().startswith("content-length:"):
+                            content_length = int(line.split(":")[1].strip())
+
+                    body_start = header_end + 4
+                    if len(buffer) < body_start + content_length:
+                        break
+
+                    body = buffer[body_start:body_start + content_length].decode()
+                    buffer = buffer[body_start + content_length:]
+
+                    try:
+                        data = json.loads(body)
+                        msg_id = data.get("id")
+                        if msg_id is not None and msg_id in self._pending:
+                            future = self._pending.pop(msg_id)
+                            if not future.done():
+                                future.set_result(data)
+                    except json.JSONDecodeError:
+                        pass
+            except asyncio.CancelledError:
+                break
+            except Exception as exc:
+                logger.error("LSP read error: %s", exc)
+                break
+
+
+# ---------------------------------------------------------------------------
+# LSP Registry
+# ---------------------------------------------------------------------------
+
+class LspRegistry:
+    """Registry of connected LSP servers.
+
+    Maps to: rust/crates/runtime/src/lsp_client.rs::LspRegistry
+    """
+
+    def __init__(self) -> None:
+        self._clients: dict[str, LspClient] = {}
+        self._server_info: dict[str, LspServerInfo] = {}
+        self._diagnostics: list[LspDiagnostic] = []
+
+    async def connect(
+        self, language: str, command: str, args: list[str] | None = None, root_uri: str = "",
+    ) -> bool:
+        """Start and connect to an LSP server."""
+        client = LspClient(language=language, command=command, args=args)
+        success = await client.start(root_uri=root_uri)
+
+        info = LspServerInfo(
+            language=language,
+            command=command,
+            status=LspServerStatus.CONNECTED if success else LspServerStatus.ERROR,
+            root_uri=root_uri,
+        )
+        self._server_info[language] = info
+
+        if success:
+            self._clients[language] = client
+        return success
+
+    def get_client(self, language: str) -> LspClient | None:
+        return self._clients.get(language)
+
+    def get_status(self, language: str) -> LspServerStatus:
+        info = self._server_info.get(language)
+        return info.status if info else LspServerStatus.DISCONNECTED
+
+    def all_servers(self) -> dict[str, LspServerInfo]:
+        return dict(self._server_info)
+
+    def connected_languages(self) -> list[str]:
+        return [lang for lang, info in self._server_info.items()
+                if info.status == LspServerStatus.CONNECTED]
+
+    def add_diagnostics(self, diagnostics: list[LspDiagnostic]) -> None:
+        self._diagnostics.extend(diagnostics)
+
+    def get_diagnostics(self, path: str | None = None) -> list[LspDiagnostic]:
+        if path is None:
+            return list(self._diagnostics)
+        return [d for d in self._diagnostics if d.path == path]
+
+    def clear_diagnostics(self, path: str | None = None) -> None:
+        if path is None:
+            self._diagnostics.clear()
+        else:
+            self._diagnostics = [d for d in self._diagnostics if d.path != path]
+
+    async def shutdown_all(self) -> None:
+        for client in self._clients.values():
+            await client.shutdown()
+        self._clients.clear()
+        for info in self._server_info.values():
+            info.status = LspServerStatus.DISCONNECTED