code-puppy 0.0.199__py3-none-any.whl → 0.0.201__py3-none-any.whl

code_puppy/agents/base_agent.py

@@ -6,12 +6,13 @@ import math
 import signal
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Union
 
 import mcp
 import pydantic
 import pydantic_ai.models
 from pydantic_ai import Agent as PydanticAgent
+from pydantic_ai import BinaryContent, DocumentUrl, ImageUrl
 from pydantic_ai import RunContext, UsageLimitExceeded
 from pydantic_ai.messages import (
     ModelMessage,
@@ -180,6 +181,21 @@ class BaseAgent(ABC):
             return get_global_model_name()
         return pinned
 
+    def _clean_binaries(self, messages: List[ModelMessage]) -> List[ModelMessage]:
+        cleaned = []
+        for message in messages:
+            parts = []
+            for part in message.parts:
+                if hasattr(part, "content") and isinstance(part.content, list):
+                    content = []
+                    for item in part.content:
+                        if not isinstance(item, BinaryContent):
+                            content.append(item)
+                    part.content = content
+                parts.append(part)
+            cleaned.append(message)
+        return cleaned
+
     # Message history processing methods (moved from state_management.py and message_history_processor.py)
     def _stringify_part(self, part: Any) -> str:
         """Create a stable string representation for a message part.
@@ -213,6 +229,12 @@ class BaseAgent(ABC):
             )
         elif isinstance(content, dict):
             attributes.append(f"content={json.dumps(content, sort_keys=True)}")
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, str):
+                    attributes.append(f"content={item}")
+                if isinstance(item, BinaryContent):
+                    attributes.append(f"BinaryContent={hash(item.data)}")
         else:
             attributes.append(f"content={repr(content)}")
         result = "|".join(attributes)
@@ -259,6 +281,13 @@ class BaseAgent(ABC):
                 result = json.dumps(part.content.model_dump())
             elif isinstance(part.content, dict):
                 result = json.dumps(part.content)
+            elif isinstance(part.content, list):
+                result = ""
+                for item in part.content:
+                    if isinstance(item, str):
+                        result += item + "\n"
+                    if isinstance(item, BinaryContent):
+                        result += f"BinaryContent={hash(item.data)}\n"
             else:
                 result = str(part.content)
 
@@ -606,6 +635,7 @@ class BaseAgent(ABC):
                         f"Final token count after processing: {final_token_count}",
                         message_group="token_context_status",
                     )
+
             self.set_message_history(result_messages)
             for m in summarized_messages:
                 self.add_compacted_message_hash(self.hash_message(m))
@@ -874,28 +904,47 @@ class BaseAgent(ABC):
         self.message_history_processor(ctx, _message_history)
         return self.get_message_history()
 
-    async def run_with_mcp(self, prompt: str, **kwargs) -> Any:
-        """
-        Run the agent with MCP servers and full cancellation support.
-
-        This method ensures we're always using the current agent instance
-        and handles Ctrl+C interruption properly by creating a cancellable task.
+    async def run_with_mcp(
+        self,
+        prompt: str,
+        *,
+        attachments: Optional[Sequence[BinaryContent]] = None,
+        link_attachments: Optional[Sequence[Union[ImageUrl, DocumentUrl]]] = None,
+        **kwargs,
+    ) -> Any:
+        """Run the agent with MCP servers, attachments, and full cancellation support.
 
         Args:
-            prompt: The user prompt to process
-            usage_limits: Optional usage limits for the agent
-            **kwargs: Additional arguments to pass to agent.run (e.g., message_history)
+            prompt: Primary user prompt text (may be empty when attachments present).
+            attachments: Local binary payloads (e.g., dragged images) to include.
+            link_attachments: Remote assets (image/document URLs) to include.
+            **kwargs: Additional arguments forwarded to `pydantic_ai.Agent.run`.
 
         Returns:
-            The agent's response
+            The agent's response.
 
         Raises:
-            asyncio.CancelledError: When execution is cancelled by user
+            asyncio.CancelledError: When execution is cancelled by user.
         """
         group_id = str(uuid.uuid4())
         # Avoid double-loading: reuse existing agent if already built
         pydantic_agent = self._code_generation_agent or self.reload_code_generation_agent()
 
+        # Build combined prompt payload when attachments are provided.
+        attachment_parts: List[Any] = []
+        if attachments:
+            attachment_parts.extend(list(attachments))
+        if link_attachments:
+            attachment_parts.extend(list(link_attachments))
+
+        if attachment_parts:
+            prompt_payload: Union[str, List[Any]] = []
+            if prompt:
+                prompt_payload.append(prompt)
+            prompt_payload.extend(attachment_parts)
+        else:
+            prompt_payload = prompt
+
         async def run_agent_task():
             try:
                 self.set_message_history(
@@ -903,7 +952,7 @@ class BaseAgent(ABC):
                 )
                 usage_limits = pydantic_ai.agent._usage.UsageLimits(request_limit=get_message_limit())
                 result_ = await pydantic_agent.run(
-                    prompt,
+                    prompt_payload,
                     message_history=self.get_message_history(),
                     usage_limits=usage_limits,
                     **kwargs,

code_puppy/command_line/attachments.py

@@ -0,0 +1,375 @@
+"""Helpers for parsing file attachments from interactive prompts."""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Sequence
+
+from pydantic_ai import BinaryContent, DocumentUrl, ImageUrl
+
+SUPPORTED_INLINE_SCHEMES = {"http", "https"}
+
+# Allow common extensions people drag in the terminal.
+DEFAULT_ACCEPTED_IMAGE_EXTENSIONS = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".webp",
+    ".tiff",
+}
+DEFAULT_ACCEPTED_DOCUMENT_EXTENSIONS = set()
+
+
+@dataclass
+class PromptAttachment:
+    """Represents a binary attachment parsed from the input prompt."""
+
+    placeholder: str
+    content: BinaryContent
+
+
+@dataclass
+class PromptLinkAttachment:
+    """Represents a URL attachment supported by pydantic-ai."""
+
+    placeholder: str
+    url_part: ImageUrl | DocumentUrl
+
+
+@dataclass
+class ProcessedPrompt:
+    """Container for parsed input prompt and attachments."""
+
+    prompt: str
+    attachments: List[PromptAttachment]
+    link_attachments: List[PromptLinkAttachment]
+    warnings: List[str]
+
+
+class AttachmentParsingError(RuntimeError):
+    """Raised when we fail to load a user-provided attachment."""
+
+
+def _is_probable_path(token: str) -> bool:
+    """Heuristically determine whether a token is a local filesystem path."""
+
+    if not token:
+        return False
+    if token.startswith("#"):
+        return False
+    # Windows drive letters or Unix absolute/relative paths
+    if token.startswith(("/", "~", "./", "../")):
+        return True
+    if len(token) >= 2 and token[1] == ":":
+        return True
+    # Things like `path/to/file.png`
+    return os.sep in token or "\"" in token
+
+
+def _unescape_dragged_path(token: str) -> str:
+    """Convert backslash-escaped spaces used by drag-and-drop to literal spaces."""
+    # Shell/terminal escaping typically produces '\ ' sequences
+    return token.replace(r"\ ", " ")
+
+
+def _normalise_path(token: str) -> Path:
+    """Expand user shortcuts and resolve relative components without touching fs."""
+    # First unescape any drag-and-drop backslash spaces before other expansions
+    unescaped = _unescape_dragged_path(token)
+    expanded = os.path.expanduser(unescaped)
+    try:
+        # This will not resolve against symlinks because we do not call resolve()
+        return Path(expanded).absolute()
+    except Exception as exc:
+        raise AttachmentParsingError(f"Invalid path '{token}': {exc}") from exc
+
+
+def _determine_media_type(path: Path) -> str:
+    """Best-effort media type detection for images only."""
+
+    mime, _ = mimetypes.guess_type(path.name)
+    if mime:
+        return mime
+    if path.suffix.lower() in DEFAULT_ACCEPTED_IMAGE_EXTENSIONS:
+        return "image/png"
+    return "application/octet-stream"
+
+
+def _load_binary(path: Path) -> bytes:
+    try:
+        return path.read_bytes()
+    except FileNotFoundError as exc:
+        raise AttachmentParsingError(f"Attachment not found: {path}") from exc
+    except PermissionError as exc:
+        raise AttachmentParsingError(f"Cannot read attachment (permission denied): {path}") from exc
+    except OSError as exc:
+        raise AttachmentParsingError(f"Failed to read attachment {path}: {exc}") from exc
+
+
+def _tokenise(prompt: str) -> Iterable[str]:
+    """Split the prompt preserving quoted segments using shell-like semantics."""
+
+    if not prompt:
+        return []
+    try:
+        # On Windows, avoid POSIX escaping so backslashes are preserved
+        posix_mode = os.name != "nt"
+        return shlex.split(prompt, posix=posix_mode)
+    except ValueError:
+        # Fallback naive split when shlex fails (e.g. unmatched quotes)
+        return prompt.split()
+
+
+def _strip_attachment_token(token: str) -> str:
+    """Trim surrounding whitespace/punctuation terminals tack onto paths."""
+
+    return token.strip().strip(",;:()[]{}")
+
+
+def _candidate_paths(
+    tokens: Sequence[str],
+    start: int,
+    max_span: int = 5,
+) -> Iterable[tuple[str, int]]:
+    """Yield space-joined token slices to reconstruct paths with spaces."""
+
+    collected: list[str] = []
+    for offset, raw in enumerate(tokens[start : start + max_span]):
+        collected.append(raw)
+        yield " ".join(collected), start + offset + 1
+
+
+def _is_supported_extension(path: Path) -> bool:
+    suffix = path.suffix.lower()
+    return suffix in DEFAULT_ACCEPTED_IMAGE_EXTENSIONS | DEFAULT_ACCEPTED_DOCUMENT_EXTENSIONS
+
+
+def _parse_link(token: str) -> PromptLinkAttachment | None:
+    if "://" not in token:
+        return None
+    scheme = token.split(":", 1)[0].lower()
+    if scheme not in SUPPORTED_INLINE_SCHEMES:
+        return None
+    if token.lower().endswith(".pdf"):
+        return PromptLinkAttachment(
+            placeholder=token,
+            url_part=DocumentUrl(url=token),
+        )
+    return PromptLinkAttachment(
+        placeholder=token,
+        url_part=ImageUrl(url=token),
+    )
+
+
+@dataclass
+class _DetectedPath:
+    placeholder: str
+    path: Path | None
+    start_index: int
+    consumed_until: int
+    unsupported: bool = False
+    link: PromptLinkAttachment | None = None
+
+    def has_path(self) -> bool:
+        return self.path is not None and not self.unsupported
+
+
+def _detect_path_tokens(prompt: str) -> tuple[list[_DetectedPath], list[str]]:
+    # Preserve backslash-spaces from drag-and-drop before shlex tokenization
+    # Replace '\ ' with a marker that shlex won't split, then restore later
+    ESCAPE_MARKER = "\u0000ESCAPED_SPACE\u0000"
+    masked_prompt = prompt.replace(r"\ ", ESCAPE_MARKER)
+    tokens = list(_tokenise(masked_prompt))
+    # Restore escaped spaces in individual tokens
+    tokens = [t.replace(ESCAPE_MARKER, " ") for t in tokens]
+
+    detections: list[_DetectedPath] = []
+    warnings: list[str] = []
+
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+
+        link_attachment = _parse_link(token)
+        if link_attachment:
+            detections.append(
+                _DetectedPath(
+                    placeholder=token,
+                    path=None,
+                    start_index=index,
+                    consumed_until=index + 1,
+                    link=link_attachment,
+                )
+            )
+            index += 1
+            continue
+
+        stripped_token = _strip_attachment_token(token)
+        if not _is_probable_path(stripped_token):
+            index += 1
+            continue
+
+        start_index = index
+        consumed_until = index + 1
+        candidate_path_token = stripped_token
+        # For placeholder: try to reconstruct escaped representation; if none, use raw token
+        original_tokens_for_slice = list(_tokenise(masked_prompt))[index:consumed_until]
+        candidate_placeholder = "".join(
+            ot.replace(ESCAPE_MARKER, r"\ ") if ESCAPE_MARKER in ot else ot
+            for ot in original_tokens_for_slice
+        )
+        # If placeholder seems identical to raw token, just use the raw token
+        if candidate_placeholder == token.replace(" ", r"\ "):
+            candidate_placeholder = token
+
+        try:
+            path = _normalise_path(candidate_path_token)
+        except AttachmentParsingError as exc:
+            warnings.append(str(exc))
+            index = consumed_until
+            continue
+
+        if not path.exists() or not path.is_file():
+            found_span = False
+            last_path = path
+            for joined, end_index in _candidate_paths(tokens, index):
+                stripped_joined = _strip_attachment_token(joined)
+                if not _is_probable_path(stripped_joined):
+                    continue
+                candidate_path_token = stripped_joined
+                candidate_placeholder = joined
+                consumed_until = end_index
+                try:
+                    last_path = _normalise_path(candidate_path_token)
+                except AttachmentParsingError as exc:
+                    warnings.append(str(exc))
+                    found_span = False
+                    break
+                if last_path.exists() and last_path.is_file():
+                    path = last_path
+                    found_span = True
+                    # We'll rebuild escaped placeholder after this block
+                    break
+            if not found_span:
+                warnings.append(f"Attachment ignored (not a file): {path}")
+                index += 1
+                continue
+            # Reconstruct escaped placeholder for multi-token paths
+            original_tokens_for_path = tokens[index:consumed_until]
+            escaped_placeholder = " ".join(original_tokens_for_path).replace(" ", r"\ ")
+            candidate_placeholder = escaped_placeholder
+        if not _is_supported_extension(path):
+            detections.append(
+                _DetectedPath(
+                    placeholder=candidate_placeholder,
+                    path=path,
+                    start_index=start_index,
+                    consumed_until=consumed_until,
+                    unsupported=True,
+                )
+            )
+            index = consumed_until
+            continue
+
+        # Reconstruct escaped placeholder for exact replacement later
+        # For unquoted spaces, keep the original literal token from the prompt
+        # so replacement matches precisely
+        escaped_placeholder = candidate_placeholder
+
+        detections.append(
+            _DetectedPath(
+                placeholder=candidate_placeholder,
+                path=path,
+                start_index=start_index,
+                consumed_until=consumed_until,
+            )
+        )
+        index = consumed_until
+
+    return detections, warnings
+
+
+def parse_prompt_attachments(prompt: str) -> ProcessedPrompt:
+    """Extract attachments from the prompt returning cleaned text and metadata."""
+
+    attachments: List[PromptAttachment] = []
+
+    detections, detection_warnings = _detect_path_tokens(prompt)
+    warnings: List[str] = list(detection_warnings)
+
+    link_attachments = [d.link for d in detections if d.link is not None]
+
+    for detection in detections:
+        if detection.link is not None and detection.path is None:
+            continue
+        if detection.path is None:
+            continue
+        if detection.unsupported:
+            warnings.append(
+                f"Unsupported attachment type: {detection.path.suffix or detection.path.name}"
+            )
+            continue
+
+        try:
+            media_type = _determine_media_type(detection.path)
+            data = _load_binary(detection.path)
+        except AttachmentParsingError as exc:
+            warnings.append(str(exc))
+            continue
+        attachments.append(
+            PromptAttachment(
+                placeholder=detection.placeholder,
+                content=BinaryContent(data=data, media_type=media_type),
+            )
+        )
+
+    # Rebuild cleaned_prompt by skipping tokens consumed as file paths.
+    # This preserves original punctuation and spacing for non-attachment tokens.
+    ESCAPE_MARKER = "\u0000ESCAPED_SPACE\u0000"
+    masked = prompt.replace(r"\ ", ESCAPE_MARKER)
+    tokens = list(_tokenise(masked))
+
+    # Build exact token spans for file attachments (supported or unsupported)
+    # Skip spans for: supported files (path present and not unsupported) and links.
+    spans = [
+        (d.start_index, d.consumed_until)
+        for d in detections
+        if (d.path is not None and not d.unsupported) or (d.link is not None and d.path is None)
+    ]
+    cleaned_parts: list[str] = []
+    i = 0
+    while i < len(tokens):
+        span = next((s for s in spans if s[0] <= i < s[1]), None)
+        if span is not None:
+            i = span[1]
+            continue
+        cleaned_parts.append(tokens[i].replace(ESCAPE_MARKER, " "))
+        i += 1
+
+    cleaned_prompt = " ".join(cleaned_parts).strip()
+    cleaned_prompt = " ".join(cleaned_prompt.split())
+
+    if cleaned_prompt == "" and attachments:
+        cleaned_prompt = "Describe the attached files in detail."
+
+    return ProcessedPrompt(
+        prompt=cleaned_prompt,
+        attachments=attachments,
+        link_attachments=link_attachments,
+        warnings=warnings,
+    )
+
+
+__all__ = [
+    "ProcessedPrompt",
+    "PromptAttachment",
+    "PromptLinkAttachment",
+    "AttachmentParsingError",
+    "parse_prompt_attachments",
+]

code_puppy/command_line/prompt_toolkit_completion.py

@@ -17,6 +17,7 @@ from prompt_toolkit.history import FileHistory
 from prompt_toolkit.filters import is_searching
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
+from prompt_toolkit.layout.processors import Processor, Transformation
 from prompt_toolkit.styles import Style
 
 from code_puppy.command_line.file_path_completion import FilePathCompleter
@@ -33,6 +34,11 @@ from code_puppy.config import (
     get_puppy_name,
     get_value,
 )
+from code_puppy.command_line.attachments import (
+    DEFAULT_ACCEPTED_DOCUMENT_EXTENSIONS,
+    DEFAULT_ACCEPTED_IMAGE_EXTENSIONS,
+    _detect_path_tokens, _tokenise,
+)
 
 
 class SetCompleter(Completer):
@@ -98,6 +104,117 @@ class SetCompleter(Completer):
                 )
 
 
+class AttachmentPlaceholderProcessor(Processor):
+    """Display friendly placeholders for recognised attachments."""
+
+    _PLACEHOLDER_STYLE = "class:attachment-placeholder"
+
+    def apply_transformation(self, transformation_input):
+        document = transformation_input.document
+        text = document.text
+        if not text:
+            return Transformation(list(transformation_input.fragments))
+
+        detections, _warnings = _detect_path_tokens(text)
+        replacements: list[tuple[int, int, str]] = []
+        search_cursor = 0
+        ESCAPE_MARKER = "\u0000ESCAPED_SPACE\u0000"
+        masked_text = text.replace(r"\ ", ESCAPE_MARKER)
+        token_view = list(_tokenise(masked_text))
+        for detection in detections:
+            display_text: str | None = None
+            if detection.path and detection.has_path():
+                suffix = detection.path.suffix.lower()
+                if suffix in DEFAULT_ACCEPTED_IMAGE_EXTENSIONS:
+                    display_text = f"[{suffix.lstrip('.') or 'image'} image]"
+                elif suffix in DEFAULT_ACCEPTED_DOCUMENT_EXTENSIONS:
+                    display_text = f"[{suffix.lstrip('.') or 'file'} document]"
+                else:
+                    display_text = "[file attachment]"
+            elif detection.link is not None:
+                display_text = "[link]"
+
+            if not display_text:
+                continue
+
+            # Use token-span for robust lookup (handles escaped spaces)
+            span_tokens = token_view[detection.start_index:detection.consumed_until]
+            raw_span = " ".join(span_tokens).replace(ESCAPE_MARKER, r"\ ")
+            index = text.find(raw_span, search_cursor)
+            span_len = len(raw_span)
+            if index == -1:
+                # Fallback to placeholder string
+                placeholder = detection.placeholder
+                index = text.find(placeholder, search_cursor)
+                span_len = len(placeholder)
+            if index == -1:
+                continue
+            replacements.append((index, index + span_len, display_text))
+            search_cursor = index + span_len
+
+        if not replacements:
+            return Transformation(list(transformation_input.fragments))
+
+        replacements.sort(key=lambda item: item[0])
+
+        new_fragments: list[tuple[str, str]] = []
+        source_to_display_map: list[int] = []
+        display_to_source_map: list[int] = []
+
+        source_index = 0
+        display_index = 0
+
+        def append_plain_segment(segment: str) -> None:
+            nonlocal source_index, display_index
+            if not segment:
+                return
+            new_fragments.append(("", segment))
+            for _ in segment:
+                source_to_display_map.append(display_index)
+                display_to_source_map.append(source_index)
+                source_index += 1
+                display_index += 1
+
+        for start, end, replacement_text in replacements:
+            if start > source_index:
+                append_plain_segment(text[source_index:start])
+
+            placeholder = replacement_text or ""
+            placeholder_start = display_index
+            if placeholder:
+                new_fragments.append((self._PLACEHOLDER_STYLE, placeholder))
+                for _ in placeholder:
+                    display_to_source_map.append(start)
+                    display_index += 1
+
+            for _ in text[source_index:end]:
+                source_to_display_map.append(placeholder_start if placeholder else display_index)
+                source_index += 1
+
+        if source_index < len(text):
+            append_plain_segment(text[source_index:])
+
+        def source_to_display(pos: int) -> int:
+            if pos < 0:
+                return 0
+            if pos < len(source_to_display_map):
+                return source_to_display_map[pos]
+            return display_index
+
+        def display_to_source(pos: int) -> int:
+            if pos < 0:
+                return 0
+            if pos < len(display_to_source_map):
+                return display_to_source_map[pos]
+            return len(source_to_display_map)
+
+        return Transformation(
+            new_fragments,
+            source_to_display=source_to_display,
+            display_to_source=display_to_source,
+        )
+
+
 class CDCompleter(Completer):
     def __init__(self, trigger: str = "/cd"):
         self.trigger = trigger
@@ -247,6 +364,7 @@ async def get_input_with_combined_completion(
         history=history,
         complete_while_typing=True,
         key_bindings=bindings,
+        input_processors=[AttachmentPlaceholderProcessor()],
     )
     # If they pass a string, backward-compat: convert it to formatted_text
     if isinstance(prompt_str, str):
@@ -263,6 +381,7 @@ async def get_input_with_combined_completion(
             "model": "bold cyan",
             "cwd": "bold green",
             "arrow": "bold yellow",
+            "attachment-placeholder": "italic cyan",
         }
     )
     text = await session.prompt_async(prompt_str, style=style)

code_puppy/main.py

@@ -1,12 +1,10 @@
 import argparse
 import asyncio
-import json
 import os
 import subprocess
 import sys
 import time
 import webbrowser
-from datetime import datetime
 from pathlib import Path
 
 from rich.console import Console, ConsoleOptions, RenderResult
@@ -20,6 +18,7 @@ from code_puppy.command_line.prompt_toolkit_completion import (
     get_input_with_combined_completion,
     get_prompt_with_active_model,
 )
+from code_puppy.command_line.attachments import parse_prompt_attachments
 from code_puppy.config import (
     AUTOSAVE_DIR,
     COMMAND_HISTORY_FILE,
@@ -28,7 +27,7 @@ from code_puppy.config import (
     initialize_command_history_file,
     save_command_to_history,
 )
-from code_puppy.session_storage import list_sessions, load_session, restore_autosave_interactively
+from code_puppy.session_storage import restore_autosave_interactively
 from code_puppy.http_utils import find_available_port
 from code_puppy.tools.common import console
 
@@ -313,33 +312,24 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 awaiting_input = False
 
             # Run with or without spinner based on whether we're awaiting input
-            if awaiting_input:
-                # No spinner - use agent_manager's run_with_mcp method
+            response = await run_prompt_with_attachments(
+                agent,
+                initial_command,
+                spinner_console=display_console,
+                use_spinner=not awaiting_input,
+            )
+            if response is not None:
+                agent_response = response.output
 
-                response = await agent.run_with_mcp(
-                    initial_command,
+                emit_system_message(
+                    f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
                 )
-            else:
-                # Use our custom spinner for better compatibility with user input
-                from code_puppy.messaging.spinner import ConsoleSpinner
-
-                with ConsoleSpinner(console=display_console):
-                    # Use agent_manager's run_with_mcp method
-                    response = await agent.run_with_mcp(
-                        initial_command,
-                    )
-
-            agent_response = response.output
-
-            emit_system_message(
-                f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
-            )
-            emit_system_message("\n" + "=" * 50)
-            emit_info("[bold green]🐶 Continuing in Interactive Mode[/bold green]")
-            emit_system_message(
-                "Your command and response are preserved in the conversation history."
-            )
-            emit_system_message("=" * 50 + "\n")
+                emit_system_message("\n" + "=" * 50)
+                emit_info("[bold green]🐶 Continuing in Interactive Mode[/bold green]")
+                emit_system_message(
+                    "Your command and response are preserved in the conversation history."
+                )
+                emit_system_message("=" * 50 + "\n")
 
         except Exception as e:
             from code_puppy.messaging import emit_error
@@ -425,9 +415,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_info(f"[dim]Auto-save session rotated to: {new_session_id}[/dim]")
             continue
 
-        # Handle / commands before anything else
-        if task.strip().startswith("/"):
-            command_result = handle_command(task.strip())
+        # Parse attachments first so leading paths aren't misread as commands
+        processed_for_commands = parse_prompt_attachments(task)
+        cleaned_for_commands = (processed_for_commands.prompt or "").strip()
+
+        # Handle / commands based on cleaned prompt (after stripping attachments)
+        if cleaned_for_commands.startswith("/"):
+            command_result = handle_command(cleaned_for_commands)
             if command_result is True:
                 continue
             elif isinstance(command_result, str):
@@ -446,14 +440,12 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
                 # No need to get agent directly - use manager's run methods
 
-                # Use our custom spinner for better compatibility with user input
-                from code_puppy.messaging import emit_warning
-                from code_puppy.messaging.spinner import ConsoleSpinner
-
-                with ConsoleSpinner(console=message_renderer.console):
-                    result = await current_agent.run_with_mcp(
-                        task,
-                    )
+                # Use our custom helper to enable attachment handling with spinner support
+                result = await run_prompt_with_attachments(
+                    current_agent,
+                    task,
+                    spinner_console=message_renderer.console,
+                )
                 # Check if the task was cancelled (but don't show message if we just killed processes)
                 if result is None:
                     continue
@@ -504,6 +496,57 @@ def prettier_code_blocks():
     Markdown.elements["fence"] = SimpleCodeBlock
 
 
+async def run_prompt_with_attachments(
+    agent,
+    raw_prompt: str,
+    *,
+    spinner_console=None,
+    use_spinner: bool = True,
+):
+    """Run the agent after parsing CLI attachments for image/document support."""
+    from code_puppy.messaging import emit_system_message, emit_warning
+
+    processed_prompt = parse_prompt_attachments(raw_prompt)
+
+    for warning in processed_prompt.warnings:
+        emit_warning(warning)
+
+    summary_parts = []
+    if processed_prompt.attachments:
+        summary_parts.append(f"binary files: {len(processed_prompt.attachments)}")
+    if processed_prompt.link_attachments:
+        summary_parts.append(f"urls: {len(processed_prompt.link_attachments)}")
+    if summary_parts:
+        emit_system_message(
+            "[dim]Attachments detected -> " + ", ".join(summary_parts) + "[/dim]"
+        )
+
+    if not processed_prompt.prompt:
+        emit_warning(
+            "Prompt is empty after removing attachments; add instructions and retry."
+        )
+        return None
+
+    attachments = [attachment.content for attachment in processed_prompt.attachments]
+    link_attachments = [link.url_part for link in processed_prompt.link_attachments]
+
+    if use_spinner and spinner_console is not None:
+        from code_puppy.messaging.spinner import ConsoleSpinner
+
+        with ConsoleSpinner(console=spinner_console):
+            return await agent.run_with_mcp(
+                processed_prompt.prompt,
+                attachments=attachments,
+                link_attachments=link_attachments,
+            )
+
+    return await agent.run_with_mcp(
+        processed_prompt.prompt,
+        attachments=attachments,
+        link_attachments=link_attachments,
+    )
+
+
 async def execute_single_prompt(prompt: str, message_renderer) -> None:
     """Execute a single prompt and exit (for -p flag)."""
     from code_puppy.messaging import emit_info, emit_system_message
@@ -511,14 +554,15 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
     emit_info(f"[bold blue]Executing prompt:[/bold blue] {prompt}")
 
     try:
-        # Get agent through runtime manager and use its run_with_mcp method
+        # Get agent through runtime manager and use helper for attachments
         agent = get_current_agent()
-        from code_puppy.messaging.spinner import ConsoleSpinner
-
-        with ConsoleSpinner(console=message_renderer.console):
-            response = await agent.run_with_mcp(
-                prompt,
-            )
+        response = await run_prompt_with_attachments(
+            agent,
+            prompt,
+            spinner_console=message_renderer.console,
+        )
+        if response is None:
+            return
 
         agent_response = response.output
         emit_system_message(

code_puppy/session_storage.py

@@ -177,48 +177,87 @@ async def restore_autosave_interactively(base_dir: Path) -> None:
         return datetime.min
 
     entries.sort(key=sort_key, reverse=True)
-    top_entries = entries[:5]
-
-    emit_system_message("[bold magenta]Autosave Sessions Available:[/bold magenta]")
-    for index, (name, timestamp, message_count) in enumerate(top_entries, start=1):
-        timestamp_display = timestamp or "unknown time"
-        message_display = (
-            f"{message_count} messages" if message_count is not None else "unknown size"
-        )
-        emit_system_message(
-            f"  [{index}] {name} ({message_display}, saved at {timestamp_display})"
-        )
-
-    if len(entries) > len(top_entries):
-        emit_system_message(
-            f"  [dim]...and {len(entries) - len(top_entries)} more autosaves[/dim]"
-        )
 
-    try:
-        selection = await get_input_with_combined_completion(
-            FormattedText([("class:prompt", "Load autosave (number, name, or Enter to skip): ")])
-        )
-    except (KeyboardInterrupt, EOFError):
-        emit_warning("Autosave selection cancelled")
-        return
-
-    selection = selection.strip()
-    if not selection:
-        return
+    PAGE_SIZE = 5
+    total = len(entries)
+    page = 0
+
+    def render_page() -> None:
+        start = page * PAGE_SIZE
+        end = min(start + PAGE_SIZE, total)
+        page_entries = entries[start:end]
+        emit_system_message("[bold magenta]Autosave Sessions Available:[/bold magenta]")
+        for idx, (name, timestamp, message_count) in enumerate(page_entries, start=1):
+            timestamp_display = timestamp or "unknown time"
+            message_display = (
+                f"{message_count} messages" if message_count is not None else "unknown size"
+            )
+            emit_system_message(
+                f"  [{idx}] {name} ({message_display}, saved at {timestamp_display})"
+            )
+        # If there are more pages, offer next-page; show 'Return to first page' on last page
+        if total > PAGE_SIZE:
+            page_count = (total + PAGE_SIZE - 1) // PAGE_SIZE
+            is_last_page = (page + 1) >= page_count
+            remaining = total - (page * PAGE_SIZE + len(page_entries))
+            summary = f" and {remaining} more" if (remaining > 0 and not is_last_page) else ""
+            label = "Return to first page" if is_last_page else f"Next page{summary}"
+            emit_system_message(f"  [6] {label}")
+        emit_system_message("  [Enter] Skip loading autosave")
+
+    chosen_name: str | None = None
+
+    while True:
+        render_page()
+        try:
+            selection = await get_input_with_combined_completion(
+                FormattedText(
+                    [
+                        (
+                            "class:prompt",
+                            "Pick 1-5 to load, 6 for next, or name/Enter: ",
+                        )
+                    ]
+                )
+            )
+        except (KeyboardInterrupt, EOFError):
+            emit_warning("Autosave selection cancelled")
+            return
+
+        selection = (selection or "").strip()
+        if not selection:
+            return
+
+        # Numeric choice: 1-5 select within current page; 6 advances page
+        if selection.isdigit():
+            num = int(selection)
+            if num == 6 and total > PAGE_SIZE:
+                page = (page + 1) % ((total + PAGE_SIZE - 1) // PAGE_SIZE)
+                # loop and re-render next page
+                continue
+            if 1 <= num <= 5:
+                start = page * PAGE_SIZE
+                idx = start + (num - 1)
+                if 0 <= idx < total:
+                    chosen_name = entries[idx][0]
+                    break
+                else:
+                    emit_warning("Invalid selection for this page")
+                    continue
+            emit_warning("Invalid selection; choose 1-5 or 6 for next")
+            continue
 
-    chosen_name = None
-    if selection.isdigit():
-        idx = int(selection) - 1
-        if 0 <= idx < len(top_entries):
-            chosen_name = top_entries[idx][0]
-    else:
-        for name, _, _ in entries:
+        # Allow direct typing by exact session name
+        for name, _ts, _mc in entries:
             if name == selection:
                 chosen_name = name
                 break
+        if chosen_name:
+            break
+        emit_warning("No autosave loaded (invalid selection)")
+        # keep looping and allow another try
 
     if not chosen_name:
-        emit_warning("No autosave loaded (invalid selection)")
         return
 
     try:

{code_puppy-0.0.199.dist-info → code_puppy-0.0.201.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.199
+Version: 0.0.201
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.199.dist-info → code_puppy-0.0.201.dist-info}/RECORD

@@ -3,12 +3,12 @@ code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
 code_puppy/callbacks.py,sha256=ukSgVFaEO68o6J09qFwDrnmNanrVv3toTLQhS504Meo,6162
 code_puppy/config.py,sha256=xT-nU1U4n7u8pyzJPG18-cJZBKv5OZI2CtHLt9DGRzU,26065
 code_puppy/http_utils.py,sha256=YLd8Y16idbI32JGeBXG8n5rT4o4X_zxk9FgUvK9XFo8,8248
-code_puppy/main.py,sha256=TIFaySHV3um9Q3BDUjCjh6s-WWqcNnTY3EsD2WdW6MQ,22245
+code_puppy/main.py,sha256=WqlOivWMzm0ijLB9qBHK5Q_adJurzkD_ywGEUVD16RA,23770
 code_puppy/model_factory.py,sha256=ZbIAJWMNKNdTCEMQK8Ig6TDDZlVNyGO9hOLHoLLPMYw,15397
 code_puppy/models.json,sha256=dClUciCo2RlVDs0ZAQCIur8MOavZUEAXHEecn0uPa-4,1629
 code_puppy/reopenable_async_client.py,sha256=4UJRaMp5np8cbef9F0zKQ7TPKOfyf5U-Kv-0zYUWDho,8274
 code_puppy/round_robin_model.py,sha256=UEfw-Ix7GpNRWSxxuJtA-EE4_A46KXjMgFRciprfLmg,5634
-code_puppy/session_storage.py,sha256=40RAOCrh7MpR5cWWoatjj2bQMikduIvSzFV2yI8v2Yk,7928
+code_puppy/session_storage.py,sha256=Pf5C-qyC6xLhZCTlbAdkPwOFyqlaDomVnj9Z4cZcZsE,9595
 code_puppy/status_display.py,sha256=F6eEAkGePDp4StM2BWj-uLLQTDGtJrf0IufzCeP1rRg,8336
 code_puppy/summarization_agent.py,sha256=LnObgtLmM6N4z2553XXQlXAOf8R1BPSNmFSfXkjpivg,3211
 code_puppy/tui_state.py,sha256=TT76XBVapKj6fKjFzz6oxCONeN_BZwcMILxxZcxu6-Y,1171
@@ -27,15 +27,16 @@ code_puppy/agents/agent_qa_expert.py,sha256=wCGXzuAVElT5c-QigQVb8JX9Gw0JmViCUQQn
 code_puppy/agents/agent_qa_kitten.py,sha256=5PeFFSwCFlTUvP6h5bGntx0xv5NmRwBiw0HnMqY8nLI,9107
 code_puppy/agents/agent_security_auditor.py,sha256=ADafi2x4gqXw6m-Nch5vjiKjO0Urcbj0x4zxHti3gDw,3712
 code_puppy/agents/agent_typescript_reviewer.py,sha256=EDY1mFkVpuJ1BPXsJFu2wQ2pfAV-90ipc_8w9ymrKPg,4054
-code_puppy/agents/base_agent.py,sha256=EHAIQrfsM7x1lz9YHXxlidWhw35HTN4f1JIvdx469ZQ,39390
+code_puppy/agents/base_agent.py,sha256=dsnoFEHXVhXgK-WIOskCU1Ccx6uz5onfiycWAMxBhaw,41421
 code_puppy/agents/json_agent.py,sha256=lhopDJDoiSGHvD8A6t50hi9ZBoNRKgUywfxd0Po_Dzc,4886
 code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
+code_puppy/command_line/attachments.py,sha256=GSK-clGmJ1nmZD1XDqnWW7f9YiYLwjgu3D2iwvG6OMc,12362
 code_puppy/command_line/command_handler.py,sha256=alxMe5v_4jq8Sm6HETsgfF-VoDtgExj9dVzxP77fwmY,31614
 code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
 code_puppy/command_line/load_context_completion.py,sha256=6eZxV6Bs-EFwZjN93V8ZDZUC-6RaWxvtZk-04Wtikyw,2240
 code_puppy/command_line/model_picker_completion.py,sha256=uqwpbMYnCcWUZZ10Y4pMBKBfW52wQ-KdML2PO4Xjwr0,4501
 code_puppy/command_line/motd.py,sha256=PEdkp3ZnydVfvd7mNJylm8YyFNUKg9jmY6uwkA1em8c,2152
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=_8SUUCKfjOxgNMkcHTeB08NIjCeqL3utHljROXLTEZE,10656
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=VZanuLcv1Py4sknTJWlJOQ6IqWqDjlHPoBcoeHEcPCA,15325
 code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
 code_puppy/command_line/mcp/__init__.py,sha256=0-OQuwjq_pLiTVJ1_NrirVwdRerghyKs_MTZkwPC7YY,315
 code_puppy/command_line/mcp/add_command.py,sha256=lZ09RpFDIeghX1zhc2YIAqBASs5Ra52x5YAasUKvqJg,6409
@@ -122,9 +123,9 @@ code_puppy/tui/screens/help.py,sha256=eJuPaOOCp7ZSUlecearqsuX6caxWv7NQszUh0tZJjB
 code_puppy/tui/screens/mcp_install_wizard.py,sha256=vObpQwLbXjQsxmSg-WCasoev1usEi0pollKnL0SHu9U,27693
 code_puppy/tui/screens/settings.py,sha256=EoMxiguyeF0srwV1bj4_MG9rrxkNthh6TdTNsxnXLfE,11460
 code_puppy/tui/screens/tools.py,sha256=3pr2Xkpa9Js6Yhf1A3_wQVRzFOui-KDB82LwrsdBtyk,1715
-code_puppy-0.0.199.data/data/code_puppy/models.json,sha256=dClUciCo2RlVDs0ZAQCIur8MOavZUEAXHEecn0uPa-4,1629
-code_puppy-0.0.199.dist-info/METADATA,sha256=IV5OoNejufscIc5UvwoIbTCR0z7Worz6m0N0QFniEuI,20759
-code_puppy-0.0.199.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.199.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.199.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.199.dist-info/RECORD,,
+code_puppy-0.0.201.data/data/code_puppy/models.json,sha256=dClUciCo2RlVDs0ZAQCIur8MOavZUEAXHEecn0uPa-4,1629
+code_puppy-0.0.201.dist-info/METADATA,sha256=aych9u0aHR3SOsgBysmVF12b5JukUSqymvX0gOXdQ3w,20759
+code_puppy-0.0.201.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.201.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.201.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.201.dist-info/RECORD,,