code-puppy-core-plugins 0.0.2__tar.gz → 0.0.5__tar.gz

{code_puppy_core_plugins-0.0.2 → code_puppy_core_plugins-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.2
+Version: 0.0.5
 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
@@ -14,6 +14,7 @@ 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: httpx<1,>=0.24.1
 Description-Content-Type: text/markdown
 
 # Code Puppy Core Plugins

{code_puppy_core_plugins-0.0.2 → code_puppy_core_plugins-0.0.5}/code_puppy_core_plugins/agent_skills/remote_catalog.py

@@ -156,8 +156,8 @@ def _fetch_remote_json(url: str) -> Optional[dict[str, Any]]:
             f"{e.response.status_code} {e.response.reason_phrase}"
         )
         return None
-    except (httpx.ConnectError, httpx.TimeoutException, httpx.NetworkError) as e:
-        logger.warning(f"Remote catalog network failure: {e}")
+    except httpx.TransportError as e:
+        logger.debug(f"Remote catalog network failure: {e}")
         return None
     except json.JSONDecodeError as e:
         logger.warning(f"Remote catalog returned invalid JSON: {e}")
@@ -296,7 +296,7 @@ def fetch_remote_catalog(force_refresh: bool = False) -> Optional[RemoteCatalogD
             f"(cache_path={_CACHE_PATH}, fresh={cache_fresh})"
         )
     else:
-        logger.info("No cache present; fetching remote skills catalog")
+        logger.debug("No cache present; fetching remote skills catalog")
 
     remote_raw = _fetch_remote_json(SKILLS_JSON_URL)
     if remote_raw is not None:
@@ -309,7 +309,7 @@ def fetch_remote_catalog(force_refresh: bool = False) -> Optional[RemoteCatalogD
 
     # Offline fallback: use cache even if expired.
     if _CACHE_PATH.exists():
-        logger.warning(
+        logger.debug(
             "Remote fetch failed; falling back to cached skills catalog "
             f"(even if expired): {_CACHE_PATH}"
         )
@@ -318,5 +318,5 @@ def fetch_remote_catalog(force_refresh: bool = False) -> Optional[RemoteCatalogD
             return None
         return _parse_catalog(cached)
 
-    logger.error("Remote fetch failed and no cache is available")
+    logger.debug("Remote fetch failed and no cache is available")
     return None

{code_puppy_core_plugins-0.0.2 → code_puppy_core_plugins-0.0.5}/code_puppy_core_plugins/agent_skills/skill_catalog.py

@@ -13,12 +13,14 @@ Public API:
     )
 
 If the remote catalog can't be fetched (and there's no cache), the catalog is
-empty by default (and we log a warning).
+empty by default. Loading is deferred until a catalog-backed operation needs it.
 """
 
 from __future__ import annotations
 
 import logging
+import threading
+import time
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional
@@ -26,6 +28,7 @@ from typing import List, Optional
 from code_puppy_core_plugins.agent_skills.remote_catalog import fetch_remote_catalog
 
 logger = logging.getLogger(__name__)
+_RETRY_DELAY_SECONDS = 60
 
 
 _ACRONYMS = {
@@ -133,47 +136,59 @@ class SkillCatalog:
         self._entries: list[SkillCatalogEntry] = []
         self._by_id: dict[str, SkillCatalogEntry] = {}
         self._by_category: dict[str, list[SkillCatalogEntry]] = {}
+        self._loaded = False
+        self._next_retry_at = 0.0
+        self._load_lock = threading.Lock()
 
-        try:
-            remote = fetch_remote_catalog()
-        except Exception as e:
-            # fetch_remote_catalog should already be defensive, but let's be extra safe.
-            logger.warning(f"Failed to fetch remote catalog: {e}")
-            remote = None
-
-        if remote is None:
-            logger.warning(
-                "Remote skill catalog unavailable (no network and no cache). "
-                "Catalog will be empty."
-            )
+    def _load(self) -> None:
+        """Load the optional remote catalog, retrying after bounded failures."""
+
+        if self._loaded or time.monotonic() < self._next_retry_at:
             return
 
-        entries: list[SkillCatalogEntry] = []
-
-        for remote_entry in remote.entries:
-            skill_id = remote_entry.name
-            entry = SkillCatalogEntry(
-                id=skill_id,
-                name=remote_entry.name,
-                display_name=_format_display_name(remote_entry.name),
-                description=remote_entry.description,
-                category=remote_entry.group,
-                tags=[],
-                source_path=None,
-                has_scripts=remote_entry.has_scripts,
-                has_references=remote_entry.has_references,
-                file_count=remote_entry.file_count,
-                download_url=remote_entry.download_url,
-                zip_size_bytes=remote_entry.zip_size_bytes,
+        with self._load_lock:
+            if self._loaded or time.monotonic() < self._next_retry_at:
+                return
+
+            try:
+                remote = fetch_remote_catalog()
+            except Exception as e:
+                logger.debug(f"Failed to fetch remote catalog: {e}")
+                self._next_retry_at = time.monotonic() + _RETRY_DELAY_SECONDS
+                return
+
+            if remote is None:
+                logger.debug("Remote skill catalog unavailable; catalog will be empty.")
+                self._next_retry_at = time.monotonic() + _RETRY_DELAY_SECONDS
+                return
+
+            entries: list[SkillCatalogEntry] = []
+
+            for remote_entry in remote.entries:
+                skill_id = remote_entry.name
+                entry = SkillCatalogEntry(
+                    id=skill_id,
+                    name=remote_entry.name,
+                    display_name=_format_display_name(remote_entry.name),
+                    description=remote_entry.description,
+                    category=remote_entry.group,
+                    tags=[],
+                    source_path=None,
+                    has_scripts=remote_entry.has_scripts,
+                    has_references=remote_entry.has_references,
+                    file_count=remote_entry.file_count,
+                    download_url=remote_entry.download_url,
+                    zip_size_bytes=remote_entry.zip_size_bytes,
+                )
+                entries.append(entry)
+
+            self._rebuild_indices(entries)
+            self._loaded = True
+
+            logger.info(
+                f"Loaded remote skill catalog: {len(self._entries)} skills in "
+                f"{len(self._by_category)} categories"
             )
-            entries.append(entry)
-
-        self._rebuild_indices(entries)
-
-        logger.info(
-            f"Loaded remote skill catalog: {len(self._entries)} skills in "
-            f"{len(self._by_category)} categories"
-        )
 
     def _rebuild_indices(self, entries: list[SkillCatalogEntry]) -> None:
         """Rebuild internal lookup indices from the loaded entries."""
@@ -198,12 +213,14 @@ class SkillCatalog:
     def list_categories(self) -> List[str]:
         """List all categories."""
 
+        self._load()
         categories = {e.category for e in self._entries if e.category}
         return sorted(categories, key=lambda c: c.casefold())
 
     def get_by_category(self, category: str) -> List[SkillCatalogEntry]:
         """Return all entries in a category (case-insensitive)."""
 
+        self._load()
         if not category:
             return []
         return list(self._by_category.get(category.casefold(), []))
@@ -211,6 +228,7 @@ class SkillCatalog:
     def search(self, query: str) -> List[SkillCatalogEntry]:
         """Search by substring over id/name/display_name/description/tags/category."""
 
+        self._load()
         q = (query or "").strip().casefold()
         if not q:
             return self.get_all()
@@ -234,6 +252,7 @@ class SkillCatalog:
     def get_by_id(self, skill_id: str) -> Optional[SkillCatalogEntry]:
         """Get a skill entry by id (case-sensitive exact match)."""
 
+        self._load()
         if not skill_id:
             return None
         return self._by_id.get(skill_id)
@@ -241,6 +260,7 @@ class SkillCatalog:
     def get_all(self) -> List[SkillCatalogEntry]:
         """Return all entries."""
 
+        self._load()
         return list(self._entries)
 
 

code_puppy_core_plugins-0.0.5/code_puppy_core_plugins/spill/LICENSE.deepseek

@@ -0,0 +1,28 @@
+DeepSeek Harness spill attribution
+
+The spill functionality in this package is based on the spill packages from
+DeepSeek Harness:
+
+https://github.com/deepseek-ai/DeepSeek-Harness
+
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

code_puppy_core_plugins-0.0.5/code_puppy_core_plugins/spill/__init__.py

@@ -0,0 +1 @@
+"""Keep oversized dict-shaped tool results out of model context."""

code_puppy_core_plugins-0.0.5/code_puppy_core_plugins/spill/register_callbacks.py

@@ -0,0 +1,235 @@
+"""Plugin: spill oversized dict-shaped tool results to private files.
+
+Ported from DeepSeek Harness's MIT-licensed spill design. See
+``LICENSE.deepseek`` in this package for its copyright and license notice.
+
+The post-tool hook receives the same dict reference that Code Puppy later
+serializes for the model, so this plugin can replace top-level string fields
+in place. Non-dict results (notably plain strings) cannot be replaced through
+this hook and are deliberately left untouched.
+
+When the combined UTF-8 size of top-level string values exceeds the configured
+cap, fields are considered largest-first. Their full text is saved verbatim,
+then replaced by a bounded byte-sliced head/tail preview and a retrieval notice.
+``read_file`` is skipped by default to avoid a read -> spill -> read loop.
+Every failure is best-effort: the successful tool result stays available inline.
+
+Config (puppy.cfg, also settable with ``/set``):
+    spill_max_inline_bytes = 32768  # 0 or negative disables
+    spill_preview_bytes = 4096      # source bytes retained per field
+    spill_root =                    # unset uses a private OS temp directory
+    spill_skip_tools = read_file    # comma-separated tool names
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from pathlib import Path
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from . import store
+
+logger = logging.getLogger(__name__)
+
+MAX_INLINE_KEY = "spill_max_inline_bytes"
+PREVIEW_KEY = "spill_preview_bytes"
+ROOT_KEY = "spill_root"
+SKIP_TOOLS_KEY = "spill_skip_tools"
+DEFAULT_MAX_INLINE_BYTES = 32768
+DEFAULT_PREVIEW_BYTES = 4096
+DEFAULT_SKIP_TOOLS = frozenset({"read_file"})
+OMISSION_MARKER = "\n\n[...]\n\n"
+
+
+def _get_value(key: str) -> Any:
+    try:
+        from code_puppy.config import get_value
+
+        return get_value(key)
+    except Exception:
+        return None
+
+
+def _get_int(key: str, default: int) -> int:
+    raw = _get_value(key)
+    if raw is None or str(raw).strip() == "":
+        return default
+    try:
+        return int(str(raw).strip())
+    except (TypeError, ValueError):
+        logger.warning("Invalid %s value; falling back to %d", key, default)
+        return default
+
+
+def _get_root() -> str | None:
+    raw = _get_value(ROOT_KEY)
+    if raw is None or not str(raw).strip():
+        return None
+    return str(raw).strip()
+
+
+def _get_skip_tools() -> frozenset[str]:
+    raw = _get_value(SKIP_TOOLS_KEY)
+    if raw is None or not str(raw).strip():
+        return DEFAULT_SKIP_TOOLS
+    return frozenset(name.strip() for name in str(raw).split(",") if name.strip())
+
+
+def _byte_size(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def _preview(text: str, budget: int) -> tuple[str, int]:
+    """Return a byte-sliced preview and the count of omitted source bytes."""
+    encoded = text.encode("utf-8")
+    kept_bytes = min(max(0, budget), len(encoded))
+    if kept_bytes == 0:
+        return "", len(encoded)
+    head_bytes = math.ceil(kept_bytes / 2)
+    tail_bytes = math.floor(kept_bytes / 2)
+    head = encoded[:head_bytes].decode("utf-8", errors="replace")
+    tail = encoded[-tail_bytes:].decode("utf-8", errors="replace") if tail_bytes else ""
+    return f"{head}{OMISSION_MARKER}{tail}", len(encoded) - kept_bytes
+
+
+def _notice(omitted: int, path: Path) -> str:
+    return (
+        f"(~{omitted} bytes omitted. Full output stored at: {path}. "
+        "Retrieve it with read_file using start_line/num_lines, or grep this path.)"
+    )
+
+
+def _build_replacement(
+    text: str,
+    path: Path,
+    preview_bytes: int,
+    max_bytes: int | None,
+) -> str | None:
+    """Build a strictly smaller replacement, optionally fitting ``max_bytes``."""
+    original_bytes = _byte_size(text)
+    budget = min(max(0, preview_bytes), original_bytes)
+    limit = original_bytes - 1
+    if max_bytes is not None:
+        limit = min(limit, max_bytes)
+    if limit < 0:
+        return None
+
+    while True:
+        preview, omitted = _preview(text, budget)
+        notice = _notice(omitted, path)
+        replacement = f"{preview}\n\n{notice}" if preview else notice
+        replacement_bytes = _byte_size(replacement)
+        if replacement_bytes <= limit:
+            return replacement
+        if budget == 0:
+            return None
+        budget = max(0, budget - max(1, replacement_bytes - limit))
+
+
+def _spill_result(tool_name: str, result: dict[Any, Any]) -> None:
+    cap = _get_int(MAX_INLINE_KEY, DEFAULT_MAX_INLINE_BYTES)
+    if cap <= 0 or tool_name in _get_skip_tools():
+        return
+    preview_bytes = _get_int(PREVIEW_KEY, DEFAULT_PREVIEW_BYTES)
+    if preview_bytes < 0:
+        logger.warning(
+            "Invalid %s value; falling back to %d",
+            PREVIEW_KEY,
+            DEFAULT_PREVIEW_BYTES,
+        )
+        preview_bytes = DEFAULT_PREVIEW_BYTES
+
+    fields = [
+        (key, value, _byte_size(value))
+        for key, value in result.items()
+        if isinstance(value, str)
+    ]
+    total = sum(size for _, _, size in fields)
+    if total <= cap:
+        return
+
+    replacements: dict[Any, str] = {}
+    for key, original, original_bytes in sorted(
+        fields, key=lambda item: item[2], reverse=True
+    ):
+        if total <= cap:
+            break
+        try:
+            path = store.save_text(original, tool_name, _get_root())
+        except Exception:
+            logger.warning(
+                "Failed to spill %s result field %r; keeping it inline",
+                tool_name,
+                key,
+                exc_info=True,
+            )
+            continue
+
+        other_bytes = total - original_bytes
+        field_limit = cap - other_bytes if other_bytes < cap else None
+        replacement = _build_replacement(
+            original,
+            path,
+            preview_bytes,
+            field_limit,
+        )
+        if replacement is None:
+            logger.warning(
+                "Spill notice for %s result field %r cannot fit; keeping it inline",
+                tool_name,
+                key,
+            )
+            continue
+        replacements[key] = replacement
+        total = other_bytes + _byte_size(replacement)
+
+    # Commit atomically. A partial preview set that still exceeds the cap is
+    # neither bounded nor graceful; keep every original inline in that case.
+    if total <= cap:
+        result.update(replacements)
+
+
+def _on_post_tool_call(
+    tool_name: str,
+    tool_args: dict,
+    result: Any,
+    duration_ms: float,
+    context: Any = None,
+) -> None:
+    """Spill oversized top-level string fields without breaking tool calls."""
+    _ = tool_args, duration_ms, context
+    try:
+        if not isinstance(result, dict) or set(result) == {"error"}:
+            return
+        _spill_result(tool_name, result)
+    except Exception:
+        logger.debug(
+            "spill plugin failed; keeping the tool result inline", exc_info=True
+        )
+
+
+def _reset_state() -> None:
+    """Reset lazy process storage state for tests and defensive re-init."""
+    store._reset_state()
+
+
+register_callback("post_tool_call", _on_post_tool_call)
+
+
+__all__ = [
+    "DEFAULT_MAX_INLINE_BYTES",
+    "DEFAULT_PREVIEW_BYTES",
+    "DEFAULT_SKIP_TOOLS",
+    "MAX_INLINE_KEY",
+    "PREVIEW_KEY",
+    "ROOT_KEY",
+    "SKIP_TOOLS_KEY",
+    "_build_replacement",
+    "_get_int",
+    "_on_post_tool_call",
+    "_reset_state",
+    "_spill_result",
+]

code_puppy_core_plugins-0.0.5/code_puppy_core_plugins/spill/store.py

@@ -0,0 +1,97 @@
+"""Private local storage for spilled tool-result text."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import secrets
+import tempfile
+import uuid
+from pathlib import Path
+
+_default_root: Path | None = None
+_process_session_id: str | None = None
+_UNSAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
+
+
+def private_root(configured_root: str | None = None) -> Path:
+    """Return the configured root or a lazy private per-process temp root."""
+    global _default_root
+    if configured_root:
+        root = Path(configured_root).expanduser().resolve()
+        root.mkdir(mode=0o700, parents=True, exist_ok=True)
+        return root
+    if _default_root is None:
+        _default_root = Path(tempfile.mkdtemp(prefix="code-puppy-spill-"))
+    return _default_root
+
+
+def current_session_id() -> str:
+    """Return the active agent session id, with a stable process fallback."""
+    global _process_session_id
+    try:
+        from code_puppy.messaging import get_session_context
+
+        session_id = get_session_context()
+        if session_id:
+            return str(session_id)
+    except Exception:
+        pass
+    if _process_session_id is None:
+        _process_session_id = uuid.uuid4().hex
+    return _process_session_id
+
+
+def session_dir(root: Path, session_id: str) -> Path:
+    """Create and return a private, hashed session directory under ``root``."""
+    digest = hashlib.sha256(session_id.encode("utf-8")).hexdigest()[:12]
+    directory = root / f"session-{digest}"
+    directory.mkdir(mode=0o700, parents=True, exist_ok=True)
+    os.chmod(directory, 0o700)
+    return directory
+
+
+def safe_filename(tool_name: str) -> str:
+    """Convert an untrusted tool name into one harmless filename segment."""
+    raw = f"{tool_name}.txt".replace("\x00", "_")
+    safe = _UNSAFE_NAME.sub("_", raw.replace("/", "_").replace("\\", "_"))
+    while ".." in safe:
+        safe = safe.replace("..", "_")
+    safe = safe.strip(".")
+    return safe or "tool.txt"
+
+
+def save_text(content: str, tool_name: str, configured_root: str | None = None) -> Path:
+    """Persist ``content`` verbatim with exclusive owner-only creation."""
+    root = private_root(configured_root)
+    directory = session_dir(root, current_session_id())
+    path = directory / f"{secrets.token_hex(6)}-{safe_filename(tool_name)}"
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
+    descriptor = os.open(path, flags, 0o600)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8", newline="") as spill_file:
+            descriptor = -1
+            spill_file.write(content)
+        os.chmod(path, 0o600)
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+    return path
+
+
+def _reset_state() -> None:
+    """Forget lazy process state; test cleanup remains the caller's job."""
+    global _default_root, _process_session_id
+    _default_root = None
+    _process_session_id = None
+
+
+__all__ = [
+    "_reset_state",
+    "current_session_id",
+    "private_root",
+    "safe_filename",
+    "save_text",
+    "session_dir",
+]

{code_puppy_core_plugins-0.0.2 → code_puppy_core_plugins-0.0.5}/pyproject.toml

@@ -4,10 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.2"
+version = "0.0.5"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
+dependencies = [
+    "httpx>=0.24.1,<1",
+]
 license = {text = "MIT"}
 authors = [{name = "Michael Pfaffenberger"}]
 classifiers = [
@@ -66,6 +69,7 @@ puppy_spinner = "code_puppy_core_plugins.puppy_spinner.register_callbacks"
 quick_resume = "code_puppy_core_plugins.quick_resume.register_callbacks"
 review_pr = "code_puppy_core_plugins.review_pr.register_callbacks"
 shell_safety = "code_puppy_core_plugins.shell_safety.register_callbacks"
+spill = "code_puppy_core_plugins.spill.register_callbacks"
 stack_dump = "code_puppy_core_plugins.stack_dump.register_callbacks"
 statusline = "code_puppy_core_plugins.statusline.register_callbacks"
 steer_queue = "code_puppy_core_plugins.steer_queue.register_callbacks"