code-puppy-core-plugins 0.0.69__tar.gz → 0.0.71__tar.gz

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.69
+Version: 0.0.71
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins
@@ -15,8 +15,15 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.15,>=3.11
+Requires-Dist: httpx2>=2.7
 Requires-Dist: httpx<1,>=0.24.1
 Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai,typesafe]<3,>=2.51.0
+Requires-Dist: tree-sitter-go>=0.25.0
+Requires-Dist: tree-sitter-java>=0.23.5
+Requires-Dist: tree-sitter-javascript>=0.25.0
+Requires-Dist: tree-sitter-rust>=0.24.2
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Requires-Dist: tree-sitter<0.26,>=0.25.2
 Description-Content-Type: text/markdown
 
 # Code Puppy Core Plugins

code_puppy_core_plugins-0.0.71/code_puppy_core_plugins/attachment_references/__init__.py

@@ -0,0 +1 @@
+"""Bridge user-attached images into on-disk reference files."""

code_puppy_core_plugins-0.0.71/code_puppy_core_plugins/attachment_references/register_callbacks.py

@@ -0,0 +1,22 @@
+"""Register the attachment-to-reference bridge tool with Code Puppy."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from .tool import TOOL_NAME, register_tools_callback
+
+
+def _register_tools() -> list[dict[str, Any]]:
+    return register_tools_callback()
+
+
+def _advertise_tool(agent_name: str | None = None) -> list[str]:
+    del agent_name
+    return [TOOL_NAME]
+
+
+register_callback("register_tools", _register_tools)
+register_callback("register_agent_tools", _advertise_tool)

code_puppy_core_plugins-0.0.71/code_puppy_core_plugins/attachment_references/tool.py

@@ -0,0 +1,137 @@
+"""Materialize the latest user-attached images into reference files.
+
+Pasted or dragged images arrive as ``BinaryContent`` stapled onto the user
+message; they never touch the filesystem. Tools such as ``codex_imagegen``
+condition on ``reference_images`` *paths*, so there is otherwise no way to point
+image generation at something the user just pasted. This tool bridges that gap
+by writing the latest turn's image attachments to disk and returning their
+paths -- nothing more (SRP/YAGNI).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import mimetypes
+import os
+import uuid
+from pathlib import Path
+from typing import Any, List, Sequence
+
+from pydantic_ai import BinaryContent, RunContext
+from pydantic_ai.messages import UserPromptPart
+
+from code_puppy import config
+
+TOOL_NAME = "save_attachments_as_references"
+
+
+def _is_image(item: Any) -> bool:
+    return isinstance(item, BinaryContent) and str(
+        getattr(item, "media_type", "") or ""
+    ).startswith("image/")
+
+
+def _extract_latest_user_images(messages: Sequence[Any] | None) -> List[BinaryContent]:
+    """Return image attachments from the most recent user message only.
+
+    Walks history backwards to the last request carrying a ``UserPromptPart``
+    (an actual user turn, not a tool return) and collects its image parts in
+    order. Returns an empty list when the latest user turn has no images.
+    """
+    if not messages:
+        return []
+    for message in reversed(list(messages)):
+        parts = getattr(message, "parts", None)
+        if not parts:
+            continue
+        user_parts = [part for part in parts if isinstance(part, UserPromptPart)]
+        if not user_parts:
+            continue
+        images: List[BinaryContent] = []
+        for part in user_parts:
+            content = part.content
+            if isinstance(content, str):
+                continue
+            for item in content:
+                if _is_image(item):
+                    images.append(item)
+        return images
+    return []
+
+
+def _extension_for(media_type: str | None) -> str:
+    guessed = mimetypes.guess_extension(media_type or "") if media_type else None
+    if guessed in {".jpe", ".jpeg"}:
+        return ".jpg"
+    return guessed or ".png"
+
+
+def _save_reference_images(images: Sequence[BinaryContent]) -> List[Path]:
+    """Write each image to the Code Puppy data dir and return the paths."""
+    if not images:
+        return []
+    output_dir = Path(config.DATA_DIR) / "attachment_references"
+    output_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    saved: List[Path] = []
+    for image in images:
+        extension = _extension_for(getattr(image, "media_type", None))
+        output_path = output_dir / f"attachment-{uuid.uuid4().hex}{extension}"
+        temporary_path = output_dir / f"{output_path.name}.tmp"
+        try:
+            temporary_path.write_bytes(image.data)
+            os.chmod(temporary_path, 0o600)
+            temporary_path.replace(output_path)
+        except OSError:
+            temporary_path.unlink(missing_ok=True)
+            raise
+        saved.append(output_path)
+    return saved
+
+
+def register_save_attachments_as_references(agent: Any) -> None:
+    """Register the attachment-to-reference bridge on a pydantic-ai agent."""
+
+    @agent.tool
+    async def save_attachments_as_references(context: RunContext) -> dict[str, Any]:
+        """Save images the user attached in their latest message to disk.
+
+        Use this to turn a pasted or dragged image into a real file path so
+        other tools can act on it. In particular, pass the returned paths to
+        ``codex_imagegen`` as ``reference_images`` to generate a new image that
+        preserves the subject or style of what the user just shared.
+
+        Only images from the most recent user message are saved. Returns the
+        saved file paths; the paths are stable on disk under the Code Puppy
+        data directory.
+        """
+        images = _extract_latest_user_images(getattr(context, "messages", None))
+        if not images:
+            return {
+                "success": True,
+                "paths": [],
+                "count": 0,
+                "message": (
+                    "No image attachments were found in the latest user message."
+                ),
+            }
+        try:
+            paths = await asyncio.to_thread(_save_reference_images, images)
+        except OSError as exc:
+            return {
+                "success": False,
+                "error": f"Could not save reference images: {exc}",
+            }
+        return {
+            "success": True,
+            "paths": [str(path) for path in paths],
+            "count": len(paths),
+        }
+
+
+def register_tools_callback() -> list[dict[str, Any]]:
+    return [
+        {
+            "name": TOOL_NAME,
+            "register_func": register_save_attachments_as_references,
+        }
+    ]

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.71}/code_puppy_core_plugins/copilot_auth/reasoning_client.py

@@ -10,7 +10,7 @@ pydantic-ai's ``openai_chat_send_back_thinking_parts="field"`` mode preserves
 ``reasoning_opaque``.  The Copilot API returns **400 Bad Request** if
 ``reasoning_text`` is sent without the accompanying ``reasoning_opaque``.
 
-This module monkey-patches the httpx client to transparently:
+This module monkey-patches the httpx2 client to transparently:
 
 1. Capture ``reasoning_opaque`` (keyed by ``reasoning_text``) from responses
 2. Inject the matching ``reasoning_opaque`` into outgoing request messages
@@ -25,8 +25,8 @@ import json
 import logging
 from typing import Any, Dict
 
-import httpx
-from httpx import AsyncByteStream
+import httpx2
+from httpx2 import AsyncByteStream
 
 logger = logging.getLogger(__name__)
 
@@ -57,8 +57,8 @@ class _OpaqueCapturingStream(AsyncByteStream):
     lines, parses JSON, and pairs ``reasoning_text`` chunks with
     ``reasoning_opaque`` chunks for storage in *opaque_cache*.
 
-    Inherits from ``httpx.AsyncByteStream`` so that
-    ``httpx.Response.aclose()`` recognises us as an async stream and
+    Inherits from ``httpx2.AsyncByteStream`` so that
+    ``httpx2.Response.aclose()`` recognises us as an async stream and
     doesn't blow up with *"Attempted to call an async close on an sync
     stream"*.  Ask me how I know.
     """
@@ -188,9 +188,9 @@ def _capture_from_content(
 
 
 def _rebuild_request_body(
-    request: httpx.Request,
+    request: httpx2.Request,
     body: dict,
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
 ) -> None:
     """Replace the request body in-place (mirrors ChatGPTCodexAsyncClient)."""
     new_body = json.dumps(body).encode("utf-8")
@@ -210,9 +210,9 @@ def _rebuild_request_body(
 
 
 def _inject_opaque_into_request(
-    request: httpx.Request,
+    request: httpx2.Request,
     opaque_cache: Dict[str, str],
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
     thinking_field: str,
 ) -> None:
     """Add stored ``reasoning_opaque`` to assistant messages that need it.
@@ -288,8 +288,8 @@ def _inject_opaque_into_request(
 
 
 def _strip_all_reasoning_fields(
-    request: httpx.Request,
-    client: httpx.AsyncClient,
+    request: httpx2.Request,
+    client: httpx2.AsyncClient,
     thinking_field: str,
 ) -> bool:
     """Remove ALL reasoning fields from the request body.
@@ -340,17 +340,17 @@ def _strip_all_reasoning_fields(
 
 
 def patch_client_for_reasoning_opaque(
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
     thinking_field: str = "reasoning_text",
 ) -> None:
     """Monkey-patch *client* to round-trip ``reasoning_opaque`` transparently.
 
     Call **after** creating the client but **before** handing it to
-    ``OpenAIProvider``.  Works with plain ``httpx.AsyncClient`` and the
+    ``OpenAIProvider``.  Works with plain ``httpx2.AsyncClient`` and the
     ``RetryingAsyncClient`` subclass returned by ``create_async_client``.
 
     Args:
-        client: The httpx async client to patch.
+        client: The httpx2 async client to patch.
         thinking_field: JSON field name that carries the thinking content
             (default ``"reasoning_text"`` — the Copilot Claude convention).
     """
@@ -358,8 +358,8 @@ def patch_client_for_reasoning_opaque(
     original_send = client.send
 
     async def _patched_send(
-        request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+        request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:
         # 1) Inject reasoning_opaque into outgoing POST bodies.
         #    Also strips orphaned reasoning_text with no cached opaque.
         if request.method == "POST":

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.71}/code_puppy_core_plugins/copilot_auth/register_callbacks.py

@@ -371,11 +371,11 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
     GPT-5.6 family, Codex, Grok, ...) are built as ``OpenAIResponsesModel``;
     everything else keeps using Chat Completions.
     """
-    import httpx
+    import httpx2
     from pydantic_ai.models.openai import OpenAIChatModel, OpenAIResponsesModel
     from pydantic_ai.providers.openai import OpenAIProvider
 
-    from code_puppy.http_utils import create_async_client
+    from code_puppy.httpx2_utils import create_async_client
 
     # Discover token — match against the host stored in the model config
     host = model_config.get("copilot_host", "github.com")
@@ -405,14 +405,14 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
         "Openai-Intent": COPILOT_AUTH_CONFIG["openai_intent"],
     }
 
-    class _CopilotAuth(httpx.Auth):
-        """httpx auth flow that refreshes the Copilot session token per-request."""
+    class _CopilotAuth(httpx2.Auth):
+        """httpx2 auth flow that refreshes the Copilot session token per-request."""
 
         def __init__(self, oauth_token: str, token_host: str):
             self._oauth_token = oauth_token
             self._host = token_host
 
-        def auth_flow(self, request: httpx.Request):
+        def auth_flow(self, request: httpx2.Request):
             token = get_valid_session_token(self._oauth_token, self._host)
             if token:
                 request.headers["Authorization"] = f"Bearer {token}"
@@ -447,7 +447,7 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
         from .reasoning_client import patch_client_for_reasoning_opaque
 
         # Field-mode so thinking persists across tool calls; the reasoning_opaque
-        # interceptor (patched onto the httpx client) re-injects the encrypted blob
+        # interceptor (patched onto the httpx2 client) re-injects the encrypted blob
         # into subsequent requests, preventing 400s.
         profile = OpenAIModelProfile(
             openai_chat_thinking_field="reasoning_text",

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.71}/code_puppy_core_plugins/copilot_auth/responses_stream.py

@@ -14,7 +14,7 @@ brand-new part: tool calls come through with empty ``arguments`` (the
 ``read_file ... Field required: file_path`` failure) and assistant text is
 split into one part per delta.
 
-This module wraps the httpx response byte-stream and rewrites each event so
+This module wraps the httpx2 response byte-stream and rewrites each event so
 every item keeps the first id seen for its ``output_index``.  Bytes that
 are not SSE ``data:`` JSON events pass through untouched.  The wrapper
 follows the ``_OpaqueCapturingStream`` pattern in ``reasoning_client``.
@@ -26,8 +26,8 @@ import json
 import logging
 from typing import Any, Dict
 
-import httpx
-from httpx import AsyncByteStream
+import httpx2
+from httpx2 import AsyncByteStream
 
 logger = logging.getLogger(__name__)
 
@@ -112,7 +112,7 @@ class _StableIdStream(AsyncByteStream):
     Buffers bytes, splits on newlines, rewrites ``data:`` JSON events via
     :func:`normalise_event_ids`, and re-emits them.  Everything else (event
     lines, blank separators, ``[DONE]``, unparseable payloads) is forwarded
-    verbatim.  Inherits ``httpx.AsyncByteStream`` so ``Response.aclose()``
+    verbatim.  Inherits ``httpx2.AsyncByteStream`` so ``Response.aclose()``
     treats it as an async stream.
     """
 
@@ -166,7 +166,7 @@ class _StableIdStream(AsyncByteStream):
         return b"data: " + json.dumps(event, ensure_ascii=False).encode("utf-8")
 
 
-def _is_responses_sse(request: httpx.Request, response: httpx.Response) -> bool:
+def _is_responses_sse(request: httpx2.Request, response: httpx2.Response) -> bool:
     if request.method != "POST" or not request.url.path.rstrip("/").endswith(
         "/responses"
     ):
@@ -175,7 +175,7 @@ def _is_responses_sse(request: httpx.Request, response: httpx.Response) -> bool:
     return "text/event-stream" in content_type.lower()
 
 
-def patch_client_for_stable_ids(client: httpx.AsyncClient) -> None:
+def patch_client_for_stable_ids(client: httpx2.AsyncClient) -> None:
     """Monkey-patch *client* so ``/responses`` SSE streams carry stable ids.
 
     Call after creating the client and before handing it to
@@ -186,8 +186,8 @@ def patch_client_for_stable_ids(client: httpx.AsyncClient) -> None:
     original_send = client.send
 
     async def _patched_send(
-        request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+        request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:
         response = await original_send(request, *args, **kwargs)
         if (
             response.status_code == 200

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.71}/code_puppy_core_plugins/jev_grep/chunks.py

@@ -1,15 +1,15 @@
 """Discovery and chunking: turn a directory into judgeable source snippets.
 
-Python files are split along the
-AST (functions and methods stay whole; declarations longer than
-``SPLIT_LINES`` are split into the blocks inside them so each snippet is one
-behaviour). Every other file falls back to overlapping line windows. Line
-coverage is exact: every non-blank line lands in at least one snippet.
+Source files are split along their syntax tree (see ``structure.py``):
+functions and methods stay whole, long declarations split into the blocks
+inside them. Python uses the stdlib ``ast``; JavaScript/TypeScript, Go, Rust
+and Java use tree-sitter (``treesitter.py``). Everything else, and any file
+that does not parse, falls back to overlapping line windows. Line coverage
+is exact: every non-blank line lands in at least one snippet.
 """
 
 from __future__ import annotations
 
-import ast
 import os
 import subprocess
 from collections import Counter
@@ -17,6 +17,9 @@ from dataclasses import dataclass, field
 
 from code_puppy.tools.ripgrep import find_ripgrep
 
+from .structure import Range, python_ranges
+from .treesitter import treesitter_ranges
+
 # Discovery is bounded by files and bytes only. Snippet count is not capped:
 # only the ranked shortlist is judged, and local BM25 over the ~24k snippets
 # of a repo root takes well under a second.
@@ -25,7 +28,6 @@ MAX_FILE_BYTES = 1024 * 1024
 MAX_TOTAL_BYTES = 32 * 1024 * 1024
 MAX_CHUNK_CHARS = 12_000
 WHOLE_DECLARATION_LINES = 160
-SPLIT_LINES = 24
 WINDOW, OVERLAP = 60, 10
 
 
@@ -50,13 +52,6 @@ class Discovery:
     parsers: Counter = field(default_factory=Counter)
 
 
-@dataclass
-class _Range:
-    start: int
-    end: int
-    symbol: str | None
-
-
 def windows(
     lines: list[str],
     path: str,
@@ -90,99 +85,8 @@ def windows(
     return out
 
 
-def _begin(node: ast.AST) -> int:
-    decorators = getattr(node, "decorator_list", [])
-    return min([node.lineno, *(d.lineno for d in decorators)])
-
-
-def _partition(node: ast.AST, start: int, end: int, symbol, depth: int = 0):
-    """Split a long body into its blocks, covering every line of [start, end]."""
-    body = getattr(node, "body", None)
-    if not isinstance(body, list) or end - start < SPLIT_LINES:
-        return None
-    stmts = [s for s in body if hasattr(s, "end_lineno")]
-    if not stmts:
-        return None
-    if len(stmts) == 1:
-        return (
-            _partition(stmts[0], start, end, symbol, depth + 1) if depth < 3 else None
-        )
-
-    out: list[_Range] = []
-    cursor = start
-    group: list[ast.stmt] = []
-
-    def flush(last: bool) -> None:
-        nonlocal cursor
-        if not group:
-            return
-        stop = end if last else min(end, group[-1].end_lineno)
-        if stop >= cursor:
-            inner = None
-            if len(group) == 1 and depth < 3:
-                inner = _partition(group[0], cursor, stop, symbol, depth + 1)
-            out.extend(inner or [_Range(cursor, stop, symbol)])
-            cursor = stop + 1
-        group.clear()
-
-    for stmt in stmts:
-        span = stmt.end_lineno - _begin(stmt) + 1
-        if group and (span >= 6 or stmt.end_lineno - cursor + 1 > 20):
-            flush(False)
-        group.append(stmt)
-        if span >= 6 and stmt is not stmts[-1]:
-            flush(False)
-    flush(True)
-    return out if len(out) > 1 else None
-
-
-def _python_ranges(text: str) -> list[_Range]:
-    tree = ast.parse(text)
-    ranges: list[_Range] = []
-
-    def emit(node: ast.AST, start: int, symbol: str | None) -> None:
-        ranges.extend(
-            _partition(node, start, node.end_lineno, symbol)
-            or [_Range(start, node.end_lineno, symbol)]
-        )
-
-    for node in tree.body:
-        if isinstance(node, ast.ClassDef):
-            ranges.append(_Range(_begin(node), node.body[0].lineno - 1, node.name))
-            for member in node.body:
-                name = getattr(member, "name", "body")
-                emit(member, _begin(member), f"{node.name}.{name}")
-        else:
-            emit(node, _begin(node), getattr(node, "name", None))
-    return _merge_short_neighbours(ranges)
-
-
-def _merge_short_neighbours(ranges: list[_Range]) -> list[_Range]:
-    """Fold runs of imports/one-liners into one target (each costs a judgment)."""
-
-    def mergeable(r: _Range) -> bool:
-        return r.end - r.start <= 1 and "." not in (r.symbol or "")
-
-    merged: list[_Range] = []
-    for r in ranges:
-        last = merged[-1] if merged else None
-        if (
-            last
-            and mergeable(last)
-            and mergeable(r)
-            and r.start <= last.end + 1
-            and r.end - last.start < 12
-            and len(f"{last.symbol} {r.symbol}") < 60
-        ):
-            names = dict.fromkeys(s for s in (last.symbol, r.symbol) if s)
-            last.end, last.symbol = r.end, ", ".join(names) or None
-        else:
-            merged.append(_Range(r.start, r.end, r.symbol))
-    return merged
-
-
 def _chunks_from_ranges(
-    lines: list[str], path: str, ranges: list[_Range]
+    lines: list[str], path: str, ranges: list[Range]
 ) -> list[Chunk]:
     out: list[Chunk] = []
     next_line = 1
@@ -208,11 +112,14 @@ def source_chunks(text: str, path: str) -> tuple[list[Chunk], str]:
     lines = text.splitlines()
     if path.endswith(".py"):
         try:
-            ranges = _python_ranges(text)
+            ranges = python_ranges(text)
         except (SyntaxError, ValueError, RecursionError):
             ranges = []
         if ranges:
             return _chunks_from_ranges(lines, path, ranges), "python"
+    elif parsed := treesitter_ranges(text, path):
+        ranges, parser = parsed
+        return _chunks_from_ranges(lines, path, ranges), parser
     return windows(lines, path), "overlapping-lines"