deepagents-cli 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

deepagents_cli/file_ops.py

@@ -0,0 +1,347 @@
+"""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/input.py

@@ -0,0 +1,249 @@
+"""Input handling, completers, and prompt session for the CLI."""
+
+import os
+import re
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import (
+    Completer,
+    Completion,
+    PathCompleter,
+    WordCompleter,
+    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, COMMON_BASH_COMMANDS, SessionState, console
+
+
+class FilePathCompleter(Completer):
+    """File path completer that triggers on @ symbol with case-insensitive matching."""
+
+    def __init__(self):
+        self.path_completer = PathCompleter(expanduser=True)
+
+    def get_completions(self, document, complete_event):
+        """Get file path completions when @ is detected."""
+        text = document.text_before_cursor
+
+        # Check if we're after an @ symbol
+        if "@" in text:
+            # Get the part after the last @
+            parts = text.split("@")
+            if len(parts) >= 2:
+                after_at = parts[-1]
+                # Create a document for just the path part
+                path_doc = Document(after_at, len(after_at))
+
+                # Get all completions from PathCompleter
+                all_completions = list(
+                    self.path_completer.get_completions(path_doc, complete_event)
+                )
+
+                # If user has typed something, filter case-insensitively
+                if after_at.strip():
+                    # Extract just the filename part for matching (not the full path)
+                    search_parts = after_at.split("/")
+                    search_term = search_parts[-1].lower() if search_parts else ""
+
+                    # Filter completions case-insensitively
+                    filtered_completions = [
+                        c for c in all_completions if search_term in c.text.lower()
+                    ]
+                else:
+                    # No search term, show all completions
+                    filtered_completions = all_completions
+
+                # Yield filtered completions
+                for completion in filtered_completions:
+                    yield Completion(
+                        text=completion.text,
+                        start_position=completion.start_position,
+                        display=completion.display,
+                        display_meta=completion.display_meta,
+                        style=completion.style,
+                    )
+
+
+class CommandCompleter(Completer):
+    """Command completer for / commands."""
+
+    def __init__(self):
+        self.word_completer = WordCompleter(
+            list(COMMANDS.keys()),
+            meta_dict=COMMANDS,
+            sentence=True,
+            ignore_case=True,
+        )
+
+    def get_completions(self, document, complete_event):
+        """Get command completions when / is at the start."""
+        text = document.text
+
+        # Only complete if line starts with /
+        if text.startswith("/"):
+            # Remove / for word completion
+            cmd_text = text[1:]
+            adjusted_doc = Document(
+                cmd_text, document.cursor_position - 1 if document.cursor_position > 0 else 0
+            )
+
+            for completion in self.word_completer.get_completions(adjusted_doc, complete_event):
+                yield completion
+
+
+class BashCompleter(Completer):
+    """Bash command completer for ! commands."""
+
+    def __init__(self):
+        self.word_completer = WordCompleter(
+            list(COMMON_BASH_COMMANDS.keys()),
+            meta_dict=COMMON_BASH_COMMANDS,
+            sentence=True,
+            ignore_case=True,
+        )
+
+    def get_completions(self, document, complete_event):
+        """Get bash command completions when ! is at the start."""
+        text = document.text
+
+        # Only complete if line starts with !
+        if text.startswith("!"):
+            # Remove ! for word completion
+            cmd_text = text[1:]
+            adjusted_doc = Document(
+                cmd_text, document.cursor_position - 1 if document.cursor_position > 0 else 0
+            )
+
+            for completion in self.word_completer.get_completions(adjusted_doc, complete_event):
+                yield completion
+
+
+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):
+    """Return toolbar function that shows auto-approve status."""
+
+    def toolbar():
+        if session_state.auto_approve:
+            # Green background when auto-approve is ON
+            return [("class:toolbar-green", "auto-accept ON (CTRL+T to toggle)")]
+        # Orange background when manual accept (auto-approve OFF)
+        return [("class:toolbar-orange", "manual accept (CTRL+T to toggle)")]
+
+    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()
+
+    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 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(), BashCompleter(), FilePathCompleter()]),
+        editing_mode=EditingMode.EMACS,
+        complete_while_typing=True,  # Show completions as you type
+        mouse_support=False,
+        enable_open_in_editor=True,  # Allow Ctrl+X Ctrl+E to open external editor
+        bottom_toolbar=get_bottom_toolbar(session_state),  # Persistent status bar at bottom
+        style=toolbar_style,  # Apply toolbar styling
+    )
+
+    return session