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

ripperdoc/tools/todo_tool.py

@@ -361,9 +361,7 @@ class TodoWriteTool(Tool[TodoWriteToolInput, TodoToolOutput]):
             )
             yield ToolResult(data=output, result_for_assistant=result_text)
         except Exception as exc:
-            logger.exception(
-                "[todo_tool] Error updating todos", extra={"error": str(exc)}
-            )
+            logger.exception("[todo_tool] Error updating todos", extra={"error": str(exc)})
             error = f"Error updating todos: {exc}"
             yield ToolResult(
                 data=TodoToolOutput(

ripperdoc/tools/tool_search_tool.py

@@ -119,7 +119,9 @@ class ToolSearchTool(Tool[ToolSearchInput, ToolSearchOutput]):
     def is_concurrency_safe(self) -> bool:
         return True
 
-    def needs_permissions(self, input_data: Optional[ToolSearchInput] = None) -> bool:  # noqa: ARG002
+    def needs_permissions(
+        self, input_data: Optional[ToolSearchInput] = None
+    ) -> bool:  # noqa: ARG002
         return False
 
     async def validate_input(
@@ -280,9 +282,11 @@ class ToolSearchTool(Tool[ToolSearchInput, ToolSearchOutput]):
                     "name": name,
                     "user_facing_name": tool.user_facing_name(),
                     "description": description,
-                    "active": getattr(registry, "is_active", lambda *_: False)(name)
-                    if hasattr(registry, "is_active")
-                    else False,
+                    "active": (
+                        getattr(registry, "is_active", lambda *_: False)(name)
+                        if hasattr(registry, "is_active")
+                        else False
+                    ),
                     "deferred": name in getattr(registry, "deferred_names", set()),
                     "score": 0.0,
                 }

ripperdoc/utils/file_watch.py

@@ -0,0 +1,134 @@
+"""Lightweight file-change tracking for notifying the model about user edits."""
+
+from __future__ import annotations
+
+import difflib
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+
+@dataclass
+class FileSnapshot:
+    """Snapshot of a file read by the agent."""
+
+    content: str
+    timestamp: float
+    offset: int = 0
+    limit: Optional[int] = None
+
+
+@dataclass
+class ChangedFileNotice:
+    """Information about a file that changed after it was read."""
+
+    file_path: str
+    summary: str
+
+
+def record_snapshot(
+    file_path: str,
+    content: str,
+    cache: Dict[str, FileSnapshot],
+    *,
+    offset: int = 0,
+    limit: Optional[int] = None,
+) -> None:
+    """Store the current contents and mtime for a file."""
+    try:
+        timestamp = os.path.getmtime(file_path)
+    except OSError:
+        timestamp = 0.0
+    cache[file_path] = FileSnapshot(
+        content=content, timestamp=timestamp, offset=offset, limit=limit
+    )
+
+
+def _read_portion(file_path: str, offset: int, limit: Optional[int]) -> str:
+    with open(file_path, "r", encoding="utf-8", errors="replace") as handle:
+        lines = handle.readlines()
+    start = max(offset, 0)
+    if limit is None:
+        selected = lines[start:]
+    else:
+        selected = lines[start : start + limit]
+    return "".join(selected)
+
+
+def _build_diff_summary(old_content: str, new_content: str, file_path: str, max_lines: int) -> str:
+    diff = list(
+        difflib.unified_diff(
+            old_content.splitlines(),
+            new_content.splitlines(),
+            fromfile=file_path,
+            tofile=file_path,
+            lineterm="",
+        )
+    )
+    if not diff:
+        return "File was modified but contents appear unchanged."
+
+    # Keep the diff short to avoid flooding the model.
+    if len(diff) > max_lines:
+        diff = diff[:max_lines] + ["... (diff truncated)"]
+    return "\n".join(diff)
+
+
+def detect_changed_files(
+    cache: Dict[str, FileSnapshot], *, max_diff_lines: int = 80
+) -> List[ChangedFileNotice]:
+    """Return notices for files whose mtime increased since they were read."""
+    notices: List[ChangedFileNotice] = []
+
+    # Iterate over a static list so we can mutate cache safely.
+    for file_path, snapshot in list(cache.items()):
+        try:
+            current_mtime = os.path.getmtime(file_path)
+        except OSError:
+            notices.append(
+                ChangedFileNotice(
+                    file_path=file_path, summary="File was deleted or is no longer accessible."
+                )
+            )
+            cache.pop(file_path, None)
+            continue
+
+        if current_mtime <= snapshot.timestamp:
+            continue
+
+        try:
+            new_content = _read_portion(file_path, snapshot.offset, snapshot.limit)
+        except Exception as exc:  # pragma: no cover - best-effort telemetry
+            logger.exception(
+                "[file_watch] Failed reading changed file",
+                extra={"file_path": file_path, "error": str(exc)},
+            )
+            notices.append(
+                ChangedFileNotice(
+                    file_path=file_path,
+                    summary=f"File changed but could not be read: {exc}",
+                )
+            )
+            # Avoid spamming repeated errors by updating timestamp.
+            snapshot.timestamp = current_mtime
+            cache[file_path] = snapshot
+            continue
+
+        diff_summary = _build_diff_summary(
+            snapshot.content, new_content, file_path, max_lines=max_diff_lines
+        )
+        notices.append(ChangedFileNotice(file_path=file_path, summary=diff_summary))
+        # Update snapshot so we only notify on subsequent changes.
+        record_snapshot(
+            file_path,
+            new_content,
+            cache,
+            offset=snapshot.offset,
+            limit=snapshot.limit,
+        )
+
+    return notices

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/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

@@ -402,9 +402,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 +439,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: