code-puppy-core-plugins 0.0.42__tar.gz → 0.0.43__tar.gz

{code_puppy_core_plugins-0.0.42 → code_puppy_core_plugins-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.42
+Version: 0.0.43
 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

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/README.md

@@ -0,0 +1,47 @@
+# Configuration profiles
+
+Use different model/agent harness settings without having terminals overwrite
+each other's pins:
+
+```text
+/profile                  # keyboard menu: c creates, Enter activates
+/profile create web       # snapshot this process's current config
+/profile use web          # switch only this running process
+/profile list
+```
+
+```sh
+code-puppy --profile web
+code-puppy --profile default
+code-puppy                  # always the default profile
+```
+
+Named profiles store INI settings in
+`~/.code_puppy/profiles/<name>/puppy.cfg` (or under
+`$XDG_CONFIG_HOME/code_puppy/profiles` when configured). `default` keeps using
+the existing `puppy.cfg`; no global active-profile pointer is needed.
+A nonexistent CLI profile exits with status 2, rather than silently
+running the wrong harness. Names are lowercase letters/digits/underscores/
+hyphens, 1–64 characters, starting with a letter or digit.
+
+All `puppy.cfg` settings are snapshotted, including agent model pins, model
+settings, token limits and `/set` values. Changes persist within that profile.
+Two processes deliberately using the **same** profile still share its settings;
+use distinct names for independent harnesses. Switching rebuilds the current
+agent while retaining its conversation, rather than changing agent identity.
+
+Model catalogs, credentials, custom agent definitions, skills, MCP server files
+and conversation storage remain shared. Profiles do not restrict which agents
+a model may invoke. A profile is a settings preset, not a security sandbox.
+Provider API keys are stored once in the OS keyring, with the existing
+permission-hardened `secrets.json` fallback. Creating or selecting a profile
+migrates recognized legacy credentials from all profile configs, checking for
+conflicts before writing and removing legacy values only after verified storage.
+Conflicting values block the operation without choosing a winner. Reconcile the
+reported key in the legacy configs and shared store, then retry. Values are never
+included in the conflict message. Environment-only keys are not copied.
+Custom model API-key and secret-header environment references are recognized;
+unrelated arbitrary secrets cannot be inferred, so configs still need care.
+Data is INI, not executed Python. The plugin's `config.py` contains storage logic.
+
+No deletion or overwrite operation is exposed in this initial version.

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/__init__.py

@@ -0,0 +1 @@
+"""Process-local configuration profiles."""

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/config.py

@@ -0,0 +1,111 @@
+"""Profile persistence; ordinary INI data, never executable Python presets.
+
+The legacy config is the default profile. Selecting a profile only redirects
+this process's config I/O; there is deliberately no global 'active' pointer.
+"""
+
+from __future__ import annotations
+
+import io
+import re
+from pathlib import Path
+
+from code_puppy import config
+from code_puppy.atomic_io import atomic_write_bytes, path_lock
+from code_puppy.config_file import load_config
+from code_puppy.i18n import t
+
+_active = "default"
+_NAME = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}\Z")
+_RESERVED = {"con", "prn", "aux", "nul"} | {
+    f"{prefix}{i}" for prefix in ("com", "lpt") for i in range(1, 10)
+}
+
+
+def validate_name(name: str) -> str:
+    if not _NAME.fullmatch(name) or name in _RESERVED:
+        raise ValueError(t("profiles.invalid_name"))
+    return name
+
+
+def profile_path(name: str) -> Path:
+    validate_name(name)
+    root = Path(config.CONFIG_DIR)
+    if name == "default":
+        return root / "puppy.cfg"
+    directory = root / "profiles" / name
+    # Do not follow profile aliases outside the profiles directory.
+    if (
+        (root / "profiles").is_symlink()
+        or directory.is_symlink()
+        or (directory / "puppy.cfg").is_symlink()
+    ):
+        raise ValueError(t("profiles.symlink"))
+    return directory / "puppy.cfg"
+
+
+def active_profile() -> str:
+    return _active
+
+
+def list_profiles() -> list[str]:
+    root = Path(config.CONFIG_DIR) / "profiles"
+    if not root.exists():
+        return ["default"]
+    return ["default"] + sorted(
+        p.name
+        for p in root.iterdir()
+        if p.name != "default"
+        and _NAME.fullmatch(p.name)
+        and not p.is_symlink()
+        and not (p / "puppy.cfg").is_symlink()
+        and (p / "puppy.cfg").is_file()
+    )
+
+
+def create_profile(name: str) -> None:
+    """Snapshot current settings without overwriting an existing profile."""
+    target = profile_path(name)
+    if name == "default":
+        raise ValueError(t("profiles.exists", name=name))
+    if target.exists():
+        raise ValueError(t("profiles.exists", name=name))
+    migrate_credentials()
+    snapshot = load_config(str(config.CONFIG_FILE))
+    from code_puppy.shared_credentials import is_credential_key
+
+    # A concurrently running older Puppy may have written a plaintext key
+    # after migration. Never duplicate it into the new profile.
+    for section in [snapshot.default_section, *snapshot.sections()]:
+        for key in list(snapshot[section]):
+            if is_credential_key(key):
+                snapshot[section].pop(key, None)
+    buffer = io.StringIO()
+    snapshot.write(buffer)
+    target.parent.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    target.parent.mkdir(mode=0o700, exist_ok=True)
+    with path_lock(str(target)):
+        if target.exists():
+            raise ValueError(t("profiles.exists", name=name))
+        atomic_write_bytes(str(target), buffer.getvalue().encode("utf-8"))
+
+
+def activate_profile(name: str) -> None:
+    """Select a config for this process; missing named profiles fail closed."""
+    global _active
+    target = profile_path(name)
+    if name != "default" and not target.is_file():
+        raise ValueError(t("profiles.missing", name=name))
+    # Validate accessibility before changing any runtime state.
+    load_config(str(target))
+    migrate_credentials()
+    config.CONFIG_FILE = str(target)
+    config.reset_session_model()
+    config.clear_model_cache()
+    _active = name
+
+
+def migrate_credentials() -> None:
+    from code_puppy.shared_credentials import migrate
+
+    migrate([str(profile_path(name)) for name in list_profiles()])

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/locales/en-US.json

@@ -0,0 +1,18 @@
+{
+  "profiles.title": "Configuration profiles (* active in this process)",
+  "profiles.cli_help": "Use a named configuration profile for this run (default: default)",
+  "profiles.help": "Create and switch isolated configuration profiles",
+  "profiles.invalid_name": "Use 1–64 lowercase letters, digits, underscores or hyphens; start with a letter or digit.",
+  "profiles.symlink": "Symlinked profiles are not supported.",
+  "profiles.exists": "Profile '{name}' already exists.",
+  "profiles.missing": "Profile '{name}' does not exist. Create it with /profile create {name}.",
+  "profiles.error": "Profile error: {detail}",
+  "profiles.created": "Created '{name}' from the current settings. Select it with Enter or /profile use {name}.",
+  "profiles.active": "Active profile: {name} (this process only).",
+  "profiles.list": "Active: {active}\nProfiles: {names}",
+  "profiles.usage": "/profile | /profile list | /profile create NAME | /profile use NAME",
+  "profiles.keys": "↑/↓ select · Enter activate · c create · Esc/q close",
+  "profiles.new_name": "New profile name: {name}",
+  "profiles.row": "{cursor} {active} {name}",
+  "profiles.no_tty": "The profile menu needs a terminal. Use /profile list, create NAME or use NAME instead."
+}

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/menu.py

@@ -0,0 +1,95 @@
+"""Small keyboard-driven profile picker with inline profile creation."""
+
+from code_puppy.i18n import t
+from code_puppy_core_plugins.termflow_tui import FragmentTUI, fragments_to_lines
+
+from . import config
+
+
+class ProfileMenu:
+    def __init__(self):
+        self.names = config.list_profiles()
+        self.index = (
+            self.names.index(config.active_profile())
+            if config.active_profile() in self.names
+            else 0
+        )
+        self.creating = False
+        self.name = ""
+        self.message = ""
+
+    def render(self):
+        fragments = [("class:tui.title", t("profiles.title") + "\n\n")]
+        # Keep the selection visible even with a large profile collection.
+        start = max(0, self.index - 5)
+        for index in range(start, min(len(self.names), start + 10)):
+            name = self.names[index]
+            label = t(
+                "profiles.row",
+                cursor=">" if index == self.index else " ",
+                name=name,
+                active="*" if name == config.active_profile() else " ",
+            )
+            fragments.append(
+                (
+                    "class:tui.selected" if index == self.index else "class:tui.text",
+                    label + "\n",
+                )
+            )
+        fragments.append(("class:tui.help", "\n" + t("profiles.keys") + "\n"))
+        if self.creating:
+            fragments.append(
+                ("class:tui.input", t("profiles.new_name", name=self.name) + "\n")
+            )
+        if self.message:
+            fragments.append(("class:tui.warning", self.message))
+        return fragments_to_lines(fragments)
+
+    def on_key(self, key):
+        if key in ("ctrl-c", "\x03", "\x1b", "escape"):
+            if self.creating:
+                self.creating = False
+                return False
+            return True
+        try:
+            if self.creating:
+                if key in ("\r", "\n", "enter"):
+                    config.create_profile(self.name)
+                    self.names = config.list_profiles()
+                    self.index = self.names.index(self.name)
+                    self.creating = False
+                    self.message = t("profiles.created", name=self.name)
+                elif key in ("\x7f", "\b", "backspace"):
+                    self.name = self.name[:-1]
+                elif (
+                    len(key) == 1
+                    and key.isascii()
+                    and key.isprintable()
+                    and len(self.name) < 64
+                ):
+                    self.name += key
+            elif key in ("up", "\x1b[A", "k"):
+                self.index = (self.index - 1) % len(self.names)
+            elif key in ("down", "\x1b[B", "j"):
+                self.index = (self.index + 1) % len(self.names)
+            elif key == "c":
+                self.creating, self.name, self.message = True, "", ""
+            elif key in ("\r", "\n", "enter"):
+                from .register_callbacks import switch_profile
+
+                switch_profile(self.names[self.index])
+                self.message = t("profiles.active", name=config.active_profile())
+            elif key == "q":
+                return True
+        except (OSError, ValueError, RuntimeError) as exc:
+            self.message = t("profiles.error", detail=str(exc))
+        return False
+
+
+def run_menu():
+    import sys
+
+    if not sys.stdin.isatty():
+        raise ValueError(t("profiles.no_tty"))
+    menu = ProfileMenu()
+    FragmentTUI(menu.render, menu.on_key).run()

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/register_callbacks.py

@@ -0,0 +1,88 @@
+"""CLI and slash-command entry points for configuration profiles."""
+
+from __future__ import annotations
+
+import shlex
+import sys
+from pathlib import Path
+
+from code_puppy.callbacks import register_callback
+from code_puppy.i18n import add_catalog_dir, t
+
+from . import config
+
+add_catalog_dir(Path(__file__).parent / "locales")
+
+
+def register_cli_args(parser):
+    parser.add_argument(
+        "--profile", metavar="NAME", default="default", help=t("profiles.cli_help")
+    )
+
+
+def handle_cli_args(args):
+    try:
+        config.activate_profile(getattr(args, "profile", "default"))
+    except (OSError, ValueError) as exc:
+        print(t("profiles.error", detail=str(exc)), file=sys.stderr)
+        return {"handled": True, "exit_code": 2}
+    return None
+
+
+def switch_profile(name):
+    """Rebuild the current agent so cached model settings cannot leak."""
+    from code_puppy.agents.agent_manager import (
+        get_current_agent_name,
+        set_current_agent,
+    )
+
+    previous = config.active_profile()
+    agent = get_current_agent_name()
+    config.activate_profile(name)
+    try:
+        set_current_agent(agent)
+    except Exception:
+        config.activate_profile(previous)
+        raise
+
+
+def custom_command(command, name):
+    if name != "profile":
+        return None
+    from code_puppy.messaging import emit_error, emit_info
+
+    try:
+        parts = shlex.split(command)[1:]
+        if not parts:
+            from .menu import run_menu
+
+            run_menu()
+        elif parts == ["list"]:
+            emit_info(
+                t(
+                    "profiles.list",
+                    active=config.active_profile(),
+                    names=", ".join(config.list_profiles()),
+                )
+            )
+        elif len(parts) == 2 and parts[0] == "create":
+            config.create_profile(parts[1])
+            emit_info(t("profiles.created", name=parts[1]))
+        elif len(parts) == 2 and parts[0] == "use":
+            switch_profile(parts[1])
+            emit_info(t("profiles.active", name=parts[1]))
+        else:
+            emit_info(t("profiles.usage"))
+    except (OSError, ValueError, RuntimeError) as exc:
+        emit_error(t("profiles.error", detail=str(exc)))
+    return True
+
+
+def custom_help():
+    return [("profile", t("profiles.help"))]
+
+
+register_callback("register_cli_args", register_cli_args)
+register_callback("handle_cli_args", handle_cli_args)
+register_callback("custom_command", custom_command)
+register_callback("custom_command_help", custom_help)

{code_puppy_core_plugins-0.0.42 → code_puppy_core_plugins-0.0.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.42"
+version = "0.0.43"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -69,6 +69,7 @@ ollama_setup = "code_puppy_core_plugins.ollama_setup.register_callbacks"
 openrouter_oauth = "code_puppy_core_plugins.openrouter_oauth.register_callbacks"
 plugin_list = "code_puppy_core_plugins.plugin_list.register_callbacks"
 pop_command = "code_puppy_core_plugins.pop_command.register_callbacks"
+profiles = "code_puppy_core_plugins.profiles.register_callbacks"
 prompt_newline = "code_puppy_core_plugins.prompt_newline.register_callbacks"
 prune = "code_puppy_core_plugins.prune.register_callbacks"
 puppy_kennel = "code_puppy_core_plugins.puppy_kennel.register_callbacks"