code-puppy 0.0.550__tar.gz → 0.0.552__tar.gz

{code_puppy-0.0.550 → code_puppy-0.0.552}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.550
+Version: 0.0.552
 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.550 → code_puppy-0.0.552}/code_puppy/agents/_builder.py

@@ -27,7 +27,9 @@ from code_puppy.callbacks import (
     on_wrap_pydantic_agent,
 )
 from code_puppy.config import (
+    AGENTS_MD_MAX_CHARS_DEFAULT,
     CONFIG_DIR,
+    get_agents_md_max_chars,
     get_global_model_name,
     get_value,
 )
@@ -38,6 +40,54 @@ from code_puppy.model_factory import ModelFactory, make_model_settings
 _AGENT_RULE_FILES = ("AGENTS.md", "AGENT.md", "agents.md", "agent.md")
 _CODE_PUPPY_DIR = ".code_puppy"
 
+# Re-export the default so callers that imported AGENTS_MD_MAX_CHARS from
+# here keep working. The *effective* cap on any given load is whatever
+# ``get_agents_md_max_chars()`` returns (user override via
+# ``/set agents_md_max_chars=<int>``); this constant is just the fallback
+# documented in the warning notice and used by tests that don't care about
+# the override path.
+AGENTS_MD_MAX_CHARS = AGENTS_MD_MAX_CHARS_DEFAULT
+
+
+def _friendly_path(candidate: Path) -> str:
+    """Render ``candidate`` as ``~/relative`` when it's under ``$HOME``.
+
+    Keeps the absolute home path out of the system prompt (and out of any
+    Slack paste of the agent's "please trim AGENTS.md" reply).
+    """
+    try:
+        return f"~/{candidate.relative_to(Path.home())}"
+    except ValueError:
+        return str(candidate)
+
+
+def _truncate_agents_md(content: str, source: str, max_chars: int) -> str:
+    """Cap one AGENTS.md file at ``max_chars`` with a labelled notice.
+
+    Returns ``content`` unchanged when it's within the cap. When it overflows,
+    keeps exactly the first ``max_chars`` characters of the original and
+    appends a delimited warning addressed to the agent (so the agent can
+    surface it to the user on the next turn). ``source`` is a human-readable
+    label for the file — used in the warning so the agent can tell the user
+    which specific file to trim when multiple files overflow. ``max_chars``
+    is resolved once per load by the caller (see ``get_agents_md_max_chars``)
+    so a session-wide ``/set`` override is honoured.
+    """
+    original_len = len(content)
+    if original_len <= max_chars:
+        return content
+    dropped = original_len - max_chars
+    notice = (
+        f"\n\n--- AGENTS.md truncated ---\n"
+        f"The {source} content was truncated: original was "
+        f"{original_len:,} chars, {dropped:,} chars dropped. Please tell "
+        f"the user to trim {source} below {max_chars:,} "
+        f"characters so the full rules can take effect (or raise the cap "
+        f"via `/set agents_md_max_chars=<int>`).\n"
+        f"--- end truncation notice ---"
+    )
+    return content[:max_chars] + notice
+
 
 def load_puppy_rules() -> Optional[str]:
     """Load AGENT(S).md from global config dir and/or the current project dir.
@@ -50,13 +100,24 @@ def load_puppy_rules() -> Optional[str]:
     1. ``.code_puppy/AGENTS.md`` (preferred — keeps root clean)
     2. ``./AGENTS.md`` (alternate location)
 
+    Each file is independently truncated via :func:`_truncate_agents_md` so
+    the combined system-prompt overhead stays bounded. The per-file cap is
+    resolved once per call via :func:`get_agents_md_max_chars` so a user
+    can raise (or lower) it with ``/set agents_md_max_chars=<int>``.
+
     Returns ``None`` if neither exists.
     """
+    max_chars = get_agents_md_max_chars()
+
     global_rules: Optional[str] = None
     for name in _AGENT_RULE_FILES:
         candidate = Path(CONFIG_DIR) / name
         if candidate.exists():
-            global_rules = candidate.read_text(encoding="utf-8-sig")
+            global_rules = _truncate_agents_md(
+                candidate.read_text(encoding="utf-8-sig"),
+                source=f"global {_friendly_path(candidate)}",
+                max_chars=max_chars,
+            )
             break
 
     project_rules: Optional[str] = None
@@ -67,7 +128,11 @@ def load_puppy_rules() -> Optional[str]:
         for name in _AGENT_RULE_FILES:
             candidate = code_puppy_dir / name
             if candidate.exists():
-                project_rules = candidate.read_text(encoding="utf-8-sig")
+                project_rules = _truncate_agents_md(
+                    candidate.read_text(encoding="utf-8-sig"),
+                    source=f"project {candidate}",
+                    max_chars=max_chars,
+                )
                 break
 
     # Priority 2: Fallback to project root
@@ -75,7 +140,11 @@ def load_puppy_rules() -> Optional[str]:
         for name in _AGENT_RULE_FILES:
             candidate = Path(name)
             if candidate.exists():
-                project_rules = candidate.read_text(encoding="utf-8-sig")
+                project_rules = _truncate_agents_md(
+                    candidate.read_text(encoding="utf-8-sig"),
+                    source=f"project {candidate}",
+                    max_chars=max_chars,
+                )
                 break
 
     rules = [r for r in (global_rules, project_rules) if r]

{code_puppy-0.0.550 → code_puppy-0.0.552}/code_puppy/callbacks.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 import traceback
-from typing import Any, Callable, Dict, List, Literal, Optional
+from typing import Any, Callable, Dict, List, Literal, Optional, Set
 
 PhaseType = Literal[
     "startup",
@@ -112,6 +112,49 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
 
 logger = logging.getLogger(__name__)
 
+# ---------------------------------------------------------------------------
+# Plugin ownership tracking
+# ---------------------------------------------------------------------------
+# Maps each registered callback function to the plugin that registered it.
+# Populated by register_callback() when a loading context is active.
+_callback_owners: Dict[CallbackFunc, str] = {}
+
+# Set by the plugin loader before importing each plugin's register_callbacks.py,
+# cleared immediately after.  register_callback() reads this to record ownership.
+_current_loading_plugin: Optional[str] = None
+
+
+def set_loading_context(plugin_name: str) -> None:
+    """Mark *plugin_name* as the plugin currently being loaded.
+
+    Called by the plugin loader before importing a plugin's
+    ``register_callbacks`` module.  Any callbacks registered while this
+    context is active are associated with *plugin_name*.
+    """
+    global _current_loading_plugin
+    _current_loading_plugin = plugin_name
+
+
+def clear_loading_context() -> None:
+    """Clear the current plugin loading context."""
+    global _current_loading_plugin
+    _current_loading_plugin = None
+
+
+def get_callback_owner(func: CallbackFunc) -> Optional[str]:
+    """Return the plugin name that registered *func*, or ``None``."""
+    return _callback_owners.get(func)
+
+
+def _get_disabled_plugins() -> Set[str]:
+    """Lazy accessor for the disabled-plugins set (avoids circular import)."""
+    try:
+        from code_puppy.plugins.config import get_disabled_plugins
+
+        return get_disabled_plugins()
+    except Exception:
+        return set()
+
 
 def register_callback(phase: PhaseType, func: CallbackFunc) -> None:
     if phase not in _callbacks:
@@ -131,6 +174,11 @@ def register_callback(phase: PhaseType, func: CallbackFunc) -> None:
         return
 
     _callbacks[phase].append(func)
+
+    # Record ownership if we know which plugin is loading.
+    if _current_loading_plugin is not None:
+        _callback_owners[func] = _current_loading_plugin
+
     logger.debug(f"Registered async callback {func.__name__} for phase '{phase}'")
 
 
@@ -159,8 +207,23 @@ def clear_callbacks(phase: Optional[PhaseType] = None) -> None:
             logger.debug(f"Cleared async callbacks for phase '{phase}'")
 
 
-def get_callbacks(phase: PhaseType) -> List[CallbackFunc]:
-    return _callbacks.get(phase, []).copy()
+def get_callbacks(
+    phase: PhaseType, *, include_disabled: bool = False
+) -> List[CallbackFunc]:
+    """Return callbacks for *phase*, filtering out disabled plugins.
+
+    When *include_disabled* is ``True`` the filter is bypassed — useful for
+    introspection (e.g. listing all registered callbacks).
+    """
+    all_cbs = _callbacks.get(phase, []).copy()
+    if include_disabled:
+        return all_cbs
+
+    disabled = _get_disabled_plugins()
+    if not disabled:
+        return all_cbs
+
+    return [cb for cb in all_cbs if _callback_owners.get(cb) not in disabled]
 
 
 def count_callbacks(phase: Optional[PhaseType] = None) -> int:

{code_puppy-0.0.550 → code_puppy-0.0.552}/code_puppy/config.py

@@ -351,6 +351,8 @@ def get_config_keys():
         default_keys.append(f"banner_color_{banner_name}")
     # Add resume message count configuration
     default_keys.append("resume_message_count")
+    # Per-file AGENTS.md character cap (see get_agents_md_max_chars()).
+    default_keys.append("agents_md_max_chars")
     # Add /goal iteration cap (owned by the wiggum plugin, surfaced here so
     # /set autocompletes it). See plugins/wiggum/register_callbacks.py.
     default_keys.append("goal_max_iterations")
@@ -1300,6 +1302,35 @@ def get_resume_message_count() -> int:
         return 50
 
 
+# Default cap (in characters) for any single AGENTS.md file injected into
+# the system prompt. Users can override this via
+# ``/set agents_md_max_chars=<int>`` — any positive integer is honoured so
+# models with very large context windows (1M+ tokens) can opt into bigger
+# AGENTS.md files when it makes sense. The default of 10,000 just keeps
+# the unbounded out-of-the-box behaviour from regressing.
+AGENTS_MD_MAX_CHARS_DEFAULT = 10_000
+
+
+def get_agents_md_max_chars() -> int:
+    """Return the per-file AGENTS.md character cap, honouring user override.
+
+    Read from the ``agents_md_max_chars`` config key (settable via
+    ``/set agents_md_max_chars=<int>``). Defaults to
+    ``AGENTS_MD_MAX_CHARS_DEFAULT`` (10,000) when unset, and falls back to
+    the default on values that can't be a sensible cap (non-numeric,
+    negative, zero). No upper clamp — if a user with a 1M-token model
+    wants ``/set agents_md_max_chars=500000``, that's their call.
+    """
+    val = get_value("agents_md_max_chars")
+    try:
+        configured = int(val) if val else AGENTS_MD_MAX_CHARS_DEFAULT
+    except (ValueError, TypeError):
+        return AGENTS_MD_MAX_CHARS_DEFAULT
+    if configured <= 0:
+        return AGENTS_MD_MAX_CHARS_DEFAULT
+    return configured
+
+
 def get_compaction_threshold():
     """
     Returns the user-configured compaction threshold as a float between 0.0 and 1.0.