code-puppy-core-plugins 0.0.70__tar.gz → 0.0.72__tar.gz

{code_puppy_core_plugins-0.0.70 → code_puppy_core_plugins-0.0.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.70
+Version: 0.0.72
 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
@@ -18,6 +18,12 @@ 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.72/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.72/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.72/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.70 → code_puppy_core_plugins-0.0.72}/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"
 
 

code_puppy_core_plugins-0.0.72/code_puppy_core_plugins/jev_grep/structure.py

@@ -0,0 +1,168 @@
+"""Language-agnostic structural chunking: declarations -> line ranges.
+
+One algorithm for every parser. A language plugs in by implementing
+:class:`Syntax` (Python via stdlib ``ast`` here, others via tree-sitter in
+``treesitter.py``):
+
+* containers (classes, impls, modules) are split into a header plus one
+  range per member, named ``Container.member``;
+* declarations of ``SPLIT_LINES`` or more are split into the blocks inside
+  them, so each range is one behaviour. Splits cover every line of the
+  original range, so coverage is unchanged;
+* runs of short neighbours (imports, one-liners) merge into one range,
+  since each range costs a relevance judgment.
+"""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+SPLIT_LINES = 24
+_MAX_DEPTH = 3
+
+
+@dataclass
+class Range:
+    start: int
+    end: int
+    symbol: str | None
+
+
+class Syntax(Protocol):
+    """What the chunker needs to know about one language's tree."""
+
+    def span(self, node: Any) -> tuple[int, int]:
+        """1-based first and last line, including decorators/wrappers."""
+
+    def symbol(self, node: Any) -> str | None:
+        """The declared name, if any."""
+
+    def members(self, node: Any) -> Sequence[Any] | None:
+        """Member declarations when ``node`` is a container, else None."""
+
+    def statements(self, node: Any) -> Sequence[Any] | None:
+        """The statements of ``node``'s body, if it has one."""
+
+
+def partition(node: Any, start: int, end: int, symbol, syntax: Syntax, depth=0):
+    """Split a long body into its blocks, covering every line of [start, end]."""
+    body = syntax.statements(node)
+    if not body or end - start < SPLIT_LINES:
+        return None
+    if len(body) == 1:
+        if depth >= _MAX_DEPTH:
+            return None
+        return partition(body[0], start, end, symbol, syntax, depth + 1)
+
+    out: list[Range] = []
+    cursor = start
+    group: list[Any] = []
+
+    def flush(last: bool) -> None:
+        nonlocal cursor
+        if not group:
+            return
+        stop = end if last else min(end, syntax.span(group[-1])[1])
+        if stop >= cursor:
+            inner = None
+            if len(group) == 1 and depth < _MAX_DEPTH:
+                inner = partition(group[0], cursor, stop, symbol, syntax, depth + 1)
+            out.extend(inner or [Range(cursor, stop, symbol)])
+            cursor = stop + 1
+        group.clear()
+
+    for index, stmt in enumerate(body):
+        first, last = syntax.span(stmt)
+        span = last - first + 1
+        if group and (span >= 6 or last - cursor + 1 > 20):
+            flush(False)
+        group.append(stmt)
+        if span >= 6 and index != len(body) - 1:
+            flush(False)
+    flush(True)
+    return out if len(out) > 1 else None
+
+
+def structure_ranges(nodes: Sequence[Any], syntax: Syntax) -> list[Range]:
+    """Ranges for a file's top-level nodes."""
+    ranges: list[Range] = []
+
+    def walk(node: Any, prefix: str | None) -> None:
+        start, end = syntax.span(node)
+        name = syntax.symbol(node)
+        symbol = f"{prefix}.{name or 'body'}" if prefix else name
+        members = syntax.members(node)
+        if members:
+            header_end = syntax.span(members[0])[0] - 1
+            if header_end >= start:
+                ranges.append(Range(start, header_end, symbol))
+            for member in members:
+                walk(member, symbol or "body")
+            # The container's tail (a closing brace) joins its last member
+            # rather than becoming a judgment-costing snippet of its own.
+            if ranges and ranges[-1].end < end:
+                ranges[-1].end = end
+            return
+        ranges.extend(
+            partition(node, start, end, symbol, syntax) or [Range(start, end, symbol)]
+        )
+
+    for node in nodes:
+        walk(node, 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).
+
+    Members (dotted symbols) never merge, so a method is never folded into its
+    container's header or a neighbour.
+    """
+
+    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
+
+
+class PythonSyntax:
+    """:class:`Syntax` over the standard library ``ast``."""
+
+    def span(self, node: ast.AST) -> tuple[int, int]:
+        decorators = getattr(node, "decorator_list", [])
+        return min([node.lineno, *(d.lineno for d in decorators)]), node.end_lineno
+
+    def symbol(self, node: ast.AST) -> str | None:
+        return getattr(node, "name", None)
+
+    def members(self, node: ast.AST) -> Sequence[ast.AST] | None:
+        return node.body if isinstance(node, ast.ClassDef) else None
+
+    def statements(self, node: ast.AST) -> Sequence[ast.AST] | None:
+        body = getattr(node, "body", None)
+        if not isinstance(body, list):
+            return None
+        return [s for s in body if hasattr(s, "end_lineno")]
+
+
+def python_ranges(text: str) -> list[Range]:
+    """Raises SyntaxError/ValueError/RecursionError on unparseable source."""
+    return structure_ranges(ast.parse(text).body, PythonSyntax())