deepagents 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

deepagents-cli/deepagents_cli/file_ops.py

@@ -1,347 +0,0 @@
-"""Helpers for tracking file operations and computing diffs for CLI display."""
-
-from __future__ import annotations
-
-import difflib
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Literal
-
-from deepagents.backends.utils import perform_string_replacement
-
-FileOpStatus = Literal["pending", "success", "error"]
-
-
-@dataclass
-class ApprovalPreview:
-    """Data used to render HITL previews."""
-
-    title: str
-    details: list[str]
-    diff: str | None = None
-    diff_title: str | None = None
-    error: str | None = None
-
-
-def _safe_read(path: Path) -> str | None:
-    """Read file content, returning None on failure."""
-    try:
-        return path.read_text()
-    except (OSError, UnicodeDecodeError):
-        return None
-
-
-def _count_lines(text: str) -> int:
-    """Count lines in text, treating empty strings as zero lines."""
-    if not text:
-        return 0
-    return len(text.splitlines())
-
-
-def compute_unified_diff(
-    before: str,
-    after: str,
-    display_path: str,
-    *,
-    max_lines: int | None = 800,
-) -> str | None:
-    """Compute a unified diff between before and after content."""
-    before_lines = before.splitlines()
-    after_lines = after.splitlines()
-    diff_lines = list(
-        difflib.unified_diff(
-            before_lines,
-            after_lines,
-            fromfile=f"{display_path} (before)",
-            tofile=f"{display_path} (after)",
-            lineterm="",
-        )
-    )
-    if not diff_lines:
-        return None
-    if max_lines is not None and len(diff_lines) > max_lines:
-        truncated = diff_lines[: max_lines - 1]
-        truncated.append("... (diff truncated)")
-        return "\n".join(truncated)
-    return "\n".join(diff_lines)
-
-
-@dataclass
-class FileOpMetrics:
-    """Line and byte level metrics for a file operation."""
-
-    lines_read: int = 0
-    start_line: int | None = None
-    end_line: int | None = None
-    lines_written: int = 0
-    lines_added: int = 0
-    lines_removed: int = 0
-    bytes_written: int = 0
-
-
-@dataclass
-class FileOperationRecord:
-    """Track a single filesystem tool call."""
-
-    tool_name: str
-    display_path: str
-    physical_path: Path | None
-    tool_call_id: str | None
-    args: dict[str, Any] = field(default_factory=dict)
-    status: FileOpStatus = "pending"
-    error: str | None = None
-    metrics: FileOpMetrics = field(default_factory=FileOpMetrics)
-    diff: str | None = None
-    before_content: str | None = None
-    after_content: str | None = None
-    read_output: str | None = None
-
-
-def resolve_physical_path(path_str: str | None, assistant_id: str | None) -> Path | None:
-    """Convert a virtual/relative path to a physical filesystem path."""
-    if not path_str:
-        return None
-    try:
-        if assistant_id and path_str.startswith("/memories/"):
-            agent_dir = Path.home() / ".deepagents" / assistant_id
-            suffix = path_str.removeprefix("/memories/").lstrip("/")
-            return (agent_dir / suffix).resolve()
-        path = Path(path_str)
-        if path.is_absolute():
-            return path
-        return (Path.cwd() / path).resolve()
-    except (OSError, ValueError):
-        return None
-
-
-def format_display_path(path_str: str | None) -> str:
-    """Format a path for display."""
-    if not path_str:
-        return "(unknown)"
-    try:
-        path = Path(path_str)
-        if path.is_absolute():
-            return path.name or str(path)
-        return str(path)
-    except (OSError, ValueError):
-        return str(path_str)
-
-
-def build_approval_preview(
-    tool_name: str,
-    args: dict[str, Any] | None,
-    assistant_id: str | None,
-) -> ApprovalPreview | None:
-    """Collect summary info and diff for HITL approvals."""
-    if args is None:
-        return None
-
-    path_str = str(args.get("file_path") or args.get("path") or "")
-    display_path = format_display_path(path_str)
-    physical_path = resolve_physical_path(path_str, assistant_id)
-
-    if tool_name == "write_file":
-        content = str(args.get("content", ""))
-        before = _safe_read(physical_path) if physical_path and physical_path.exists() else ""
-        after = content
-        diff = compute_unified_diff(before or "", after, display_path, max_lines=None)
-        additions = 0
-        if diff:
-            additions = sum(
-                1
-                for line in diff.splitlines()
-                if line.startswith("+") and not line.startswith("+++")
-            )
-        total_lines = _count_lines(after)
-        details = [
-            f"File: {path_str}",
-            "Action: Create new file" + (" (overwrites existing content)" if before else ""),
-            f"Lines to write: {additions or total_lines}",
-            f"Bytes to write: {len(after.encode('utf-8'))}",
-        ]
-        return ApprovalPreview(
-            title=f"Write {display_path}",
-            details=details,
-            diff=diff,
-            diff_title=f"Diff {display_path}",
-        )
-
-    if tool_name == "edit_file":
-        if physical_path is None:
-            return ApprovalPreview(
-                title=f"Update {display_path}",
-                details=[f"File: {path_str}", "Action: Replace text"],
-                error="Unable to resolve file path.",
-            )
-        before = _safe_read(physical_path)
-        if before is None:
-            return ApprovalPreview(
-                title=f"Update {display_path}",
-                details=[f"File: {path_str}", "Action: Replace text"],
-                error="Unable to read current file contents.",
-            )
-        old_string = str(args.get("old_string", ""))
-        new_string = str(args.get("new_string", ""))
-        replace_all = bool(args.get("replace_all", False))
-        replacement = perform_string_replacement(before, old_string, new_string, replace_all)
-        if isinstance(replacement, str):
-            return ApprovalPreview(
-                title=f"Update {display_path}",
-                details=[f"File: {path_str}", "Action: Replace text"],
-                error=replacement,
-            )
-        after, occurrences = replacement
-        diff = compute_unified_diff(before, after, display_path, max_lines=None)
-        additions = 0
-        deletions = 0
-        if diff:
-            additions = sum(
-                1
-                for line in diff.splitlines()
-                if line.startswith("+") and not line.startswith("+++")
-            )
-            deletions = sum(
-                1
-                for line in diff.splitlines()
-                if line.startswith("-") and not line.startswith("---")
-            )
-        details = [
-            f"File: {path_str}",
-            f"Action: Replace text ({'all occurrences' if replace_all else 'single occurrence'})",
-            f"Occurrences matched: {occurrences}",
-            f"Lines changed: +{additions} / -{deletions}",
-        ]
-        return ApprovalPreview(
-            title=f"Update {display_path}",
-            details=details,
-            diff=diff,
-            diff_title=f"Diff {display_path}",
-        )
-
-    return None
-
-
-class FileOpTracker:
-    """Collect file operation metrics during a CLI interaction."""
-
-    def __init__(self, *, assistant_id: str | None) -> None:
-        self.assistant_id = assistant_id
-        self.active: dict[str | None, FileOperationRecord] = {}
-        self.completed: list[FileOperationRecord] = []
-
-    def start_operation(
-        self, tool_name: str, args: dict[str, Any], tool_call_id: str | None
-    ) -> None:
-        if tool_name not in {"read_file", "write_file", "edit_file"}:
-            return
-        path_str = str(args.get("file_path") or args.get("path") or "")
-        display_path = format_display_path(path_str)
-        record = FileOperationRecord(
-            tool_name=tool_name,
-            display_path=display_path,
-            physical_path=resolve_physical_path(path_str, self.assistant_id),
-            tool_call_id=tool_call_id,
-            args=args,
-        )
-        if tool_name in {"write_file", "edit_file"} and record.physical_path:
-            record.before_content = _safe_read(record.physical_path) or ""
-        self.active[tool_call_id] = record
-
-    def complete_with_message(self, tool_message: Any) -> FileOperationRecord | None:
-        tool_call_id = getattr(tool_message, "tool_call_id", None)
-        record = self.active.get(tool_call_id)
-        if record is None:
-            return None
-
-        content = tool_message.content
-        if isinstance(content, list):
-            # Some tool messages may return list segments; join them for analysis.
-            joined = []
-            for item in content:
-                if isinstance(item, str):
-                    joined.append(item)
-                else:
-                    joined.append(str(item))
-            content_text = "\n".join(joined)
-        else:
-            content_text = str(content) if content is not None else ""
-
-        if getattr(
-            tool_message, "status", "success"
-        ) != "success" or content_text.lower().startswith("error"):
-            record.status = "error"
-            record.error = content_text
-            self._finalize(record)
-            return record
-
-        record.status = "success"
-
-        if record.tool_name == "read_file":
-            record.read_output = content_text
-            lines = _count_lines(content_text)
-            record.metrics.lines_read = lines
-            offset = record.args.get("offset")
-            limit = record.args.get("limit")
-            if isinstance(offset, int):
-                record.metrics.start_line = offset + 1
-                if lines:
-                    record.metrics.end_line = offset + lines
-            elif lines:
-                record.metrics.start_line = 1
-                record.metrics.end_line = lines
-            if isinstance(limit, int) and lines > limit:
-                record.metrics.end_line = (record.metrics.start_line or 1) + limit - 1
-        else:
-            self._populate_after_content(record)
-            if record.after_content is None:
-                record.status = "error"
-                record.error = "Could not read updated file content."
-                self._finalize(record)
-                return record
-            record.metrics.lines_written = _count_lines(record.after_content)
-            before_lines = _count_lines(record.before_content or "")
-            diff = compute_unified_diff(
-                record.before_content or "",
-                record.after_content,
-                record.display_path,
-                max_lines=None,
-            )
-            record.diff = diff
-            if diff:
-                additions = sum(
-                    1
-                    for line in diff.splitlines()
-                    if line.startswith("+") and not line.startswith("+++")
-                )
-                deletions = sum(
-                    1
-                    for line in diff.splitlines()
-                    if line.startswith("-") and not line.startswith("---")
-                )
-                record.metrics.lines_added = additions
-                record.metrics.lines_removed = deletions
-            elif record.tool_name == "write_file" and (record.before_content or "") == "":
-                record.metrics.lines_added = record.metrics.lines_written
-            record.metrics.bytes_written = len(record.after_content.encode("utf-8"))
-            if record.diff is None and (record.before_content or "") != record.after_content:
-                record.diff = compute_unified_diff(
-                    record.before_content or "",
-                    record.after_content,
-                    record.display_path,
-                    max_lines=None,
-                )
-            if record.diff is None and before_lines != record.metrics.lines_written:
-                record.metrics.lines_added = max(record.metrics.lines_written - before_lines, 0)
-
-        self._finalize(record)
-        return record
-
-    def _populate_after_content(self, record: FileOperationRecord) -> None:
-        if record.physical_path is None:
-            record.after_content = None
-            return
-        record.after_content = _safe_read(record.physical_path)
-
-    def _finalize(self, record: FileOperationRecord) -> None:
-        self.completed.append(record)
-        self.active.pop(record.tool_call_id, None)

deepagents-cli/deepagents_cli/input.py

@@ -1,270 +0,0 @@
-"""Input handling, completers, and prompt session for the CLI."""
-
-import os
-import re
-from collections.abc import Callable
-from pathlib import Path
-
-from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import (
-    Completer,
-    Completion,
-    PathCompleter,
-    merge_completers,
-)
-from prompt_toolkit.document import Document
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.key_binding import KeyBindings
-
-from .config import COLORS, COMMANDS, SessionState, console
-
-# Regex patterns for context-aware completion
-AT_MENTION_RE = re.compile(r"@(?P<path>(?:[^\s@]|(?<=\\)\s)*)$")
-SLASH_COMMAND_RE = re.compile(r"^/(?P<command>[a-z]*)$")
-
-
-class FilePathCompleter(Completer):
-    """Activate filesystem completion only when cursor is after '@'."""
-
-    def __init__(self):
-        self.path_completer = PathCompleter(
-            expanduser=True,
-            min_input_len=0,
-            only_directories=False,
-        )
-
-    def get_completions(self, document, complete_event):
-        """Get file path completions when @ is detected."""
-        text = document.text_before_cursor
-
-        # Use regex to detect @path pattern at end of line
-        m = AT_MENTION_RE.search(text)
-        if not m:
-            return  # Not in an @path context
-
-        path_fragment = m.group("path")
-
-        # Unescape the path for PathCompleter (it doesn't understand escape sequences)
-        unescaped_fragment = path_fragment.replace("\\ ", " ")
-
-        # Strip trailing backslash if present (user is in the process of typing an escape)
-        unescaped_fragment = unescaped_fragment.removesuffix("\\")
-
-        # Create temporary document for the unescaped path fragment
-        temp_doc = Document(text=unescaped_fragment, cursor_position=len(unescaped_fragment))
-
-        # Get completions from PathCompleter and use its start_position
-        # PathCompleter returns suffix text with start_position=0 (insert at cursor)
-        for comp in self.path_completer.get_completions(temp_doc, complete_event):
-            # Add trailing / for directories so users can continue navigating
-            completed_path = Path(unescaped_fragment + comp.text).expanduser()
-            # Re-escape spaces in the completion text for the command line
-            completion_text = comp.text.replace(" ", "\\ ")
-            if completed_path.is_dir() and not completion_text.endswith("/"):
-                completion_text += "/"
-
-            yield Completion(
-                text=completion_text,
-                start_position=comp.start_position,  # Use PathCompleter's position (usually 0)
-                display=comp.display,
-                display_meta=comp.display_meta,
-            )
-
-
-class CommandCompleter(Completer):
-    """Activate command completion only when line starts with '/'."""
-
-    def get_completions(self, document, complete_event):
-        """Get command completions when / is at the start."""
-        text = document.text_before_cursor
-
-        # Use regex to detect /command pattern at start of line
-        m = SLASH_COMMAND_RE.match(text)
-        if not m:
-            return  # Not in a /command context
-
-        command_fragment = m.group("command")
-
-        # Match commands that start with the fragment (case-insensitive)
-        for cmd_name, cmd_desc in COMMANDS.items():
-            if cmd_name.startswith(command_fragment.lower()):
-                yield Completion(
-                    text=cmd_name,
-                    start_position=-len(command_fragment),  # Fixed position for original document
-                    display=cmd_name,
-                    display_meta=cmd_desc,
-                )
-
-
-def parse_file_mentions(text: str) -> tuple[str, list[Path]]:
-    """Extract @file mentions and return cleaned text with resolved file paths."""
-    pattern = r"@((?:[^\s@]|(?<=\\)\s)+)"  # Match @filename, allowing escaped spaces
-    matches = re.findall(pattern, text)
-
-    files = []
-    for match in matches:
-        # Remove escape characters
-        clean_path = match.replace("\\ ", " ")
-        path = Path(clean_path).expanduser()
-
-        # Try to resolve relative to cwd
-        if not path.is_absolute():
-            path = Path.cwd() / path
-
-        try:
-            path = path.resolve()
-            if path.exists() and path.is_file():
-                files.append(path)
-            else:
-                console.print(f"[yellow]Warning: File not found: {match}[/yellow]")
-        except Exception as e:
-            console.print(f"[yellow]Warning: Invalid path {match}: {e}[/yellow]")
-
-    return text, files
-
-
-def get_bottom_toolbar(
-    session_state: SessionState, session_ref: dict
-) -> Callable[[], list[tuple[str, str]]]:
-    """Return toolbar function that shows auto-approve status and BASH MODE."""
-
-    def toolbar() -> list[tuple[str, str]]:
-        parts = []
-
-        # Check if we're in BASH mode (input starts with !)
-        try:
-            session = session_ref.get("session")
-            if session:
-                current_text = session.default_buffer.text
-                if current_text.startswith("!"):
-                    parts.append(("bg:#ff1493 fg:#ffffff bold", " BASH MODE "))
-                    parts.append(("", " | "))
-        except (AttributeError, TypeError):
-            # Silently ignore - toolbar is non-critical and called frequently
-            pass
-
-        # Base status message
-        if session_state.auto_approve:
-            base_msg = "auto-accept ON (CTRL+T to toggle)"
-            base_class = "class:toolbar-green"
-        else:
-            base_msg = "manual accept (CTRL+T to toggle)"
-            base_class = "class:toolbar-orange"
-
-        parts.append((base_class, base_msg))
-
-        return parts
-
-    return toolbar
-
-
-def create_prompt_session(assistant_id: str, session_state: SessionState) -> PromptSession:
-    """Create a configured PromptSession with all features."""
-    # Set default editor if not already set
-    if "EDITOR" not in os.environ:
-        os.environ["EDITOR"] = "nano"
-
-    # Create key bindings
-    kb = KeyBindings()
-
-    # Bind Ctrl+T to toggle auto-approve
-    @kb.add("c-t")
-    def _(event):
-        """Toggle auto-approve mode."""
-        session_state.toggle_auto_approve()
-        # Force UI refresh to update toolbar
-        event.app.invalidate()
-
-    # Bind regular Enter to submit (intuitive behavior)
-    @kb.add("enter")
-    def _(event):
-        """Enter submits the input, unless completion menu is active."""
-        buffer = event.current_buffer
-
-        # If completion menu is showing, apply the current completion
-        if buffer.complete_state:
-            # Get the current completion (the highlighted one)
-            current_completion = buffer.complete_state.current_completion
-
-            # If no completion is selected (user hasn't navigated), select and apply the first one
-            if not current_completion and buffer.complete_state.completions:
-                # Move to the first completion
-                buffer.complete_next()
-                # Now apply it
-                buffer.apply_completion(buffer.complete_state.current_completion)
-            elif current_completion:
-                # Apply the already-selected completion
-                buffer.apply_completion(current_completion)
-            else:
-                # No completions available, close menu
-                buffer.complete_state = None
-        # Don't submit if buffer is empty or only whitespace
-        elif buffer.text.strip():
-            # Normal submit
-            buffer.validate_and_handle()
-            # If empty, do nothing (don't submit)
-
-    # Alt+Enter for newlines (press ESC then Enter, or Option+Enter on Mac)
-    @kb.add("escape", "enter")
-    def _(event):
-        """Alt+Enter inserts a newline for multi-line input."""
-        event.current_buffer.insert_text("\n")
-
-    # Ctrl+E to open in external editor
-    @kb.add("c-e")
-    def _(event):
-        """Open the current input in an external editor (nano by default)."""
-        event.current_buffer.open_in_editor()
-
-    # Backspace handler to retrigger completions after deletion
-    @kb.add("backspace")
-    def _(event):
-        """Handle backspace and retrigger completion if in @ or / context."""
-        buffer = event.current_buffer
-
-        # Perform the normal backspace action
-        buffer.delete_before_cursor(count=1)
-
-        # Check if we're in a completion context (@ or /)
-        text = buffer.document.text_before_cursor
-        if AT_MENTION_RE.search(text) or SLASH_COMMAND_RE.match(text):
-            # Retrigger completion
-            buffer.start_completion(select_first=False)
-
-    from prompt_toolkit.styles import Style
-
-    # Define styles for the toolbar with full-width background colors
-    toolbar_style = Style.from_dict(
-        {
-            "bottom-toolbar": "noreverse",  # Disable default reverse video
-            "toolbar-green": "bg:#10b981 #000000",  # Green for auto-accept ON
-            "toolbar-orange": "bg:#f59e0b #000000",  # Orange for manual accept
-        }
-    )
-
-    # Create session reference dict for toolbar to access session
-    session_ref = {}
-
-    # Create the session
-    session = PromptSession(
-        message=HTML(f'<style fg="{COLORS["user"]}">></style> '),
-        multiline=True,  # Keep multiline support but Enter submits
-        key_bindings=kb,
-        completer=merge_completers([CommandCompleter(), FilePathCompleter()]),
-        editing_mode=EditingMode.EMACS,
-        complete_while_typing=True,  # Show completions as you type
-        complete_in_thread=True,  # Async completion prevents menu freezing
-        mouse_support=False,
-        enable_open_in_editor=True,  # Allow Ctrl+X Ctrl+E to open external editor
-        bottom_toolbar=get_bottom_toolbar(
-            session_state, session_ref
-        ),  # Persistent status bar at bottom
-        style=toolbar_style,  # Apply toolbar styling
-        reserve_space_for_menu=7,  # Reserve space for completion menu to show 5-6 results
-    )
-
-    # Store session reference for toolbar to access
-    session_ref["session"] = session
-
-    return session