code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/acp/session_config.py

@@ -0,0 +1,179 @@
+"""Session model selection + config options exposed to the ACP client.
+
+Everything is delivered as ACP **config options** (``session/set_config_option``)
+-- clients (Zed, opencode, oh-my-pi) bind each bottom-bar dropdown to a config
+option by its ``category``, so this is the shape that actually populates them:
+
+* **Model picker** — a ``select`` option tagged ``category="model"``:
+  ``{id: "model", category: "model", type: "select", ...}``. Backed by
+  ``model_picker_completion.load_model_names`` + ``config.get_global_model_name``
+  / ``set_model_name``. Changing it rebinds the live session's model.
+* **Mode picker** — a ``select`` option tagged ``category="mode"``. Code Puppy
+  has exactly one operating mode, so this is a single "Default" entry; we still
+  send it so the client's mode dropdown reads "Default" instead of an empty
+  "Unknown" control. (ACP's top-level ``SessionModeState`` is a *different*
+  mechanism that Zed 1.7.2 does not bind that dropdown to -- config options are
+  what work across clients.)
+* **Streaming toggle** — an On/Off ``select`` option. (A boolean option would
+  be more natural, but Zed 1.7.2 renders only ``select`` options in its bottom
+  bar -- a boolean shows as "Unknown" -- so every control here is a select.) We
+  deliberately expose only this safe setting; we do **not** expose a
+  yolo/approval-bypass toggle (permissions must stay client-driven).
+
+All accessors are best-effort and degrade to "nothing to offer" on error.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional, Tuple
+
+from acp.schema import (
+    SessionConfigOptionSelect,
+    SessionConfigSelectOption,
+)
+
+logger = logging.getLogger(__name__)
+
+# Config-option ids. ``MODEL_OPTION_ID`` is public because ``agent.py`` keys
+# its "rebind the live model" behaviour off it.
+MODEL_OPTION_ID = "model"
+MODE_OPTION_ID = "mode"
+_STREAMING_ID = "enable_streaming"
+_STREAMING_ON = "on"
+_STREAMING_OFF = "off"
+
+# Exactly one operating mode, but advertised as a category="mode" select so the
+# client's dropdown shows "Default" rather than an empty "Unknown" control.
+# (Model selection is the separate category="model" option.)
+_DEFAULT_MODE_ID = "default"
+
+
+def _mode_option() -> SessionConfigOptionSelect:
+    """Advertise Code Puppy's single "Default" mode as a category=mode select.
+
+    There is nothing to switch between, but a one-item option keeps the
+    client's mode dropdown meaningful instead of blank.
+    """
+    return SessionConfigOptionSelect(
+        id=MODE_OPTION_ID,
+        name="Mode",
+        category="mode",
+        type="select",
+        current_value=_DEFAULT_MODE_ID,
+        options=[
+            SessionConfigSelectOption(
+                value=_DEFAULT_MODE_ID,
+                name="Default",
+                description="Standard Code Puppy session",
+            )
+        ],
+    )
+
+
+def _model_choices() -> Tuple[List[str], Optional[str]]:
+    """Return ``(available_model_names, current_selection)`` from config.
+
+    ``current`` is coerced into the available list so a picker always has a
+    valid selection. Returns ``([], None)`` when there are no models to offer.
+    """
+    from code_puppy.command_line.model_picker_completion import load_model_names
+    from code_puppy.config import get_global_model_name
+
+    names = list(load_model_names() or [])
+    if not names:
+        return [], None
+    current = get_global_model_name()
+    return names, (current if current in names else names[0])
+
+
+def _model_option() -> Optional[SessionConfigOptionSelect]:
+    """Build the model picker as a ``category="model"`` select option.
+
+    Returns ``None`` when there are no models to offer.
+    """
+    names, current = _model_choices()
+    if not names or current is None:
+        return None
+    return SessionConfigOptionSelect(
+        id=MODEL_OPTION_ID,
+        name="Model",
+        category="model",
+        type="select",
+        current_value=current,
+        options=[SessionConfigSelectOption(value=n, name=n) for n in names],
+    )
+
+
+def set_model(model_id: str) -> bool:
+    """Switch the active model. Returns ``True`` on success."""
+    try:
+        from code_puppy.config import set_model_name
+
+        set_model_name(model_id)
+        return True
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: set_model failed", exc_info=True)
+        return False
+
+
+def config_options() -> List[Any]:
+    """Build the config-option list for a session (model picker + streaming).
+
+    Order matters for presentation: the model picker leads. Either entry is
+    omitted if it can't be built, so a config hiccup never sinks the session.
+    """
+    opts: List[Any] = []
+    try:
+        model_opt = _model_option()
+        if model_opt is not None:
+            opts.append(model_opt)
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: could not build model option", exc_info=True)
+    try:
+        opts.append(_mode_option())
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: could not build mode option", exc_info=True)
+    try:
+        from code_puppy.config import get_enable_streaming
+
+        # A select (On/Off), not a boolean: Zed 1.7.2 only renders select-type
+        # config options in its bottom bar; a boolean shows as "Unknown".
+        opts.append(
+            SessionConfigOptionSelect(
+                id=_STREAMING_ID,
+                name="Streaming responses",
+                type="select",
+                current_value=_STREAMING_ON
+                if get_enable_streaming()
+                else _STREAMING_OFF,
+                options=[
+                    SessionConfigSelectOption(value=_STREAMING_ON, name="On"),
+                    SessionConfigSelectOption(value=_STREAMING_OFF, name="Off"),
+                ],
+                description="Stream model output token-by-token.",
+            )
+        )
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: could not build streaming option", exc_info=True)
+    return opts
+
+
+def apply_config_option(config_id: str, value: Any) -> List[Any]:
+    """Apply a config-option change and return the refreshed option list."""
+    try:
+        if config_id == MODEL_OPTION_ID:
+            set_model(str(value))
+        elif config_id == _STREAMING_ID:
+            from code_puppy.config import set_config_value
+
+            set_config_value("enable_streaming", "true" if _as_bool(value) else "false")
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: apply_config_option failed", exc_info=True)
+    return config_options()
+
+
+def _as_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    return str(value).strip().lower() in ("1", "true", "yes", "on")

code_puppy_core_plugins/acp/state.py

@@ -0,0 +1,135 @@
+"""Run context for the active ACP connection.
+
+Code Puppy's approval and I/O seams live at its *edges* (the
+``run_shell_command`` hook, the ``tools.common`` approval backend, and the
+``tools.io_backends`` filesystem/command backends). Those are plain module
+functions with no reference to the live ACP connection, so this module is the
+small, explicit bridge between them and the running agent.
+
+Two kinds of state live here:
+
+* **Connection-scoped** — the ``AgentSideConnection`` handle + its event loop.
+  There is exactly one connection per process (set once, on connect), so these
+  are plain module globals.
+* **Run-scoped** — the id of the session whose prompt is currently running, the
+  stack of in-flight tool calls (so permission dialogs and updates correlate to
+  the tool that triggered them), and whether any assistant text has streamed.
+  A single ACP connection multiplexes *multiple* sessions, and the SDK
+  dispatches each ``session/prompt`` as its own task, so two prompts can be in
+  flight at once. Run-scoped state therefore lives in a **``ContextVar``** — set
+  in ``begin_run`` before the run task is spawned, so each prompt task (and the
+  tool coroutines/threads it copies its context into) sees its *own* run, never
+  a sibling's. The var holds a shared mutable dict so a mutation made deep in
+  the run (e.g. ``note_streamed_text`` from a streamed delta) is visible back in
+  the prompt coroutine's ``finally`` that reads it.
+
+Keeping this here — rather than smuggled through globals or reached via the
+agent object — keeps the coupling visible and testable.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import uuid
+from typing import Any, Dict, List, Optional, Tuple
+
+_CONNECTION: Any = None
+_LOOP: Optional[asyncio.AbstractEventLoop] = None
+
+# Per-run state isolated per prompt task via a ContextVar (None = no active run).
+# A mutable dict {"session_id", "streamed", "tool_stack"} so child tasks/threads
+# (which copy this context) see writes made by the creating prompt coroutine.
+_RUN: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+    "acp_run", default=None
+)
+
+
+# ---- Connection lifecycle -------------------------------------------------
+def set_connection(connection: Any, loop: Optional[asyncio.AbstractEventLoop]) -> None:
+    """Register (or clear, with ``None``) the live connection + its loop."""
+    global _CONNECTION, _LOOP
+    _CONNECTION = connection
+    _LOOP = loop
+
+
+def get_connection() -> Any:
+    """Return the ``AgentSideConnection``, or ``None`` when not in ACP mode."""
+    return _CONNECTION
+
+
+def get_loop() -> Optional[asyncio.AbstractEventLoop]:
+    """Return the ACP event loop, or ``None`` when not in ACP mode."""
+    return _LOOP
+
+
+# ---- Per-run context ------------------------------------------------------
+def begin_run(session_id: str) -> None:
+    """Mark ``session_id`` as the run whose events/permissions we handle.
+
+    Sets a fresh run-state dict in the current context. Call this in the prompt
+    coroutine *before* spawning the run task, so the task (and every tool
+    coroutine/thread that copies the context) shares this exact dict.
+    """
+    _RUN.set(
+        {
+            "session_id": session_id,
+            "streamed": False,
+            "tool_stack": [],
+        }
+    )
+
+
+def end_run() -> None:
+    """Detach after a run; late events/permissions in this context are dropped."""
+    _RUN.set(None)
+
+
+def get_active_session_id() -> Optional[str]:
+    """The session id of the in-flight run in this context, or ``None``."""
+    run = _RUN.get()
+    return run["session_id"] if run else None
+
+
+# ---- Streamed-text tracking (final-result fallback) -----------------------
+def note_streamed_text() -> None:
+    """Record that at least one assistant text delta streamed this run."""
+    run = _RUN.get()
+    if run is not None:
+        run["streamed"] = True
+
+
+def streamed_text() -> bool:
+    """Whether any assistant text streamed during the active run."""
+    run = _RUN.get()
+    return bool(run and run["streamed"])
+
+
+# ---- Tool-call correlation ------------------------------------------------
+def push_tool_call(tool_name: str) -> str:
+    """Open a tool call, returning a fresh id to report to the client."""
+    tool_call_id = f"tc_{uuid.uuid4().hex[:12]}"
+    run = _RUN.get()
+    if run is not None:
+        run["tool_stack"].append((tool_name, tool_call_id))
+    return tool_call_id
+
+
+def pop_tool_call(tool_name: str) -> Optional[str]:
+    """Close the most recent open call for ``tool_name`` and return its id."""
+    run = _RUN.get()
+    if run is None:
+        return None
+    stack: List[Tuple[str, str]] = run["tool_stack"]
+    for i in range(len(stack) - 1, -1, -1):
+        if stack[i][0] == tool_name:
+            return stack.pop(i)[1]
+    return None
+
+
+def current_tool_call() -> Optional[Tuple[str, str]]:
+    """Return the most recent open ``(tool_name, tool_call_id)``, or ``None``."""
+    run = _RUN.get()
+    if not run or not run["tool_stack"]:
+        return None
+    return run["tool_stack"][-1]

code_puppy_core_plugins/agent_skills/__init__.py

@@ -0,0 +1,22 @@
+"""Agent Skills plugin - dynamic skill loading and discovery.
+
+This plugin enables code_puppy to discover, load, and use custom skills
+defined in SKILL.md files. Skills can be placed in user-specific or
+project-specific directories for easy sharing and organization.
+"""
+
+from .metadata import (
+    SkillMetadata,
+    get_skill_resources,
+    load_full_skill_content,
+    parse_skill_metadata,
+    parse_yaml_frontmatter,
+)
+
+__all__ = [
+    "SkillMetadata",
+    "parse_yaml_frontmatter",
+    "parse_skill_metadata",
+    "load_full_skill_content",
+    "get_skill_resources",
+]

code_puppy_core_plugins/agent_skills/config.py

@@ -0,0 +1,208 @@
+"""Plugin-level config helpers for agent_skills."""
+
+import json
+import logging
+from pathlib import Path
+from typing import List, Set
+
+from code_puppy.config import get_value, set_value
+
+logger = logging.getLogger(__name__)
+
+
+def get_skill_directories() -> List[str]:
+    """Get configured skill directories.
+
+    Returns:
+        List of skill directory paths from configuration, normalized to
+        POSIX-style forward-slash separators for cross-platform display
+        consistency (see the ``display-paths-as-posix`` convention adopted
+        by ``plugin_list``). Consumers that need a native ``Path`` wrap the
+        string in ``Path(...)``, which accepts either separator on Windows.
+        Reads from puppy.cfg [puppy] section under 'skill_directories' key.
+        Default: ['~/.code_puppy/skills', './.code_puppy/skills', './skills']
+
+    The directories are stored as a JSON list in the config.
+    """
+    # Try to read from config first
+    config_value = get_value("skill_directories")
+
+    if config_value:
+        try:
+            # Parse as JSON
+            directories = json.loads(config_value)
+            # Ensure it's a list
+            if isinstance(directories, list):
+                return [Path(d).as_posix() for d in directories]
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse skill_directories config: {e}")
+
+    # Fallback to defaults
+    home_skills = (Path.home() / ".code_puppy" / "skills").as_posix()
+    project_config_skills = (Path.cwd() / ".code_puppy" / "skills").as_posix()
+    local_skills = (Path.cwd() / "skills").as_posix()
+    return [
+        home_skills,
+        project_config_skills,
+        local_skills,
+    ]
+
+
+def add_skill_directory(path: str) -> bool:
+    """Add a directory to the skills search path.
+
+    Args:
+        path: Path to add to the skill directories list.
+
+    Returns:
+        True if the directory was added successfully, False otherwise.
+    """
+    directories = get_skill_directories()
+
+    # Check if already exists
+    if path in directories:
+        logger.info(f"Skill directory already exists: {path}")
+        return False
+
+    # Add the new directory
+    directories.append(path)
+
+    try:
+        # Save back to config as JSON
+        set_value("skill_directories", json.dumps(directories))
+        logger.info(f"Added skill directory: {path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to add skill directory: {e}")
+        return False
+
+
+def remove_skill_directory(path: str) -> bool:
+    """Remove a directory from the skills search path.
+
+    Args:
+        path: Path to remove from the skill directories list.
+
+    Returns:
+        True if the directory was removed successfully, False otherwise.
+    """
+    directories = get_skill_directories()
+
+    # Check if exists
+    if path not in directories:
+        logger.info(f"Skill directory not found: {path}")
+        return False
+
+    # Remove the directory
+    directories.remove(path)
+
+    try:
+        # Save back to config as JSON
+        set_value("skill_directories", json.dumps(directories))
+        logger.info(f"Removed skill directory: {path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to remove skill directory: {e}")
+        return False
+
+
+def get_skills_enabled() -> bool:
+    """Check if skills integration is globally enabled.
+
+    Returns:
+        True if skills are globally enabled, False otherwise.
+        Reads from 'skills_enabled' config key (default: True).
+    """
+    cfg_val = get_value("skills_enabled")
+    if cfg_val is None:
+        return True  # Enabled by default
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def set_skills_enabled(enabled: bool) -> None:
+    """Enable or disable skills integration globally.
+
+    Args:
+        enabled: True to enable, False to disable.
+    """
+    set_value("skills_enabled", "true" if enabled else "false")
+    logger.info(f"Skills integration {'enabled' if enabled else 'disabled'}")
+
+
+def get_frontmatter_in_system_prompt() -> bool:
+    """Check if skill frontmatter is injected into the system prompt.
+
+    When enabled (default), each enabled skill's ``name`` + ``description``
+    (parsed from the SKILL.md frontmatter) is appended to the system prompt
+    so the model can see what skills are available. When disabled, the model
+    has no built-in awareness of skills but can still discover / activate
+    them via the ``list_or_search_skills`` and ``activate_skill`` tools.
+
+    Returns:
+        True if frontmatter is loaded into the system prompt, False otherwise.
+        Reads from ``frontmatter_in_system_prompt`` config key (default: True).
+    """
+    cfg_val = get_value("frontmatter_in_system_prompt")
+    if cfg_val is None:
+        return True  # Enabled by default
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def set_frontmatter_in_system_prompt(enabled: bool) -> None:
+    """Enable or disable loading frontmatter into the system prompt.
+
+    Args:
+        enabled: True to inject frontmatter, False to skip it.
+    """
+    set_value("frontmatter_in_system_prompt", "true" if enabled else "false")
+    logger.info(f"Frontmatter in system prompt {'enabled' if enabled else 'disabled'}")
+
+
+def get_disabled_skills() -> Set[str]:
+    """Get set of explicitly disabled skill names.
+
+    Returns:
+        Set of skill names that are disabled.
+        Reads from 'disabled_skills' config key as a JSON list.
+    """
+    config_value = get_value("disabled_skills")
+
+    if config_value:
+        try:
+            # Parse as JSON
+            disabled_list = json.loads(config_value)
+            # Ensure it's a list and convert to set
+            if isinstance(disabled_list, list):
+                return set(disabled_list)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse disabled_skills config: {e}")
+
+    return set()
+
+
+def set_skill_disabled(skill_name: str, disabled: bool) -> None:
+    """Disable or re-enable a specific skill.
+
+    Args:
+        skill_name: Name of the skill to disable/enable.
+        disabled: True to disable, False to enable.
+    """
+    disabled_skills = get_disabled_skills()
+
+    if disabled:
+        # Add to disabled set
+        if skill_name in disabled_skills:
+            logger.info(f"Skill already disabled: {skill_name}")
+            return
+        disabled_skills.add(skill_name)
+        logger.info(f"Disabled skill: {skill_name}")
+    else:
+        # Remove from disabled set
+        if skill_name not in disabled_skills:
+            logger.info(f"Skill already enabled: {skill_name}")
+            return
+        disabled_skills.remove(skill_name)
+        logger.info(f"Enabled skill: {skill_name}")
+
+    # Save back to config as JSON
+    set_value("disabled_skills", json.dumps(list(disabled_skills)))