ripperdoc 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

ripperdoc/utils/git_utils.py

@@ -0,0 +1,276 @@
+"""Git utilities for Ripperdoc."""
+
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import fnmatch
+
+
+def is_git_repository(path: Path) -> bool:
+    """Check if a directory is a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0 and result.stdout.strip() == "true"
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def get_git_root(path: Path) -> Optional[Path]:
+    """Get the git root directory for a given path."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return Path(result.stdout.strip())
+        return None
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+
+
+def read_gitignore_patterns(path: Path) -> List[str]:
+    """Read .gitignore patterns from a directory and its parent directories."""
+    patterns: List[str] = []
+    current = path
+    
+    # Read .gitignore from current directory up to git root
+    git_root = get_git_root(path)
+    
+    while current and (git_root is None or current.is_relative_to(git_root)):
+        gitignore_file = current / ".gitignore"
+        if gitignore_file.exists():
+            try:
+                with open(gitignore_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#"):
+                            patterns.append(line)
+            except (IOError, UnicodeDecodeError):
+                pass
+        
+        # Also check for .git/info/exclude
+        git_info_exclude = current / ".git" / "info" / "exclude"
+        if git_info_exclude.exists():
+            try:
+                with open(git_info_exclude, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#"):
+                            patterns.append(line)
+            except (IOError, UnicodeDecodeError):
+                pass
+        
+        if current.parent == current:  # Reached root
+            break
+        current = current.parent
+    
+    # Add global gitignore patterns
+    global_gitignore = Path.home() / ".gitignore"
+    if global_gitignore.exists():
+        try:
+            with open(global_gitignore, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        patterns.append(line)
+        except (IOError, UnicodeDecodeError):
+            pass
+    
+    return patterns
+
+
+def parse_gitignore_pattern(pattern: str, root_path: Path) -> Tuple[str, Optional[Path]]:
+    """Parse a gitignore pattern and return (relative_pattern, root)."""
+    pattern = pattern.strip()
+    
+    # Handle absolute paths
+    if pattern.startswith("/"):
+        return pattern[1:], root_path
+    
+    # Handle patterns relative to home directory
+    if pattern.startswith("~/"):
+        home_pattern = pattern[2:]
+        return home_pattern, Path.home()
+    
+    # Handle patterns with leading slash (relative to repository root)
+    if pattern.startswith("/"):
+        return pattern[1:], root_path
+    
+    # Default: pattern is relative to the directory containing .gitignore
+    return pattern, None
+
+
+def build_ignore_patterns_map(
+    root_path: Path, 
+    user_ignore_patterns: Optional[List[str]] = None,
+    include_gitignore: bool = True
+) -> Dict[Optional[Path], List[str]]:
+    """Build a map of ignore patterns by root directory."""
+    ignore_map: Dict[Optional[Path], List[str]] = {}
+    
+    # Add user-provided ignore patterns
+    if user_ignore_patterns:
+        for pattern in user_ignore_patterns:
+            relative_pattern, pattern_root = parse_gitignore_pattern(pattern, root_path)
+            if pattern_root not in ignore_map:
+                ignore_map[pattern_root] = []
+            ignore_map[pattern_root].append(relative_pattern)
+    
+    # Add .gitignore patterns
+    if include_gitignore and is_git_repository(root_path):
+        gitignore_patterns = read_gitignore_patterns(root_path)
+        for pattern in gitignore_patterns:
+            relative_pattern, pattern_root = parse_gitignore_pattern(pattern, root_path)
+            if pattern_root not in ignore_map:
+                ignore_map[pattern_root] = []
+            ignore_map[pattern_root].append(relative_pattern)
+    
+    return ignore_map
+
+
+def should_ignore_path(
+    path: Path, 
+    root_path: Path, 
+    ignore_map: Dict[Optional[Path], List[str]]
+) -> bool:
+    """Check if a path should be ignored based on ignore patterns."""
+    # Check against each root in the ignore map
+    for pattern_root, patterns in ignore_map.items():
+        # Determine the actual root to use for pattern matching
+        actual_root = pattern_root if pattern_root is not None else root_path
+        
+        try:
+            # Get relative path from actual_root
+            rel_path = path.relative_to(actual_root).as_posix()
+        except ValueError:
+            # Path is not under this root, skip
+            continue
+        
+        # For directories, also check with trailing slash
+        rel_path_dir = f"{rel_path}/" if path.is_dir() else rel_path
+        
+        # Check each pattern
+        for pattern in patterns:
+            # Handle directory-specific patterns
+            if pattern.endswith("/"):
+                if not path.is_dir():
+                    continue
+                pattern_without_slash = pattern[:-1]
+                if fnmatch.fnmatch(rel_path, pattern_without_slash) or \
+                   fnmatch.fnmatch(rel_path_dir, pattern):
+                    return True
+            else:
+                if fnmatch.fnmatch(rel_path, pattern) or \
+                   fnmatch.fnmatch(rel_path_dir, pattern):
+                    return True
+    
+    return False
+
+
+def get_git_status_files(root_path: Path) -> Tuple[List[str], List[str]]:
+    """Get tracked and untracked files from git status."""
+    tracked: List[str] = []
+    untracked: List[str] = []
+    
+    if not is_git_repository(root_path):
+        return tracked, untracked
+    
+    try:
+        # Get tracked files (modified, added, etc.)
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=root_path,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        
+        if result.returncode == 0:
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    status = line[:2].strip()
+                    file_path = line[3:].strip()
+                    
+                    # Remove quotes if present
+                    if file_path.startswith('"') and file_path.endswith('"'):
+                        file_path = file_path[1:-1]
+                    
+                    if status == "??":  # Untracked
+                        untracked.append(file_path)
+                    else:  # Tracked (modified, added, etc.)
+                        tracked.append(file_path)
+    
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
+    
+    return tracked, untracked
+
+
+def get_current_git_branch(root_path: Path) -> Optional[str]:
+    """Get the current git branch name."""
+    if not is_git_repository(root_path):
+        return None
+    
+    try:
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            cwd=root_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
+    
+    return None
+
+
+def get_git_commit_hash(root_path: Path) -> Optional[str]:
+    """Get the current git commit hash."""
+    if not is_git_repository(root_path):
+        return None
+    
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=root_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()[:8]  # Short hash
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
+    
+    return None
+
+
+def is_working_directory_clean(root_path: Path) -> bool:
+    """Check if the working directory is clean (no uncommitted changes)."""
+    if not is_git_repository(root_path):
+        return True
+    
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=root_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0 and not result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return True

ripperdoc/utils/json_utils.py

@@ -0,0 +1,28 @@
+"""JSON helper utilities for Ripperdoc."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+from ripperdoc.utils.log import get_logger
+
+
+logger = get_logger()
+
+
+def safe_parse_json(json_text: Optional[str], log_error: bool = True) -> Optional[Any]:
+    """Best-effort JSON.parse wrapper that returns None on failure.
+    """
+    if not json_text:
+        return None
+    try:
+        return json.loads(json_text)
+    except Exception as exc:
+        if log_error:
+            logger.debug(
+                "[json_utils] Failed to parse JSON",
+                extra={"error": str(exc), "length": len(json_text)},
+                exc_info=True,
+            )
+        return None

ripperdoc/utils/log.py

@@ -1,11 +1,66 @@
 """Logging utilities for Ripperdoc."""
 
+import json
 import logging
 import sys
 import os
-from pathlib import Path
-from typing import Optional
 from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+from ripperdoc.utils.path_utils import sanitize_project_path
+
+
+_LOG_RECORD_FIELDS = {
+    "name",
+    "msg",
+    "args",
+    "levelname",
+    "levelno",
+    "pathname",
+    "filename",
+    "module",
+    "exc_info",
+    "exc_text",
+    "stack_info",
+    "lineno",
+    "funcName",
+    "created",
+    "msecs",
+    "relativeCreated",
+    "thread",
+    "threadName",
+    "processName",
+    "process",
+    "message",
+    "asctime",
+    "stacklevel",
+}
+
+
+class StructuredFormatter(logging.Formatter):
+    """Formatter with ISO timestamps and context."""
+
+    def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
+        timestamp = datetime.utcfromtimestamp(record.created)
+        return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = super().format(record)
+        extras = {
+            key: value
+            for key, value in record.__dict__.items()
+            if key not in _LOG_RECORD_FIELDS and not key.startswith("_")
+        }
+        if extras:
+            try:
+                serialized = json.dumps(
+                    extras, sort_keys=True, ensure_ascii=True, default=str
+                )
+            except Exception:
+                serialized = str(extras)
+            return f"{message} | {serialized}"
+        return message
 
 
 class RipperdocLogger:
@@ -15,46 +70,71 @@ class RipperdocLogger:
         self.logger = logging.getLogger(name)
         level_name = os.getenv("RIPPERDOC_LOG_LEVEL", "WARNING").upper()
         level = getattr(logging, level_name, logging.WARNING)
-        self.logger.setLevel(level)
+        # Allow file handlers to capture debug logs while console respects the configured level.
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.propagate = False
+
+        # Avoid adding duplicate handlers if an existing logger is reused.
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(level)
+            console_formatter = logging.Formatter("%(levelname)s: %(message)s")
+            console_handler.setFormatter(console_formatter)
+            self.logger.addHandler(console_handler)
 
-        # Console handler
-        console_handler = logging.StreamHandler(sys.stderr)
-        console_handler.setLevel(level)
-        console_formatter = logging.Formatter("%(levelname)s: %(message)s")
-        console_handler.setFormatter(console_formatter)
-        self.logger.addHandler(console_handler)
+        self._file_handler: Optional[logging.Handler] = None
+        self._file_handler_path: Optional[Path] = None
 
-        # File handler (optional)
         if log_dir:
-            log_dir.mkdir(exist_ok=True)
+            log_dir.mkdir(parents=True, exist_ok=True)
             log_file = log_dir / f"ripperdoc_{datetime.now().strftime('%Y%m%d')}.log"
-            file_handler = logging.FileHandler(log_file)
-            file_handler.setLevel(logging.DEBUG)
-            file_formatter = logging.Formatter(
-                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            )
-            file_handler.setFormatter(file_formatter)
-            self.logger.addHandler(file_handler)
-
-    def debug(self, message: str) -> None:
+            self.attach_file_handler(log_file)
+
+    def attach_file_handler(self, log_file: Path) -> Path:
+        """Attach or replace a file handler for logging to disk."""
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        if self._file_handler and self._file_handler_path == log_file:
+            return log_file
+
+        if self._file_handler:
+            try:
+                self.logger.removeHandler(self._file_handler)
+            except Exception:
+                # Swallow errors while rotating handlers; console logging should continue.
+                self.logger.exception("[logging] Failed to remove existing file handler")
+
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = StructuredFormatter("%(asctime)s [%(levelname)s] %(message)s")
+        file_handler.setFormatter(file_formatter)
+        self.logger.addHandler(file_handler)
+        self._file_handler = file_handler
+        self._file_handler_path = log_file
+        return log_file
+
+    def debug(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log debug message."""
-        self.logger.debug(message)
+        self.logger.debug(message, *args, **kwargs)
 
-    def info(self, message: str) -> None:
+    def info(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log info message."""
-        self.logger.info(message)
+        self.logger.info(message, *args, **kwargs)
 
-    def warning(self, message: str) -> None:
+    def warning(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log warning message."""
-        self.logger.warning(message)
+        self.logger.warning(message, *args, **kwargs)
 
-    def error(self, message: str) -> None:
+    def error(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log error message."""
-        self.logger.error(message)
+        self.logger.error(message, *args, **kwargs)
 
-    def critical(self, message: str) -> None:
+    def critical(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log critical message."""
-        self.logger.critical(message)
+        self.logger.critical(message, *args, **kwargs)
+
+    def exception(self, message: str, *args: Any, **kwargs: Any) -> None:
+        """Log an exception with traceback."""
+        self.logger.exception(message, *args, **kwargs)
 
 
 # Global logger instance
@@ -69,8 +149,29 @@ def get_logger() -> RipperdocLogger:
     return _logger
 
 
+def _normalize_path_for_logs(project_path: Path) -> Path:
+    """Return the directory for log files for a given project."""
+    safe_name = sanitize_project_path(project_path)
+    return Path.home() / ".ripperdoc" / "logs" / safe_name
+
+
+def session_log_path(project_path: Path, session_id: str, when: Optional[datetime] = None) -> Path:
+    """Build the log file path for a project session."""
+    timestamp = (when or datetime.now()).strftime("%Y%m%d-%H%M%S")
+    return _normalize_path_for_logs(project_path) / f"{timestamp}-{session_id}.log"
+
+
 def init_logger(log_dir: Optional[Path] = None) -> RipperdocLogger:
     """Initialize the global logger."""
     global _logger
     _logger = RipperdocLogger(log_dir=log_dir)
     return _logger
+
+
+def enable_session_file_logging(project_path: Path, session_id: str) -> Path:
+    """Ensure the global logger writes to the session-specific log file."""
+    logger = get_logger()
+    log_file = session_log_path(project_path, session_id)
+    logger.attach_file_handler(log_file)
+    logger.debug(f"[logging] File logging enabled at {log_file}")
+    return log_file

ripperdoc/utils/mcp.py

@@ -14,6 +14,8 @@ from ripperdoc import __version__
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.message_compaction import estimate_tokens_from_text
 
+logger = get_logger()
+
 try:
     import mcp.types as mcp_types
     from mcp.client.session import ClientSession
@@ -26,9 +28,7 @@ except Exception:  # pragma: no cover - handled gracefully at runtime
     MCP_AVAILABLE = False
     ClientSession = object  # type: ignore
     mcp_types = None  # type: ignore
-
-
-logger = get_logger()
+    logger.exception("[mcp] MCP SDK not available at import time")
 
 
 @dataclass
@@ -72,9 +72,12 @@ def _load_json_file(path: Path) -> Dict[str, Any]:
     if not path.exists():
         return {}
     try:
-        return json.loads(path.read_text())
-    except (OSError, json.JSONDecodeError) as exc:
-        logger.error(f"Failed to load JSON from {path}: {exc}")
+        data = json.loads(path.read_text())
+        if isinstance(data, dict):
+            return data
+        return {}
+    except (OSError, json.JSONDecodeError):
+        logger.exception("Failed to load JSON", extra={"path": str(path)})
         return {}
 
 
@@ -86,6 +89,10 @@ def _ensure_str_dict(raw: object) -> Dict[str, str]:
         try:
             result[str(key)] = str(value)
         except Exception:
+            logger.exception(
+                "[mcp] Failed to coerce env/header value to string",
+                extra={"key": key, "value": value},
+            )
             continue
     return result
 
@@ -151,6 +158,14 @@ def _load_server_configs(project_path: Optional[Path]) -> Dict[str, McpServerInf
     for path in candidates:
         data = _load_json_file(path)
         merged.update(_parse_servers(data))
+    logger.debug(
+        "[mcp] Loaded MCP server configs",
+        extra={
+            "project_path": str(project_path),
+            "server_count": len(merged),
+            "candidates": [str(path) for path in candidates],
+        },
+    )
     return merged
 
 
@@ -165,6 +180,14 @@ class McpRuntime:
         self._closed = False
 
     async def connect(self, configs: Dict[str, McpServerInfo]) -> List[McpServerInfo]:
+        logger.info(
+            "[mcp] Connecting to MCP servers",
+            extra={
+                "project_path": str(self.project_path),
+                "server_count": len(configs),
+                "servers": list(configs.keys()),
+            },
+        )
         await self._exit_stack.__aenter__()
         if not MCP_AVAILABLE:
             for config in configs.values():
@@ -179,13 +202,21 @@ class McpRuntime:
 
         for config in configs.values():
             self.servers.append(await self._connect_server(config))
+        logger.debug(
+            "[mcp] MCP connection summary",
+            extra={
+                "connected": [s.name for s in self.servers if s.status == "connected"],
+                "failed": [s.name for s in self.servers if s.status == "failed"],
+                "unavailable": [s.name for s in self.servers if s.status == "unavailable"],
+            },
+        )
         return self.servers
 
-    async def _list_roots_callback(self, *_: Any, **__: Any):
+    async def _list_roots_callback(self, *_: Any, **__: Any) -> Optional[Any]:
         if not mcp_types:
             return None
         return mcp_types.ListRootsResult(
-            roots=[mcp_types.Root(uri=Path(self.project_path).resolve().as_uri())]
+            roots=[mcp_types.Root(uri=Path(self.project_path).resolve().as_uri())]  # type: ignore[arg-type]
         )
 
     async def _connect_server(self, config: McpServerInfo) -> McpServerInfo:
@@ -198,6 +229,15 @@ class McpRuntime:
         try:
             read_stream = None
             write_stream = None
+            logger.debug(
+                "[mcp] Connecting server",
+                extra={
+                    "server": config.name,
+                    "type": config.type,
+                    "command": config.command,
+                    "url": config.url,
+                },
+            )
 
             if config.type in ("sse", "sse-ide"):
                 if not config.url:
@@ -228,17 +268,22 @@ class McpRuntime:
                     stdio_client(stdio_params)
                 )
 
+            if read_stream is None or write_stream is None:
+                raise ValueError("Failed to create read/write streams for MCP server")
+
             session = await self._exit_stack.enter_async_context(
                 ClientSession(
                     read_stream,
                     write_stream,
-                    list_roots_callback=self._list_roots_callback,
+                    list_roots_callback=self._list_roots_callback,  # type: ignore[arg-type]
                     client_info=mcp_types.Implementation(name="ripperdoc", version=__version__),
                 )
             )
 
             init_result = await session.initialize()
             capabilities = session.get_server_capabilities()
+            if capabilities is None:
+                capabilities = mcp_types.ServerCapabilities()
 
             info.status = "connected"
             info.instructions = init_result.instructions or info.instructions
@@ -272,8 +317,21 @@ class McpRuntime:
                     for resource in resources_result.resources
                 ]
 
+            logger.info(
+                "[mcp] Connected to MCP server",
+                extra={
+                    "server": config.name,
+                    "status": info.status,
+                    "tools": len(info.tools),
+                    "resources": len(info.resources),
+                    "capabilities": list(info.capabilities.keys()),
+                },
+            )
         except Exception as exc:  # pragma: no cover - network/process errors
-            logger.error(f"Failed to connect to MCP server '{config.name}': {exc}")
+            logger.exception(
+                "Failed to connect to MCP server",
+                extra={"server": config.name, "error": str(exc)},
+            )
             info.status = "failed"
             info.error = str(exc)
 
@@ -283,6 +341,10 @@ class McpRuntime:
         if self._closed:
             return
         self._closed = True
+        logger.debug(
+            "[mcp] Shutting down MCP runtime",
+            extra={"project_path": str(self.project_path), "session_count": len(self.sessions)},
+        )
         try:
             await self._exit_stack.aclose()
         finally:
@@ -308,12 +370,23 @@ async def ensure_mcp_runtime(project_path: Optional[Path] = None) -> McpRuntime:
     runtime = _get_runtime()
     project_path = project_path or Path.cwd()
     if runtime and not runtime._closed and runtime.project_path == project_path:
+        logger.debug(
+            "[mcp] Reusing existing MCP runtime",
+            extra={
+                "project_path": str(project_path),
+                "server_count": len(runtime.servers),
+            },
+        )
         return runtime
 
     if runtime:
         await runtime.aclose()
 
     runtime = McpRuntime(project_path)
+    logger.debug(
+        "[mcp] Creating MCP runtime",
+        extra={"project_path": str(project_path)},
+    )
     configs = _load_server_configs(project_path)
     await runtime.connect(configs)
     _runtime_var.set(runtime)