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

ripperdoc/utils/git_utils.py

@@ -42,10 +42,10 @@ 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():
@@ -57,7 +57,7 @@ def read_gitignore_patterns(path: Path) -> List[str]:
                             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():
@@ -69,11 +69,11 @@ def read_gitignore_patterns(path: Path) -> List[str]:
                             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():
@@ -85,39 +85,39 @@ def read_gitignore_patterns(path: Path) -> List[str]:
                         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, 
+    root_path: Path,
     user_ignore_patterns: Optional[List[str]] = None,
-    include_gitignore: bool = True
+    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:
@@ -125,7 +125,7 @@ def build_ignore_patterns_map(
             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)
@@ -134,31 +134,29 @@ def build_ignore_patterns_map(
             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]]
+    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
@@ -166,14 +164,14 @@ def should_ignore_path(
                 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):
+                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):
+                if fnmatch.fnmatch(rel_path, pattern) or fnmatch.fnmatch(rel_path_dir, pattern):
                     return True
-    
+
     return False
 
 
@@ -181,10 +179,10 @@ 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(
@@ -194,25 +192,25 @@ def get_git_status_files(root_path: Path) -> Tuple[List[str], List[str]]:
             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
 
 
@@ -220,7 +218,7 @@ 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"],
@@ -233,7 +231,7 @@ def get_current_git_branch(root_path: Path) -> Optional[str]:
             return result.stdout.strip()
     except (subprocess.SubprocessError, FileNotFoundError):
         pass
-    
+
     return None
 
 
@@ -241,7 +239,7 @@ 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"],
@@ -254,7 +252,7 @@ def get_git_commit_hash(root_path: Path) -> Optional[str]:
             return result.stdout.strip()[:8]  # Short hash
     except (subprocess.SubprocessError, FileNotFoundError):
         pass
-    
+
     return None
 
 
@@ -262,7 +260,7 @@ 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"],

ripperdoc/utils/json_utils.py

@@ -12,8 +12,7 @@ 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.
-    """
+    """Best-effort JSON.parse wrapper that returns None on failure."""
     if not json_text:
         return None
     try:

ripperdoc/utils/log.py

@@ -54,9 +54,7 @@ class StructuredFormatter(logging.Formatter):
         }
         if extras:
             try:
-                serialized = json.dumps(
-                    extras, sort_keys=True, ensure_ascii=True, default=str
-                )
+                serialized = json.dumps(extras, sort_keys=True, ensure_ascii=True, default=str)
             except Exception:
                 serialized = str(extras)
             return f"{message} | {serialized}"
@@ -103,7 +101,8 @@ class RipperdocLogger:
                 # 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)
+        # Use UTF-8 to avoid Windows code page encoding errors when logs contain non-ASCII text.
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
         file_handler.setLevel(logging.DEBUG)
         file_formatter = StructuredFormatter("%(asctime)s [%(levelname)s] %(message)s")
         file_handler.setFormatter(file_formatter)

ripperdoc/utils/mcp.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import contextvars
 import json
+import shlex
 from contextlib import AsyncExitStack
 from dataclasses import dataclass, field, replace
 from pathlib import Path
@@ -12,16 +13,16 @@ from typing import Any, Dict, List, Optional
 
 from ripperdoc import __version__
 from ripperdoc.utils.log import get_logger
-from ripperdoc.utils.message_compaction import estimate_tokens_from_text
+from ripperdoc.utils.token_estimation import estimate_tokens
 
 logger = get_logger()
 
 try:
-    import mcp.types as mcp_types
-    from mcp.client.session import ClientSession
-    from mcp.client.sse import sse_client
-    from mcp.client.stdio import StdioServerParameters, stdio_client
-    from mcp.client.streamable_http import streamablehttp_client
+    import mcp.types as mcp_types  # type: ignore[import-not-found]
+    from mcp.client.session import ClientSession  # type: ignore[import-not-found]
+    from mcp.client.sse import sse_client  # type: ignore[import-not-found]
+    from mcp.client.stdio import StdioServerParameters, stdio_client  # type: ignore[import-not-found]
+    from mcp.client.streamable_http import streamablehttp_client  # type: ignore[import-not-found]
 
     MCP_AVAILABLE = True
 except Exception:  # pragma: no cover - handled gracefully at runtime
@@ -97,10 +98,48 @@ def _ensure_str_dict(raw: object) -> Dict[str, str]:
     return result
 
 
+def _normalize_command(
+    raw_command: Any, raw_args: Any
+) -> tuple[Optional[str], List[str]]:
+    """Normalize MCP server command/args.
+
+    Supports:
+    - command as list -> first element is executable, rest are args
+    - command as string with spaces -> shlex.split into executable/args (when args empty)
+    - command as plain string -> used as-is
+    """
+    args: List[str] = []
+    if isinstance(raw_args, list):
+        args = [str(a) for a in raw_args]
+
+    # Command provided as list: treat first token as command.
+    if isinstance(raw_command, list):
+        tokens = [str(t) for t in raw_command if str(t)]
+        if not tokens:
+            return None, args
+        return tokens[0], tokens[1:] + args
+
+    if not isinstance(raw_command, str):
+        return None, args
+
+    command_str = raw_command.strip()
+    if not command_str:
+        return None, args
+
+    if not args and (" " in command_str or "\t" in command_str):
+        try:
+            tokens = shlex.split(command_str)
+        except ValueError:
+            tokens = [command_str]
+        if tokens:
+            return tokens[0], tokens[1:]
+
+    return command_str, args
+
+
 def _parse_server(name: str, raw: Dict[str, Any]) -> McpServerInfo:
     server_type = str(raw.get("type") or raw.get("transport") or "").strip().lower()
-    command = raw.get("command")
-    args = raw.get("args") if isinstance(raw.get("args"), list) else []
+    command, args = _normalize_command(raw.get("command"), raw.get("args"))
     url = str(raw.get("url") or raw.get("uri") or "").strip() or None
 
     if not server_type:
@@ -121,7 +160,7 @@ def _parse_server(name: str, raw: Dict[str, Any]) -> McpServerInfo:
         type=server_type,
         url=url,
         description=description,
-        command=str(command) if isinstance(command, str) else None,
+        command=command,
         args=[str(a) for a in args] if args else [],
         env=env,
         headers=headers,
@@ -482,7 +521,7 @@ def format_mcp_instructions(servers: List[McpServerInfo]) -> str:
 def estimate_mcp_tokens(servers: List[McpServerInfo]) -> int:
     """Estimate token usage for MCP instructions."""
     mcp_text = format_mcp_instructions(servers)
-    return estimate_tokens_from_text(mcp_text)
+    return estimate_tokens(mcp_text)
 
 
 __all__ = [

ripperdoc/utils/memory.py

@@ -72,9 +72,7 @@ def _read_file_with_type(file_path: Path, file_type: str) -> Optional[MemoryFile
         content = file_path.read_text(encoding="utf-8", errors="ignore")
         return MemoryFile(path=str(file_path), type=file_type, content=content)
     except PermissionError:
-        logger.exception(
-            "[memory] Permission error reading file", extra={"path": str(file_path)}
-        )
+        logger.exception("[memory] Permission error reading file", extra={"path": str(file_path)})
         return None
     except OSError:
         logger.exception("[memory] OS error reading file", extra={"path": str(file_path)})

ripperdoc/utils/message_compaction.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 import json
-import math
 import os
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Union
 
 from ripperdoc.core.config import GlobalConfig, ModelProfile, get_global_config
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.token_estimation import estimate_tokens
 from ripperdoc.utils.messages import (
     AssistantMessage,
     MessageContent,
@@ -140,10 +140,8 @@ def _parse_truthy_env_value(value: Optional[str]) -> bool:
 
 
 def estimate_tokens_from_text(text: str) -> int:
-    """Rough token estimate using a 4-characters-per-token rule."""
-    if not text:
-        return 0
-    return max(1, math.ceil(len(text) / 4))
+    """Estimate token count using shared token estimation helper."""
+    return estimate_tokens(text)
 
 
 def _stringify_content(content: Union[str, List[MessageContent], None]) -> str:
@@ -402,9 +400,7 @@ def find_latest_assistant_usage_tokens(
             if tokens > 0:
                 return tokens
         except Exception:
-            logger.debug(
-                "[message_compaction] Failed to parse usage tokens", exc_info=True
-            )
+            logger.debug("[message_compaction] Failed to parse usage tokens", exc_info=True)
             continue
     return 0
 
@@ -441,9 +437,7 @@ def _run_cleanup_callbacks() -> None:
         try:
             callback()
         except Exception as exc:
-            logger.debug(
-                f"[message_compaction] Cleanup callback failed: {exc}", exc_info=True
-            )
+            logger.debug(f"[message_compaction] Cleanup callback failed: {exc}", exc_info=True)
 
 
 def _normalize_tool_use_id(block: Any) -> str:

ripperdoc/utils/messages.py

@@ -31,7 +31,7 @@ class MessageContent(BaseModel):
     id: Optional[str] = None
     tool_use_id: Optional[str] = None
     name: Optional[str] = None
-    input: Optional[Dict[str, Any]] = None
+    input: Optional[Dict[str, object]] = None
     is_error: Optional[bool] = None
 
 
@@ -120,7 +120,7 @@ class Message(BaseModel):
     content: Union[str, List[MessageContent]]
     uuid: str = ""
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -132,9 +132,9 @@ class UserMessage(BaseModel):
     type: str = "user"
     message: Message
     uuid: str = ""
-    tool_use_result: Optional[Any] = None
+    tool_use_result: Optional[object] = None
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -150,7 +150,7 @@ class AssistantMessage(BaseModel):
     duration_ms: float = 0.0
     is_api_error_message: bool = False
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -167,14 +167,14 @@ class ProgressMessage(BaseModel):
     sibling_tool_use_ids: set[str] = set()
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
 
 
 def create_user_message(
-    content: Union[str, List[Dict[str, Any]]], tool_use_result: Optional[Any] = None
+    content: Union[str, List[Dict[str, Any]]], tool_use_result: Optional[object] = None
 ) -> UserMessage:
     """Create a user message."""
     if isinstance(content, str):
@@ -371,9 +371,7 @@ def normalize_messages_for_api(
                     api_blocks.append(_content_block_to_api(block))
                 normalized.append({"role": "user", "content": api_blocks})
             else:
-                normalized.append(
-                    {"role": "user", "content": user_content}  # type: ignore
-                )
+                normalized.append({"role": "user", "content": user_content})  # type: ignore
         elif msg_type == "assistant":
             asst_content = _msg_content(msg)
             if isinstance(asst_content, list):
@@ -428,9 +426,7 @@ def normalize_messages_for_api(
                     api_blocks.append(_content_block_to_api(block))
                 normalized.append({"role": "assistant", "content": api_blocks})
             else:
-                normalized.append(
-                    {"role": "assistant", "content": asst_content}  # type: ignore
-                )
+                normalized.append({"role": "assistant", "content": asst_content})  # type: ignore
 
     logger.debug(
         f"[normalize_messages_for_api] protocol={protocol} tool_mode={effective_tool_mode} "

ripperdoc/utils/output_utils.py

@@ -151,9 +151,7 @@ def truncate_output(text: str, max_chars: int = MAX_OUTPUT_CHARS) -> dict[str, A
         available = max(0, max_chars - len(marker))
         keep_start = min(TRUNCATE_KEEP_START, available // 2)
         keep_end = min(TRUNCATE_KEEP_END, available - keep_start)
-        marker = _choose_marker(
-            max(0, original_length - (keep_start + keep_end)), max_chars
-        )
+        marker = _choose_marker(max(0, original_length - (keep_start + keep_end)), max_chars)
 
     available = max(0, max_chars - len(marker))
     # Ensure kept sections fit the final budget; trim end first, then start if needed.

ripperdoc/utils/prompt.py

@@ -0,0 +1,17 @@
+"""Prompt helpers for interactive input."""
+
+from getpass import getpass
+
+
+def prompt_secret(prompt_text: str, prompt_suffix: str = ": ") -> str:
+    """Prompt for sensitive input, masking characters when possible.
+
+    Falls back to getpass (no echo) if prompt_toolkit is unavailable.
+    """
+    full_prompt = f"{prompt_text}{prompt_suffix}"
+    try:
+        from prompt_toolkit import prompt as pt_prompt
+
+        return pt_prompt(full_prompt, is_password=True)
+    except Exception:
+        return getpass(full_prompt)

ripperdoc/utils/session_usage.py

@@ -17,6 +17,7 @@ class ModelUsage:
     cache_creation_input_tokens: int = 0
     requests: int = 0
     duration_ms: float = 0.0
+    cost_usd: float = 0.0
 
 
 @dataclass
@@ -49,6 +50,10 @@ class SessionUsage:
     def total_duration_ms(self) -> float:
         return sum(usage.duration_ms for usage in self.models.values())
 
+    @property
+    def total_cost_usd(self) -> float:
+        return sum(usage.cost_usd for usage in self.models.values())
+
 
 _SESSION_USAGE = SessionUsage()
 
@@ -76,6 +81,7 @@ def record_usage(
     cache_read_input_tokens: int = 0,
     cache_creation_input_tokens: int = 0,
     duration_ms: float = 0.0,
+    cost_usd: float = 0.0,
 ) -> None:
     """Record a single model invocation."""
     global _SESSION_USAGE
@@ -88,6 +94,7 @@ def record_usage(
     usage.cache_creation_input_tokens += _as_int(cache_creation_input_tokens)
     usage.duration_ms += float(duration_ms) if duration_ms and duration_ms > 0 else 0.0
     usage.requests += 1
+    usage.cost_usd += float(cost_usd) if cost_usd and cost_usd > 0 else 0.0
 
 
 def get_session_usage() -> SessionUsage: