@trac3er/oh-my-god 1.0.2

package/tools/git_inspector.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+Git Inspection Tools for OMG
+
+Read-only git inspection: status, log, and hunk-level diffs.
+Feature flag: OMG_GIT_TOOLS_ENABLED (default: False)
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+from typing import Any, Dict, List, Optional
+
+# Import feature flag helper
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from hooks._common import get_feature_flag
+
+
+def git_status(cwd: str = ".") -> Dict[str, Any]:
+    """
+    Get git status: staged, unstaged, untracked files and current branch.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+    
+    Returns:
+        {
+            "skipped": True  # if feature flag disabled
+        }
+        or
+        {
+            "staged": ["file1.py", "file2.py"],
+            "unstaged": ["file3.py"],
+            "untracked": ["file4.py"],
+            "branch": "main",
+            "error": None
+        }
+        or
+        {
+            "error": "git not found"
+        }
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return {"skipped": True}
+    
+    try:
+        # Get status with porcelain format
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return {"error": "git command failed"}
+        
+        staged = []
+        unstaged = []
+        untracked = []
+        
+        for line in result.stdout.split("\n"):
+            if not line:
+                continue
+            
+            status_code = line[:2]
+            file_path = line[3:]
+            
+            # First char: index (staged)
+            # Second char: working tree (unstaged)
+            if status_code[0] != " ":
+                staged.append(file_path)
+            if status_code[1] != " ":
+                unstaged.append(file_path)
+            if status_code == "??":
+                untracked.append(file_path)
+        
+        # Get current branch
+        branch_result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        branch = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
+        
+        return {
+            "staged": staged,
+            "unstaged": unstaged,
+            "untracked": untracked,
+            "branch": branch,
+            "error": None
+        }
+    
+    except FileNotFoundError:
+        return {"error": "git not found"}
+    except subprocess.TimeoutExpired:
+        return {"error": "git command timeout"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def git_log(cwd: str = ".", n: int = 10) -> List[Dict[str, Any]]:
+    """
+    Get recent N commits with hash, subject, author, and date.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+        n: Number of commits to retrieve (default: 10)
+    
+    Returns:
+        List of {hash, subject, author, date} dicts
+        Empty list if git not available or feature flag disabled
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return []
+    
+    try:
+        result = subprocess.run(
+            ["git", "log", f"--oneline", f"-n", str(n), 
+             "--format=%H|%s|%an|%ai"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return []
+        
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            
+            parts = line.split("|", 3)
+            if len(parts) == 4:
+                commits.append({
+                    "hash": parts[0],
+                    "subject": parts[1],
+                    "author": parts[2],
+                    "date": parts[3]
+                })
+        
+        return commits
+    
+    except FileNotFoundError:
+        return []
+    except subprocess.TimeoutExpired:
+        return []
+    except Exception:
+        return []
+
+
+def git_hunk(cwd: str = ".", file_path: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Get hunk-level diff for a file or all files.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+        file_path: Specific file to diff (None for all files)
+    
+    Returns:
+        List of {file, old_start, old_count, new_start, new_count, context, lines} dicts
+        Empty list if no diff or git not available or feature flag disabled
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return []
+    
+    try:
+        cmd = ["git", "diff", "--unified=3"]
+        if file_path:
+            cmd.append(file_path)
+        
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return []
+        
+        hunks = []
+        current_file = None
+        current_hunk = None
+        hunk_lines = []
+        
+        # Regex to match hunk header: @@ -a,b +c,d @@ context
+        hunk_header_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@\s*(.*)")
+        
+        for line in result.stdout.split("\n"):
+            # File header
+            if line.startswith("diff --git"):
+                # Save previous hunk if exists
+                if current_hunk and hunk_lines:
+                    current_hunk["lines"] = hunk_lines
+                    hunks.append(current_hunk)
+                    hunk_lines = []
+                    current_hunk = None
+                
+                # Extract filename from "diff --git a/file b/file"
+                parts = line.split()
+                if len(parts) >= 4:
+                    current_file = parts[3][2:]  # Remove "b/" prefix
+            
+            # Hunk header
+            elif line.startswith("@@"):
+                # Save previous hunk if exists
+                if current_hunk and hunk_lines:
+                    current_hunk["lines"] = hunk_lines
+                    hunks.append(current_hunk)
+                    hunk_lines = []
+                
+                match = hunk_header_re.match(line)
+                if match:
+                    old_start = int(match.group(1))
+                    old_count = int(match.group(2)) if match.group(2) else 1
+                    new_start = int(match.group(3))
+                    new_count = int(match.group(4)) if match.group(4) else 1
+                    context = match.group(5).strip()
+                    
+                    current_hunk = {
+                        "file": current_file,
+                        "old_start": old_start,
+                        "old_count": old_count,
+                        "new_start": new_start,
+                        "new_count": new_count,
+                        "context": context,
+                        "lines": []
+                    }
+            
+            # Hunk content
+            elif current_hunk is not None:
+                if line.startswith("+") or line.startswith("-") or line.startswith(" "):
+                    hunk_lines.append(line)
+        
+        # Save last hunk
+        if current_hunk and hunk_lines:
+            current_hunk["lines"] = hunk_lines
+            hunks.append(current_hunk)
+        
+        return hunks
+    
+    except FileNotFoundError:
+        return []
+    except subprocess.TimeoutExpired:
+        return []
+    except Exception:
+        return []
+
+
+def main():
+    """CLI entry point."""
+    if len(sys.argv) < 2:
+        print("Usage:", file=sys.stderr)
+        print("  python3 git_inspector.py --overview", file=sys.stderr)
+        print("  python3 git_inspector.py --hunk [--file <path>]", file=sys.stderr)
+        sys.exit(1)
+    
+    cwd = os.getcwd()
+    
+    if sys.argv[1] == "--overview":
+        # Return status + log
+        status = git_status(cwd)
+        log = git_log(cwd)
+        result = {
+            "status": status,
+            "log": log
+        }
+        print(json.dumps(result, indent=2))
+    
+    elif sys.argv[1] == "--hunk":
+        # Return hunk diff
+        file_path = None
+        if len(sys.argv) >= 4 and sys.argv[2] == "--file":
+            file_path = sys.argv[3]
+        
+        hunks = git_hunk(cwd, file_path)
+        result = {"hunks": hunks}
+        print(json.dumps(result, indent=2))
+    
+    else:
+        print(f"Unknown command: {sys.argv[1]}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/tools/lsp_client.py

@@ -0,0 +1,275 @@
+"""LSP client wrapper supporting stdio transport.
+
+Implements JSON-RPC 2.0 over stdio with Content-Length framing
+per the Language Server Protocol specification.
+
+Pure stdlib: subprocess, json, threading — no external dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import threading
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_CONTENT_LENGTH_HEADER = "Content-Length: "
+_HEADER_SEPARATOR = "\r\n\r\n"
+_DEFAULT_TIMEOUT = 10.0
+
+
+class LSPClient:
+    """LSP client that communicates with a language server over stdio.
+
+    When ``server_cmd`` is None the client operates in **stub mode**:
+    ``start()`` returns False, ``is_connected()`` returns False, and
+    ``send_request()`` returns None.  This allows OMG to instantiate
+    the client unconditionally — LSP is always optional.
+    """
+
+    def __init__(
+        self,
+        server_cmd: list[str] | None = None,
+        transport: str = "stdio",
+        timeout: float = _DEFAULT_TIMEOUT,
+    ) -> None:
+        if transport != "stdio":
+            raise ValueError(f"Unsupported transport: {transport!r} (only 'stdio' is supported)")
+
+        self._server_cmd = server_cmd
+        self._transport = transport
+        self._timeout = timeout
+
+        self._process: subprocess.Popen[bytes] | None = None
+        self._request_id = 0
+        self._lock = threading.Lock()
+        self._connected = False
+        self._initialized = False
+
+    def start(self) -> bool:
+        """Start the language-server process.
+
+        Returns True on success, False if no server command was
+        configured (stub mode) or if the process failed to launch.
+        """
+        if self._server_cmd is None:
+            logger.debug("LSPClient in stub mode — no server_cmd provided")
+            return False
+
+        try:
+            self._process = subprocess.Popen(
+                self._server_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self._connected = True
+            logger.info("LSP server started: %s (pid=%d)", self._server_cmd, self._process.pid)
+            return True
+        except (OSError, FileNotFoundError) as exc:
+            logger.error("Failed to start LSP server %s: %s", self._server_cmd, exc)
+            self._connected = False
+            return False
+
+    def initialize(
+        self,
+        root_uri: str,
+        capabilities: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Perform the LSP ``initialize`` handshake.
+
+        Returns the server capabilities dict, or an empty dict on
+        failure / stub mode.
+        """
+        if not self._connected:
+            return {}
+
+        params: dict[str, Any] = {
+            "processId": None,
+            "rootUri": root_uri,
+            "capabilities": capabilities or {},
+        }
+
+        result = self.send_request("initialize", params)
+        if result is None:
+            return {}
+
+        self.send_notification("initialized", {})
+        self.send_notification("initialized", {})
+        self._initialized = True
+        return result
+
+    def shutdown(self) -> None:
+        """Send ``shutdown`` then ``exit`` and tear down the process."""
+        if not self._connected or self._process is None:
+            return
+
+        try:
+            self.send_request("shutdown", {})
+            self.send_notification("exit", {})
+        except Exception:  # noqa: BLE001
+            logger.debug("Error during LSP shutdown sequence", exc_info=True)
+
+        self._cleanup_process()
+
+    def send_request(
+        self,
+        method: str,
+        params: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Send a JSON-RPC **request** (expects a response).
+
+        Returns the ``result`` field of the response, or None on
+        timeout / error / not connected.
+        """
+        if not self._connected or self._process is None:
+            return None
+
+        with self._lock:
+            self._request_id += 1
+            req_id = self._request_id
+
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "method": method,
+            "params": params,
+        }
+
+        try:
+            self._write_message(message)
+            response = self._read_message()
+        except Exception:  # noqa: BLE001
+            logger.debug("send_request(%s) failed", method, exc_info=True)
+            return None
+
+        if response is None:
+            return None
+
+        if "error" in response:
+            logger.warning(
+                "LSP error for %s: %s",
+                method,
+                response["error"],
+            )
+            return None
+
+        return response.get("result")
+
+    def send_notification(
+        self,
+        method: str,
+        params: dict[str, Any],
+    ) -> None:
+        """Send a JSON-RPC **notification** (no ``id``, no response)."""
+        if not self._connected or self._process is None:
+            return
+
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+        }
+
+        try:
+            self._write_message(message)
+        except Exception:  # noqa: BLE001
+            logger.debug("send_notification(%s) failed", method, exc_info=True)
+
+    def is_connected(self) -> bool:
+        """Return True if the server process is alive and connected."""
+        if not self._connected or self._process is None:
+            return False
+        # Poll returns None while process is still running
+        return self._process.poll() is None
+
+    @staticmethod
+    def encode_message(body: dict[str, Any]) -> bytes:
+        """Encode a JSON-RPC message with Content-Length header.
+
+        Public so tests can verify framing without a live process.
+        """
+        payload = json.dumps(body, separators=(",", ":")).encode("utf-8")
+        header = f"Content-Length: {len(payload)}\r\n\r\n".encode("ascii")
+        return header + payload
+
+    def _write_message(self, body: dict[str, Any]) -> None:
+        """Write a framed JSON-RPC message to the server's stdin."""
+        assert self._process is not None and self._process.stdin is not None
+        raw = self.encode_message(body)
+        self._process.stdin.write(raw)
+        self._process.stdin.flush()
+
+    def _read_message(self) -> dict[str, Any] | None:
+        """Read one framed JSON-RPC message from the server's stdout.
+
+        Uses a background thread + join(timeout) so we never block
+        indefinitely.
+        """
+        assert self._process is not None and self._process.stdout is not None
+
+        result_holder: list[dict[str, Any] | None] = [None]
+
+        def _reader() -> None:
+            try:
+                stdout = self._process.stdout  # type: ignore[union-attr]
+                content_length = 0
+                content_length = 0
+                while True:
+                    line = stdout.readline()
+                    if not line:
+                        return  # EOF
+                    line_str = line.decode("ascii").strip()
+                    if not line_str:
+                        break
+                    if line_str.startswith(_CONTENT_LENGTH_HEADER.strip()):
+                        content_length = int(line_str[len(_CONTENT_LENGTH_HEADER.strip()):])
+
+                if content_length == 0:
+                    return
+
+                data = stdout.read(content_length)
+                if data:
+                    result_holder[0] = json.loads(data.decode("utf-8"))
+            except Exception:  # noqa: BLE001
+                logger.debug("_reader failed", exc_info=True)
+
+        thread = threading.Thread(target=_reader, daemon=True)
+        thread.start()
+        thread.join(timeout=self._timeout)
+
+        if thread.is_alive():
+            logger.warning("LSP read timed out after %.1fs", self._timeout)
+            return None
+
+        return result_holder[0]
+
+    def _cleanup_process(self) -> None:
+        """Terminate / kill the server process and reset state."""
+        self._connected = False
+        self._initialized = False
+        if self._process is None:
+            return
+        try:
+            self._process.terminate()
+            self._process.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            self._process.kill()
+            self._process.wait(timeout=1)
+        except Exception:  # noqa: BLE001
+            pass
+        finally:
+            self._process = None
+
+    def __enter__(self) -> LSPClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.shutdown()
+
+    def __repr__(self) -> str:
+        cmd = self._server_cmd or "(stub)"
+        return f"<LSPClient cmd={cmd!r} connected={self.is_connected()}>"