code-puppy 0.0.199__tar.gz → 0.0.200__tar.gz

{code_puppy-0.0.199 → code_puppy-0.0.200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.199
+Version: 0.0.200
 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 → code_puppy-0.0.200}/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-0.0.200/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-0.0.199 → code_puppy-0.0.200}/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)