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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.198
+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.198 → 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)
 
@@ -460,16 +489,21 @@ class BaseAgent(ABC):
 
     def get_model_context_length(self) -> int:
         """
-        Get the context length for the currently configured model from models.json
-        """
-        model_configs = ModelFactory.load_config()
-        model_name = get_global_model_name()
-
-        # Get context length from model config
-        model_config = model_configs.get(model_name, {})
-        context_length = model_config.get("context_length", 128000)  # Default value
+        Return the context length for this agent's effective model.
 
-        return int(context_length)
+        Honors per-agent pinned model via `self.get_model_name()`; falls back
+        to global model when no pin is set. Defaults conservatively on failure.
+        """
+        try:
+            model_configs = ModelFactory.load_config()
+            # Use the agent's effective model (respects /pin_model)
+            model_name = self.get_model_name()
+            model_config = model_configs.get(model_name, {})
+            context_length = model_config.get("context_length", 128000)
+            return int(context_length)
+        except Exception:
+            # Be safe; don't blow up status/compaction if model lookup fails
+            return 128000
 
     def prune_interrupted_tool_calls(
         self, messages: List[ModelMessage]
@@ -601,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))
@@ -869,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(
@@ -898,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.198 → code_puppy-0.0.200}/code_puppy/command_line/model_picker_completion.py

@@ -29,13 +29,22 @@ def set_active_model(model_name: str):
     Sets the active model name by updating the config (for persistence).
     """
     set_model_name(model_name)
-    # Reload agent globally
+    # Reload the currently active agent so the new model takes effect immediately
     try:
-        from code_puppy.agent import reload_code_generation_agent
-
-        reload_code_generation_agent()  # This will reload dynamically everywhere
+        from code_puppy.agents import get_current_agent
+
+        current_agent = get_current_agent()
+        # JSON agents may need to refresh their config before reload
+        if hasattr(current_agent, "refresh_config"):
+            try:
+                current_agent.refresh_config()
+            except Exception:
+                # Non-fatal, continue to reload
+                ...
+        current_agent.reload_code_generation_agent()
     except Exception:
-        pass  # If reload fails, agent will still be switched next interpreter run
+        # Swallow errors to avoid breaking the prompt flow; model persists for next run
+        pass
 
 
 class ModelNameCompleter(Completer):