code-puppy 0.0.882__tar.gz → 0.0.883__tar.gz

{code_puppy-0.0.882 → code_puppy-0.0.883}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.882
+Version: 0.0.883
 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.882 → code_puppy-0.0.883}/code_puppy/callbacks.py

@@ -45,6 +45,7 @@ PhaseType = Literal[
     "register_agents",
     "register_model_type",
     "register_skills",
+    "register_settings",
     "register_kennel_memory",
     "register_cli_args",
     "handle_cli_args",
@@ -136,6 +137,7 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "register_agents": [],
     "register_model_type": [],
     "register_skills": [],
+    "register_settings": [],
     "register_kennel_memory": [],
     "register_cli_args": [],
     "handle_cli_args": [],
@@ -1239,6 +1241,29 @@ def on_register_skills() -> List[Dict[str, Any]]:
     return _trigger_callbacks_sync("register_skills")
 
 
+def on_register_settings() -> List[Any]:
+    """Collect ``/set`` settings declared by plugins.
+
+    Callback contract: ``() -> SettingsCategory | list[SettingsCategory] | None``
+    (from :mod:`code_puppy.command_line.set_menu_schema`). One declaration
+    feeds both ``/set`` autocomplete and the ``/set`` menu; a category named
+    like a core one (e.g. "Features") merges into it. Anything else returned
+    is ignored with a warning.
+    """
+    from code_puppy.command_line.set_menu_schema import SettingsCategory
+
+    categories: List[Any] = []
+    for result in _trigger_callbacks_sync("register_settings"):
+        if result is None:
+            continue
+        for item in result if isinstance(result, (list, tuple)) else [result]:
+            if isinstance(item, SettingsCategory):
+                categories.append(item)
+            else:
+                logger.warning("Ignoring non-SettingsCategory setting: %r", item)
+    return categories
+
+
 def on_register_kennel_memory() -> List[Any]:
     """Collect kennel memory providers from plugins.
 

{code_puppy-0.0.882 → code_puppy-0.0.883}/code_puppy/command_line/completers.py

@@ -135,11 +135,15 @@ class SetCompleter(Completer):
                 lambda: (get_config_keys, sorted(get_config_keys()))
             )
 
+        from code_puppy.command_line.set_menu_values import sensitive_keys
+
+        hidden = {"model", "puppy_token"} | MODEL_SETTINGS_ONLY_KEYS
+        secret = sensitive_keys()  # complete the key, never echo its value
         for key in config_keys:
-            if key in {"model", "puppy_token"} | MODEL_SETTINGS_ONLY_KEYS:
+            if key in hidden:
                 continue
             if key.startswith(text_after_trigger):
-                prev_value = get_value(key)
+                prev_value = None if key in secret else get_value(key)
                 value_part = f" = {prev_value}" if prev_value is not None else " = "
                 completion_text = f"{key}{value_part}"
 

code_puppy-0.0.883/code_puppy/command_line/set_menu_settings.py

@@ -0,0 +1,44 @@
+"""Facade for the ``/set`` menu's setting registry.
+
+The core data lives in :mod:`set_menu_catalog`; plugins add their own via
+the ``register_settings`` hook. This module merges the two so every call
+site sees one registry through :func:`iter_curated_settings`.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Iterator, List, Tuple
+
+from code_puppy.command_line.set_menu_catalog import SETTINGS_CATEGORIES
+from code_puppy.command_line.set_menu_schema import Setting, SettingsCategory
+
+__all__ = [
+    "Setting",
+    "SettingsCategory",
+    "SETTINGS_CATEGORIES",
+    "iter_curated_settings",
+]
+
+
+def _merged_categories() -> List[SettingsCategory]:
+    """Core categories, then plugin ones; same-named categories merge in place."""
+    from code_puppy.callbacks import on_register_settings
+
+    merged: Dict[str, List[Setting]] = {}
+    for category in (*SETTINGS_CATEGORIES, *on_register_settings()):
+        merged.setdefault(category.name, []).extend(category.settings)
+    return [SettingsCategory(name, tuple(items)) for name, items in merged.items()]
+
+
+def iter_curated_settings() -> Iterator[Tuple[SettingsCategory, Setting]]:
+    """Yield ``(category, setting)`` pairs for core and plugin settings.
+
+    Keys are unique: core claims first, then plugins in load order, so a
+    plugin can never shadow (or duplicate) a setting core already owns.
+    """
+    seen: set[str] = set()
+    for category in _merged_categories():
+        for setting in category.settings:
+            if setting.key not in seen:
+                seen.add(setting.key)
+                yield category, setting

{code_puppy-0.0.882 → code_puppy-0.0.883}/code_puppy/command_line/set_menu_values.py

@@ -14,8 +14,8 @@ from __future__ import annotations
 from typing import Any, Optional
 
 from code_puppy.command_line.set_menu_settings import (
-    SETTINGS_CATEGORIES,
     Setting,
+    iter_curated_settings,
 )
 from code_puppy.config import get_value
 
@@ -23,17 +23,14 @@ _MASK_KEEP_CHARS = 4
 _MASK_ELLIPSIS = "..."
 
 
-def _sensitive_keys() -> frozenset[str]:
-    """Set of curated keys flagged ``sensitive=True``.
+def sensitive_keys() -> frozenset[str]:
+    """Set of curated keys (core and plugin) flagged ``sensitive=True``.
 
     Deliberately not cached: tests monkey-patch the categories registry,
-    and the cost is negligible at the curated-setting scale (~20 keys).
+    plugins can load late, and the cost is negligible at this scale.
     """
     return frozenset(
-        setting.key
-        for category in SETTINGS_CATEGORIES
-        for setting in category.settings
-        if setting.sensitive
+        setting.key for _, setting in iter_curated_settings() if setting.sensitive
     )
 
 
@@ -43,7 +40,7 @@ def is_sensitive_key(key: str) -> bool:
     Used by the slash-command path to decide whether to mask values in
     success messages without needing the full :class:`Setting` object.
     """
-    return key in _sensitive_keys()
+    return key in sensitive_keys()
 
 
 def is_default_value(setting: Setting) -> bool:

{code_puppy-0.0.882 → code_puppy-0.0.883}/code_puppy/config.py

@@ -715,9 +715,21 @@ def get_config_keys():
     config = _load_config()
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
     keys.update(default_keys)
+    keys.update(_plugin_setting_keys())
     return sorted(keys)
 
 
+def _plugin_setting_keys() -> set[str]:
+    """Keys plugins declare via ``register_settings`` (their own, not core's)."""
+    from code_puppy.callbacks import on_register_settings
+
+    return {
+        setting.key
+        for category in on_register_settings()
+        for setting in category.settings
+    }
+
+
 def set_config_value(key: str, value: str):
     """
     Sets a config value in the persistent config file.

{code_puppy-0.0.882 → code_puppy-0.0.883}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.882"
+version = "0.0.883"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

code_puppy-0.0.882/code_puppy/command_line/set_menu_settings.py

@@ -1,26 +0,0 @@
-"""Facade for the ``/set`` menu's setting registry.
-
-The actual data lives in :mod:`set_menu_catalog`. This module is a
-thin re-export so existing call sites can keep importing ``Setting``,
-``SettingsCategory``, ``SETTINGS_CATEGORIES``, and
-``iter_curated_settings`` from a single place.
-"""
-
-from __future__ import annotations
-
-from code_puppy.command_line.set_menu_catalog import SETTINGS_CATEGORIES
-from code_puppy.command_line.set_menu_schema import Setting, SettingsCategory
-
-__all__ = [
-    "Setting",
-    "SettingsCategory",
-    "SETTINGS_CATEGORIES",
-    "iter_curated_settings",
-]
-
-
-def iter_curated_settings():
-    """Yield ``(category, setting)`` pairs for every curated setting."""
-    for category in SETTINGS_CATEGORIES:
-        for setting in category.settings:
-            yield category, setting