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

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.67
+Version: 0.0.69
 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
 Author: Michael Pfaffenberger
 License: MIT
 License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3

code_puppy_core_plugins-0.0.69/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,56 @@
+# Third-Party Notices
+
+This package includes material derived from the third-party projects listed
+below. Each remains under its own license; the full license text is either
+reproduced here or shipped next to the derived code, as noted.
+
+## jg
+
+- Source: https://github.com/remotehostai/jg (version 1.0.1, commit
+  `e4f464467130da8b60ee46f93bc6732f5c9bd196`)
+- License: MIT
+- Used in `code_puppy_core_plugins/jev_grep/`:
+  - `chunks.py`: ported from `src/chunks.mjs` (line windows, Python AST
+    partitioning, merging of short adjacent declarations)
+  - `retrieve.py`: ported from `src/retrieve.mjs` (BM25 ranking, identifier
+    term splitting, synonym groups)
+  - `search.py`: adapted from `src/search.mjs` (overlapping-window
+    de-duplication, narrower evidence block selection)
+
+```
+MIT License
+
+Copyright (c) 2026 Remotehost
+
+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.
+```
+
+## DeepSeek Harness
+
+- Source: https://github.com/deepseek-ai/DeepSeek-Harness
+- License: MIT, Copyright (c) 2026 DeepSeek
+- Used in `code_puppy_core_plugins/spill/`: ported spill design. The full
+  license text ships alongside it in `code_puppy_core_plugins/spill/LICENSE.deepseek`.
+
+## llxprt-code
+
+- Source: https://github.com/vybestack/llxprt-code
+- License: Apache-2.0
+- Used in `code_puppy_core_plugins/theme/`: the Green Screen theme's phosphor
+  color values. Attribution only; no llxprt-code source code is included.

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/claude_code_oauth/model_provider.py

@@ -98,8 +98,9 @@ def create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
     if verify is None:
         verify = get_cert_bundle_path()
 
-    # No HTTP/2 for OAuth: the UnprefixingStream tool-name rewrite breaks under
-    # HTTP/2's compression handling, causing zlib decompression errors.
+    # No HTTP/2 for OAuth: kept as a precaution from core cfff821b4, which fixed
+    # zlib decompression errors caused by rewriting response streams to strip
+    # the ``cp_`` prefix. Responses are no longer rewritten -- see below.
     kwargs = {}
     # Plugin releases land before core. Old transports keep their legacy path.
     import inspect
@@ -116,7 +117,11 @@ def create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
         timeout=180,
         http2=False,
         # Claude Code OAuth requires the ``cp_`` tool-name prefix; the wire
-        # format Anthropic's CLI uses won't accept un-prefixed tools.
+        # format Anthropic's CLI uses won't accept un-prefixed tools. Only
+        # requests are rewritten: returned ``cp_*`` calls are mapped back to
+        # real tool names at dispatch by core's pydantic_patches
+        # (``_normalize_claude_code_tool_name``), so this model needs
+        # ``apply_all_patches()`` -- cli_runner applies it at import.
         apply_claude_code_prefix=True,
         oauth_reauthentication_callback=lambda: _reauthenticate_after_expired_oauth(
             model_name

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

@@ -1,6 +1,6 @@
 """Discovery and chunking: turn a directory into judgeable source snippets.
 
-A port of jevgrep's client-side chunker. Python files are split along the
+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
@@ -17,8 +17,10 @@ from dataclasses import dataclass, field
 
 from code_puppy.tools.ripgrep import find_ripgrep
 
+# 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.
 MAX_FILES = 20_000
-MAX_CHUNKS = 20_000
 MAX_FILE_BYTES = 1024 * 1024
 MAX_TOTAL_BYTES = 32 * 1024 * 1024
 MAX_CHUNK_CHARS = 12_000
@@ -218,7 +220,7 @@ def list_files(directory: str, glob: str | None = None) -> list[str]:
     """Files ripgrep would search: honours .gitignore, skips hidden files."""
     rg = find_ripgrep()
     if rg is None:
-        raise RuntimeError("ripgrep (rg) is required for semantic_grep.")
+        raise RuntimeError("ripgrep (rg) is required for smart_grep.")
     args = [rg, "--files", "-0", *(["-g", glob] if glob else []), "--", directory]
     proc = subprocess.run(args, capture_output=True, timeout=15, check=False)
     if proc.returncode not in (0, 1):  # 1 == no files
@@ -264,8 +266,4 @@ def discover(directory: str, glob: str | None = None) -> Discovery:
             continue
         found.parsers[parser] += 1
         found.chunks.extend(chunks)
-        if len(found.chunks) > MAX_CHUNKS:
-            raise RuntimeError(
-                f"Search exceeds {MAX_CHUNKS} snippets. Narrow the directory or glob."
-            )
     return found

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/jev_grep/config.py

@@ -1,11 +1,18 @@
-"""Settings for jev_grep. Set with `/set <key> <value>` or the environment."""
+"""Settings for smart_grep. Set with `/set <key> <value>` or the environment.
+
+/set smart_grep on          enable (off by default)
+/set jev_api_key <key>      credentials (or TYPESAFE_API_KEY)
+/set smart_grep_model ...   pin a Jev version, e.g. jev-1.13.0
+/set smart_grep_threshold   relevance cut-off, 0-1 (default 0.5)
+"""
 
 from __future__ import annotations
 
 import os
 
-from code_puppy.config import get_api_key, get_value
+from code_puppy.config import get_api_key, get_truthy_bool_value, get_value
 
+ENABLED_KEY = "smart_grep"
 # TypeSafe's official name first, then the Jev-branded alias. Config lookup
 # is case-insensitive, so `/set jev_api_key ...` matches JEV_API_KEY.
 API_KEY_NAMES = ("TYPESAFE_API_KEY", "JEV_API_KEY")
@@ -25,14 +32,24 @@ def get_typesafe_api_key() -> str:
     return ""
 
 
+def is_enabled() -> bool:
+    """Opt-in: smart_grep sends selected source to an external service."""
+    return get_truthy_bool_value(ENABLED_KEY, False)
+
+
+def is_available() -> bool:
+    """The single gate for tool exposure, prompting and execution."""
+    return is_enabled() and bool(get_typesafe_api_key())
+
+
 def get_jev_model_name() -> str:
     """Pin a version (e.g. ``jev-1.13.0``) once a threshold is tuned against it."""
-    return get_value("jev_grep_model") or DEFAULT_MODEL
+    return get_value("smart_grep_model") or DEFAULT_MODEL
 
 
 def get_threshold() -> float:
     try:
-        value = float(get_value("jev_grep_threshold") or DEFAULT_THRESHOLD)
+        value = float(get_value("smart_grep_threshold") or DEFAULT_THRESHOLD)
     except ValueError:
         return DEFAULT_THRESHOLD
     return value if 0 <= value <= 1 else DEFAULT_THRESHOLD

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/jev_grep/judge.py

@@ -1,10 +1,10 @@
 """Relevance judgments from Jev, TypeSafe's decision model, via Pydantic AI.
 
-This replaces jevgrep's hosted ``/api/v1/grep`` backend. jevgrep documents its
-score as the product of two independent judgments -- the snippet acts on the
-requested *entity*, and it performs the requested *operation* -- so that is
-exactly what we ask. A bounded ``float`` field on a decision model is answered
-with the raw probability of yes, so there is no confidence-margin math to undo.
+Relevance is scored as the product of two independent judgments -- the snippet
+acts on the requested *entity*, and it performs the requested *operation* -- so
+mentioning a concept is not enough; the code must do the thing. A bounded
+``float`` field on a decision model is answered with the raw probability of
+yes, so there is no confidence-margin math to undo.
 
 Every snippet is judged in its own run (its own Jev state), so neighbouring
 snippets never lend each other evidence.

code_puppy_core_plugins-0.0.69/code_puppy_core_plugins/jev_grep/locales/en-US.json

@@ -0,0 +1,3 @@
+{
+  "smart_grep.summary": "smart_grep '{query}' in {directory}: {matches} matches ({evaluated}/{snippets} snippets judged)"
+}

code_puppy_core_plugins-0.0.69/code_puppy_core_plugins/jev_grep/register_callbacks.py

@@ -0,0 +1,54 @@
+"""smart_grep: semantic code search judged by TypeSafe's Jev decision model.
+
+Registers a ``smart_grep`` tool alongside the regular ``grep``. It is opt-in:
+agents only see the tool, and the smart_grep-first discovery policy is only
+added to the prompt, once ``/set smart_grep on`` is set AND a Jev/TypeSafe
+key is configured. ``/set`` reloads the agent, so toggling applies at once.
+"""
+
+from code_puppy.callbacks import register_callback
+
+from .config import is_available
+from .tool import TOOL_NAME, register_smart_grep
+
+
+def _register_tools():
+    return [{"name": TOOL_NAME, "register_func": register_smart_grep}]
+
+
+def _advertise_when_configured(agent_name=None):
+    return [TOOL_NAME] if is_available() else []
+
+
+def _discovery_instructions() -> str | None:
+    """Same live gate as tool advertisement; the key itself is never included."""
+    if not is_available():
+        return None
+    return """## Code discovery: smart_grep first
+When smart_grep is available, use it as your first tool for gathering code
+context about an unfamiliar implementation. Describe the behavior you need to
+find in plain English, scoped to the relevant repository or directory. Do this
+instead of guessing symbol names, running exploratory grep chains, or listing
+and reading many files just to locate the implementation.
+
+Use the returned source excerpts and line ranges to decide which files need a
+targeted read. Do not automatically read every match or repeat searches when
+the excerpts already answer the question. Read the relevant existing code before
+editing; semantic search is discovery, not a substitute for understanding it.
+
+Use regular grep for exact symbols, regexes, and exhaustive references. Read a
+known file directly when its location is already established. Use list_files
+when you actually need directory contents, not as a ritual before every search.
+
+A lexical shortlist is not exhaustive and no matches do not prove absence.
+If results are weak, rephrase or narrow the query, or use exact grep as needed.
+If smart_grep is unavailable or errors, fall back to grep and targeted reads;
+do not block the task or repeatedly retry a missing key or failing provider.
+Respect requests to keep code local: smart_grep sends selected source, paths,
+and the query to TypeSafe, so use local grep/reads for local-only work.
+"""
+
+
+register_callback("load_prompt", _discovery_instructions)
+register_callback("register_tools", _register_tools)
+register_callback("register_agent_tools", _advertise_when_configured)

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/jev_grep/retrieve.py

@@ -1,4 +1,4 @@
-"""Local BM25 shortlist (port of jevgrep's retrieve.mjs).
+"""Local BM25 shortlist: identifier-aware terms, path/symbol boost, synonyms.
 
 Cheap lexical ranking decides which snippets are worth a Jev judgment. It is
 a shortlist, not a verdict: code with unrelated wording can be missed, which

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/jev_grep/search.py

@@ -15,6 +15,7 @@ from .judge import judge
 from .retrieve import rank, terms
 
 MAX_QUERY_CHARS = 2000
+DEFAULT_CANDIDATES = 128
 MAX_CANDIDATES = 256
 EXCERPT_LINES = 12
 EXCERPT_CHARS = 1200
@@ -134,7 +135,7 @@ async def semantic_search(
     *,
     glob: str | None = None,
     limit: int = 5,
-    candidates: int = 48,
+    candidates: int = DEFAULT_CANDIDATES,
     threshold: float = 0.5,
 ) -> SemanticGrepOutput:
     query = query.strip()

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/code_puppy_core_plugins/jev_grep/tool.py

@@ -1,4 +1,4 @@
-"""The ``semantic_grep`` agent tool."""
+"""The ``smart_grep`` agent tool."""
 
 from __future__ import annotations
 
@@ -13,15 +13,19 @@ from code_puppy.tools.common import resolve_path
 from .config import (
     API_KEY_NAME,
     API_KEY_NAMES,
+    ENABLED_KEY,
     get_jev_model_name,
     get_threshold,
     get_typesafe_api_key,
+    is_enabled,
 )
 from .judge import build_jev_model
-from .search import SemanticGrepOutput, semantic_search
+from .search import DEFAULT_CANDIDATES, SemanticGrepOutput, semantic_search
 
 add_catalog_dir(Path(__file__).parent / "locales")
 
+TOOL_NAME = "smart_grep"
+
 
 def _first_error(exc: BaseException) -> BaseException:
     """TaskGroup wraps failures in ExceptionGroups; surface the real one."""
@@ -30,13 +34,19 @@ def _first_error(exc: BaseException) -> BaseException:
     return exc
 
 
-async def run_semantic_grep(
+async def run_smart_grep(
     query: str,
     directory: str = ".",
     glob: str | None = None,
     limit: int = 5,
-    candidates: int = 48,
+    candidates: int = DEFAULT_CANDIDATES,
 ) -> SemanticGrepOutput:
+    # Re-checked per call: an agent built before `/set smart_grep off` must
+    # not keep sending source out.
+    if not is_enabled():
+        return SemanticGrepOutput(
+            error=f"smart_grep is off. Enable it with `/set {ENABLED_KEY} on`."
+        )
     api_key = get_typesafe_api_key()
     if not api_key:
         return SemanticGrepOutput(
@@ -59,11 +69,11 @@ async def run_semantic_grep(
     except Exception as exc:  # noqa: BLE001 - report to the model, never crash the turn
         err = _first_error(exc)
         return SemanticGrepOutput(
-            error=f"semantic_grep failed: {type(err).__name__}: {err}"
+            error=f"smart_grep failed: {type(err).__name__}: {err}"
         )
     emit_info(
         t(
-            "jev_grep.summary",
+            "smart_grep.summary",
             query=query,
             directory=directory,
             matches=len(result.matches),
@@ -74,17 +84,19 @@ async def run_semantic_grep(
     return result
 
 
-def register_semantic_grep(agent):
-    """Register the semantic_grep tool on an agent."""
+def register_smart_grep(agent):
+    """Register the smart_grep tool on an agent."""
 
-    @agent.tool
-    async def semantic_grep(
+    # Read-only discovery: eligible for speculative early launch. Safe because
+    # run_smart_grep re-checks the opt-in flag on every call.
+    @agent.tool(metadata={"speculatable": True})
+    async def smart_grep(
         context: RunContext,
         query: str,
         directory: str = ".",
         glob: str | None = None,
         limit: int = 5,
-        candidates: int = 48,
+        candidates: int = DEFAULT_CANDIDATES,
     ) -> SemanticGrepOutput:
         """Find code by what it DOES, described in plain English (semantic search).
 
@@ -104,6 +116,6 @@ def register_semantic_grep(agent):
             glob: Optional ripgrep glob to restrict files, e.g. "*.py".
             limit: Max matches to return (1-100).
             candidates: Snippets to judge after the lexical shortlist (1-256).
-                Higher = better recall, slower and costlier.
+                Defaults to 128. Higher = better recall, slower and costlier.
         """
-        return await run_semantic_grep(query, directory, glob, limit, candidates)
+        return await run_smart_grep(query, directory, glob, limit, candidates)

{code_puppy_core_plugins-0.0.67 → code_puppy_core_plugins-0.0.69}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.67"
+version = "0.0.69"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -13,6 +13,9 @@ dependencies = [
     "pydantic-ai-slim[openai,anthropic,mcp,typesafe]>=2.51.0,<3",
 ]
 license = {text = "MIT"}
+# Ship third-party notices with every build: MIT requires the notice to
+# accompany ported code (see THIRD_PARTY_NOTICES.md).
+license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md"]
 authors = [{name = "Michael Pfaffenberger"}]
 classifiers = [
     "Programming Language :: Python :: 3",

code_puppy_core_plugins-0.0.67/code_puppy_core_plugins/jev_grep/locales/en-US.json

@@ -1,3 +0,0 @@
-{
-  "jev_grep.summary": "semantic_grep '{query}' in {directory}: {matches} matches ({evaluated}/{snippets} snippets judged)"
-}

code_puppy_core_plugins-0.0.67/code_puppy_core_plugins/jev_grep/register_callbacks.py

@@ -1,25 +0,0 @@
-"""jev_grep: semantic code search (a jevgrep reimplementation) on TypeSafe's Jev.
-
-Registers a ``semantic_grep`` tool alongside the regular ``grep``. It is only
-advertised to agents once ``TYPESAFE_API_KEY`` is configured, so agents never
-see a tool that can only fail.
-"""
-
-from code_puppy.callbacks import register_callback
-
-from .config import get_typesafe_api_key
-from .tool import register_semantic_grep
-
-TOOL_NAME = "semantic_grep"
-
-
-def _register_tools():
-    return [{"name": TOOL_NAME, "register_func": register_semantic_grep}]
-
-
-def _advertise_when_configured(agent_name=None):
-    return [TOOL_NAME] if get_typesafe_api_key() else []
-
-
-register_callback("register_tools", _register_tools)
-register_callback("register_agent_tools", _advertise_when_configured)