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

code_puppy_core_plugins/azure_foundry/utils.py

@@ -0,0 +1,375 @@
+"""Utility functions for the Azure AI Foundry plugin.
+
+This module provides helper functions for configuration management,
+environment variable resolution, and model configuration.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import Any
+
+from .config import (
+    DEFAULT_CONTEXT_LENGTHS,
+    ENV_FOUNDRY_RESOURCE,
+    get_extra_models_path,
+    get_openai_context_length,
+)
+from code_puppy import atomic_io, atomic_json
+
+logger = logging.getLogger(__name__)
+
+# Context window suffix pattern: [<number><unit>] where unit is k or m (case-insensitive)
+# Examples: [200k], [500k], [1m], [2m]
+_CONTEXT_SUFFIX_PATTERN = re.compile(r"\[(\d+)([km])\]", re.IGNORECASE)
+
+# Multipliers for context window units
+_CONTEXT_MULTIPLIERS = {
+    "k": 1_000,
+    "m": 1_000_000,
+}
+
+
+def parse_context_window_suffix(name: str) -> tuple[str, int | None]:
+    """Parse and extract context window suffix from a model/deployment name.
+
+    Supports Claude Code format: [<number><unit>] where unit is 'k' (thousands)
+    or 'm' (millions). Examples: [200k], [500k], [1m], [2m]
+
+    Args:
+        name: The model or deployment name, possibly with context suffix.
+              e.g., "it-entra-claude-opus-4-6[1m]"
+
+    Returns:
+        A tuple of (stripped_name, context_length):
+        - stripped_name: The name with the suffix removed
+        - context_length: The parsed context length in tokens, or None if no suffix
+
+    Examples:
+        >>> parse_context_window_suffix("claude-opus-4-6[1m]")
+        ('claude-opus-4-6', 1000000)
+        >>> parse_context_window_suffix("claude-sonnet[200k]")
+        ('claude-sonnet', 200000)
+        >>> parse_context_window_suffix("claude-haiku-4-5")
+        ('claude-haiku-4-5', None)
+    """
+    match = _CONTEXT_SUFFIX_PATTERN.search(name)
+    if not match:
+        return name, None
+
+    number = int(match.group(1))
+    unit = match.group(2).lower()
+    multiplier = _CONTEXT_MULTIPLIERS[unit]
+    context_length = number * multiplier
+
+    # Remove the suffix from the name
+    stripped_name = _CONTEXT_SUFFIX_PATTERN.sub("", name).strip()
+
+    return stripped_name, context_length
+
+
+def resolve_env_var(value: str) -> str:
+    """Resolve a value that may contain an environment variable reference.
+
+    If the value starts with '$', it's treated as an environment variable
+    reference and resolved. Otherwise, the value is returned as-is.
+
+    Args:
+        value: The value to resolve, possibly starting with '$'.
+
+    Returns:
+        The resolved value.
+
+    Example:
+        >>> os.environ["MY_VAR"] = "test"
+        >>> resolve_env_var("$MY_VAR")
+        'test'
+        >>> resolve_env_var("literal")
+        'literal'
+    """
+    if value and value.startswith("$"):
+        env_var = value[1:]
+        resolved = os.environ.get(env_var)
+        if resolved is None:
+            logger.warning(f"Environment variable '{env_var}' not set")
+            return ""
+        return resolved
+    return value
+
+
+def load_extra_models() -> dict[str, Any]:
+    """Load the extra_models.json configuration file.
+
+    Bounded and lock-aware via :mod:`code_puppy.atomic_json` -- a large or
+    concurrently-being-written file can no longer balloon memory or read a
+    torn write.
+
+    Returns:
+        Dictionary containing model configurations, or empty dict if file
+        doesn't exist or is invalid.
+    """
+    extra_models_path = str(get_extra_models_path())
+    try:
+        return atomic_json.load_json(extra_models_path, default={})
+    except atomic_json.JsonFileCorrupt as e:
+        logger.error(f"Invalid JSON in extra_models.json: {e}")
+        return {}
+    except OSError as e:
+        logger.error(f"Error loading extra_models.json: {e}")
+        return {}
+
+
+def save_extra_models(models: dict[str, Any]) -> bool:
+    """Save model configurations to extra_models.json.
+
+    Args:
+        models: Dictionary of model configurations to save.
+
+    Returns:
+        True if save succeeded, False otherwise.
+    """
+    extra_models_path = str(get_extra_models_path())
+
+    try:
+        with atomic_io.path_lock(extra_models_path):
+            atomic_io.atomic_write_bytes(
+                extra_models_path,
+                json.dumps(models, indent=2, ensure_ascii=False).encode("utf-8"),
+            )
+
+        logger.info(f"Saved {len(models)} models to extra_models.json")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error saving extra_models.json: {e}")
+        return False
+
+
+def build_foundry_model_config(
+    deployment_name: str,
+    model_tier: str,
+    foundry_resource: str | None = None,
+    context_length: int | None = None,
+) -> dict[str, Any]:
+    """Build a Code Puppy model configuration for an Azure Foundry deployment.
+
+    Args:
+        deployment_name: The deployment name in Azure Foundry.
+        model_tier: One of "opus", "sonnet", or "haiku".
+        foundry_resource: The Foundry resource name. If None, uses env var reference.
+        context_length: Override for context length. If None, uses default for tier.
+
+    Returns:
+        Dictionary containing the model configuration.
+    """
+    if context_length is None:
+        context_length = DEFAULT_CONTEXT_LENGTHS.get(model_tier.lower(), 200000)
+
+    resource_value = (
+        foundry_resource if foundry_resource else f"${ENV_FOUNDRY_RESOURCE}"
+    )
+
+    # All Anthropic models need extended_thinking + budget_tokens in the request body,
+    # plus interleaved_thinking for the beta header; Opus additionally adds effort.
+    supported_settings = [
+        "temperature",
+        "extended_thinking",
+        "budget_tokens",
+        "interleaved_thinking",
+    ]
+    if model_tier.lower() == "opus":
+        supported_settings.append("effort")
+
+    return {
+        "type": "azure_foundry",
+        "provider": "azure_foundry",
+        "name": deployment_name,
+        "foundry_resource": resource_value,
+        "context_length": context_length,
+        "supported_settings": supported_settings,
+    }
+
+
+def add_foundry_models_to_config(
+    resource_name: str,
+    opus_deployment: str | None = None,
+    sonnet_deployment: str | None = None,
+    haiku_deployment: str | None = None,
+) -> list[str]:
+    """Add Azure Foundry model configurations to extra_models.json.
+
+    Args:
+        resource_name: The Azure Foundry resource name.
+        opus_deployment: Deployment name for Opus model (optional).
+        sonnet_deployment: Deployment name for Sonnet model (optional).
+        haiku_deployment: Deployment name for Haiku model (optional).
+
+    Returns:
+        List of model keys that were added.
+
+    Uses :func:`code_puppy.atomic_json.mutate_json` so the read and write
+    happen inside one locked transaction -- extra_models.json is also
+    touched by add_model_menu.py and the ollama_setup/aws_bedrock plugins,
+    so a read-then-write split across two unlocked calls could lose one of
+    those concurrent updates.
+    """
+    deployments = [
+        ("opus", opus_deployment, "foundry-claude-opus"),
+        ("sonnet", sonnet_deployment, "foundry-claude-sonnet"),
+        ("haiku", haiku_deployment, "foundry-claude-haiku"),
+    ]
+
+    entries: dict[str, dict[str, Any]] = {}
+    for tier, deployment, model_key in deployments:
+        if deployment:
+            # Parse context window suffix (Claude Code format: [200k], [1m], etc.)
+            actual_deployment, context_length = parse_context_window_suffix(deployment)
+            entries[model_key] = build_foundry_model_config(
+                deployment_name=actual_deployment,
+                model_tier=tier,
+                foundry_resource=resource_name,
+                context_length=context_length,
+            )
+
+    if not entries:
+        return []
+
+    def _mutate(models: dict[str, Any]) -> dict[str, Any]:
+        models.update(entries)
+        return models
+
+    extra_models_path = str(get_extra_models_path())
+    try:
+        atomic_json.mutate_json(extra_models_path, _mutate, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error(f"Error saving extra_models.json: {e}")
+        return []
+
+    return list(entries.keys())
+
+
+FOUNDRY_TYPES = {"azure_foundry", "azure_foundry_openai"}
+
+
+_GPT5_SUPPORTED_SETTINGS = [
+    "reasoning_effort",
+    "summary",
+    "verbosity",
+]
+
+
+def get_foundry_openai_supported_settings(model_name: str) -> list[str]:
+    """Return supported settings for an Azure Foundry OpenAI model.
+
+    Later GPT-5-family models support Code Puppy's reasoning/summary/verbosity
+    controls in addition to the baseline temperature setting.
+    """
+    supported_settings = ["temperature"]
+    if model_name.startswith("gpt-5"):
+        supported_settings.extend(_GPT5_SUPPORTED_SETTINGS)
+    return supported_settings
+
+
+def add_discovered_models_to_config(
+    resource_name: str,
+    deployments: list,
+) -> list[str]:
+    """Add auto-discovered deployments to extra_models.json.
+
+    Classifies each deployment by model format (Anthropic vs OpenAI)
+    and creates the appropriate model config.
+
+    Uses :func:`code_puppy.atomic_json.mutate_json` so the read and write
+    happen inside one locked transaction (see :func:`add_foundry_models_to_config`).
+    """
+    from .discovery import AzureDeployment
+
+    entries: dict[str, dict[str, Any]] = {}
+
+    for d in deployments:
+        if not isinstance(d, AzureDeployment):
+            continue
+
+        key = f"foundry-{d.name}"
+
+        if d.model_format == "Anthropic":
+            tier = "haiku"
+            for t in ("opus", "sonnet"):
+                if t in d.model_name.lower():
+                    tier = t
+                    break
+            entries[key] = build_foundry_model_config(
+                deployment_name=d.name,
+                model_tier=tier,
+                foundry_resource=resource_name,
+            )
+
+        elif d.model_format == "OpenAI":
+            entries[key] = {
+                "type": "azure_foundry_openai",
+                "provider": "azure_foundry_openai",
+                "name": d.name,
+                "foundry_resource": resource_name,
+                "context_length": get_openai_context_length(d.model_name),
+                "supported_settings": get_foundry_openai_supported_settings(
+                    d.model_name
+                ),
+            }
+
+    if not entries:
+        return []
+
+    def _mutate(models: dict[str, Any]) -> dict[str, Any]:
+        models.update(entries)
+        return models
+
+    extra_models_path = str(get_extra_models_path())
+    try:
+        atomic_json.mutate_json(extra_models_path, _mutate, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error(f"Error saving extra_models.json: {e}")
+        return []
+
+    return list(entries.keys())
+
+
+def remove_foundry_models_from_config() -> list[str]:
+    """Remove all Azure Foundry model configurations from extra_models.json.
+
+    Uses :func:`code_puppy.atomic_json.mutate_json` so the read and write
+    happen inside one locked transaction (see :func:`add_foundry_models_to_config`).
+    """
+    extra_models_path = str(get_extra_models_path())
+    removed_models: list[str] = []
+
+    def _mutate(models: dict[str, Any]) -> dict[str, Any]:
+        keys_to_remove = [
+            key
+            for key, config in models.items()
+            if isinstance(config, dict) and config.get("type") in FOUNDRY_TYPES
+        ]
+        for key in keys_to_remove:
+            del models[key]
+            removed_models.append(key)
+        return models
+
+    try:
+        atomic_json.mutate_json(extra_models_path, _mutate, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error(f"Failed to persist model removal: {e}")
+        return []
+
+    return removed_models
+
+
+def get_foundry_models_from_config() -> dict[str, Any]:
+    """Get all Azure Foundry model configurations from extra_models.json."""
+    models = load_extra_models()
+    return {
+        key: config
+        for key, config in models.items()
+        if isinstance(config, dict) and config.get("type") in FOUNDRY_TYPES
+    }

code_puppy_core_plugins/btw/__init__.py

@@ -0,0 +1 @@
+"""/btw — quick side questions without polluting the main conversation."""

code_puppy_core_plugins/btw/inline_view.py

@@ -0,0 +1,135 @@
+"""Inline rendering for `/btw` answers (Claude Code style).
+
+Why direct console writes instead of ``emit_info``: the `/btw` handler
+blocks the main event loop while the side query runs, which starves the
+async transcript renderer — queued messages would only paint *after*
+the handler returns. Every slash command already executes under
+``suspended_run_ui`` (idle and mid-run), so the terminal is ours for
+the duration; printing straight to it is the same trick the TUI menus
+use.
+
+The dismiss-wait is load-bearing mid-run: the agent stays parked at its
+pause boundary until the user dismisses (or the timeout fires), so the
+resuming stream can't immediately scroll the answer away.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import time
+
+logger = logging.getLogger(__name__)
+
+DISMISS_TIMEOUT_S = 120.0
+_DISMISS_KEYS = (b" ", b"\r", b"\n", b"\x1b")
+_HINT = "Press Space, Enter, or Escape to dismiss"
+_INDENT = (0, 0, 0, 2)  # answer block: two-cell left inset
+
+
+def is_tty() -> bool:
+    if os.getenv("CODE_PUPPY_NO_TUI") == "1":
+        return False
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except Exception:
+        return False
+
+
+def _console():
+    from rich.console import Console
+
+    return Console()
+
+
+def show_asking(question: str, model_name: str) -> None:
+    """Echo the question and a progress line before the query blocks."""
+    from rich.markup import escape
+
+    console = _console()
+    console.print()
+    console.print(f"[bold yellow]/btw[/bold yellow] [dim]{escape(question)}[/dim]")
+    console.print(f"  [dim]thinking ({escape(model_name)})...[/dim]")
+
+
+def show_answer(answer: str) -> None:
+    """Render the answer inline as Markdown, plus the dismiss hint."""
+    from rich.markdown import Markdown
+    from rich.padding import Padding
+
+    console = _console()
+    console.print()
+    console.print(Padding(Markdown(answer), _INDENT))
+    console.print()
+    console.print(f"  [dim]{_HINT}[/dim]")
+
+
+def wait_for_dismiss(timeout_s: float = DISMISS_TIMEOUT_S) -> None:
+    """Block until Space / Enter / Esc, or auto-dismiss on timeout.
+
+    Never raises. Skips waiting entirely when a raw key can't be read
+    (no termios/msvcrt, weird stdin) — better to resume than to hang.
+    """
+    if not is_tty():
+        return
+    try:
+        _wait_key_posix(timeout_s)
+        return
+    except ImportError:
+        pass
+    except Exception:
+        logger.debug("btw: posix key wait failed", exc_info=True)
+        return
+    try:
+        _wait_key_windows(timeout_s)
+    except Exception:
+        logger.debug("btw: windows key wait failed", exc_info=True)
+
+
+def _wait_key_posix(timeout_s: float) -> None:
+    import select
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        deadline = time.monotonic() + timeout_s
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return
+            ready, _, _ = select.select([fd], [], [], min(remaining, 0.5))
+            if ready and os.read(fd, 1) in _DISMISS_KEYS:
+                return
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+def _wait_key_windows(timeout_s: float) -> None:
+    import msvcrt
+
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if msvcrt.kbhit() and msvcrt.getch() in _DISMISS_KEYS:
+            return
+        time.sleep(0.05)
+
+
+def emit_fallback(question: str, answer: str) -> None:
+    """Non-TTY path: plain transcript message via the message queue."""
+    from code_puppy.messaging import emit_info
+
+    emit_info(f"/btw {question}\n\n{answer}")
+
+
+__all__ = [
+    "DISMISS_TIMEOUT_S",
+    "emit_fallback",
+    "is_tty",
+    "show_answer",
+    "show_asking",
+    "wait_for_dismiss",
+]

code_puppy_core_plugins/btw/register_callbacks.py

@@ -0,0 +1,106 @@
+"""Plugin: `/btw` — ask a quick side question without derailing the task.
+
+Runs an independent, single-turn model query (fresh throwaway agent, no
+tools, no shared history) and shows the answer inline, Claude Code
+style. The main conversation's context window never sees the exchange,
+so minor "by the way..." curiosities stop costing you expensive tokens.
+
+Mid-run behaviour comes free from ``run_ui._run_paused_commands``:
+slash commands typed while the agent works are queued, the in-flight
+stream finishes, the agent parks at its pause boundary, the command
+runs with the terminal released, then the run resumes. `/btw` just has
+to behave like any other blocking command inside that window — and the
+dismiss-wait keeps the window open until the user has read the answer.
+
+Usage:
+    /btw <question>     One-shot side query, answer shown inline
+    /btw --help         Show usage
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+COMMAND_NAME = "btw"
+
+_USAGE = (
+    "Usage: /btw <question>\n"
+    "  Runs an independent single-turn query and shows the answer in a\n"
+    "  temporary overlay. Your main conversation history is untouched."
+)
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        (
+            COMMAND_NAME,
+            "Quick side question, answered inline (single turn, history untouched)",
+        )
+    ]
+
+
+def _parse_question(command: str) -> Optional[str]:
+    """Return the question text, or None if usage was shown instead."""
+    parts = command.split(maxsplit=1)
+    question = parts[1].strip() if len(parts) == 2 else ""
+    if not question or question in {"--help", "-h", "help"}:
+        from code_puppy.messaging import emit_info
+
+        emit_info(_USAGE)
+        return None
+    return question
+
+
+def _handle_custom_command(command: str, name: str) -> Optional[bool]:
+    if name != COMMAND_NAME:
+        return None
+
+    question = _parse_question(command)
+    if question is None:
+        return True
+
+    from code_puppy.messaging import emit_error, emit_info
+
+    from . import inline_view
+    from .side_query import ask_blocking, resolve_model_name
+
+    model_name = resolve_model_name()
+    if not model_name:
+        emit_error("/btw: could not resolve a model to ask. Check your model config.")
+        return True
+
+    tty = inline_view.is_tty()
+    if tty:
+        inline_view.show_asking(question, model_name)
+    else:
+        emit_info(f"btw: asking {model_name} (side query, history untouched)...")
+
+    try:
+        answer = ask_blocking(model_name, question)
+    except Exception as exc:
+        emit_error(f"/btw failed ({type(exc).__name__}): {exc}")
+        return True
+
+    if tty:
+        inline_view.show_answer(answer)
+        inline_view.wait_for_dismiss()
+    else:
+        inline_view.emit_fallback(question, answer)
+    return True
+
+
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "COMMAND_NAME",
+    "_custom_help",
+    "_handle_custom_command",
+    "_parse_question",
+]

code_puppy_core_plugins/btw/side_query.py

@@ -0,0 +1,91 @@
+"""One-shot, history-free model query backing the `/btw` command.
+
+Deliberately minimal (YAGNI): a throwaway pydantic_ai Agent with no
+tools, no message history, and a tiny system prompt. The main agent's
+context window never sees any of this — that's the whole point.
+
+Threading note: ``handle_command`` executes synchronously *inside* the
+already-running main event loop, so we can't ``asyncio.run`` on the
+main thread. Same escape hatch as the ``steer_queue`` menu: hop to a
+worker thread and give it its own loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import logging
+
+logger = logging.getLogger(__name__)
+
+QUERY_TIMEOUT_S = 180.0
+
+_INSTRUCTIONS = (
+    "You are answering a quick side question ('/btw') a developer asked "
+    "mid-coding-session. Answer directly and concisely — a few sentences "
+    "or a short snippet is ideal. No preamble, no follow-up questions."
+)
+
+
+def resolve_model_name() -> str | None:
+    """Current agent's pinned model if any, else the global model."""
+    try:
+        from code_puppy.agents.agent_manager import get_current_agent
+
+        pinned = get_current_agent().get_model_name()
+        if pinned:
+            return pinned
+    except Exception:
+        logger.debug("btw: agent model lookup failed", exc_info=True)
+    try:
+        from code_puppy.config import get_global_model_name
+
+        return get_global_model_name()
+    except Exception:
+        logger.debug("btw: global model lookup failed", exc_info=True)
+        return None
+
+
+async def _ask(model_name: str, question: str) -> str:
+    """Single-turn query against a fresh Agent. Raises on failure."""
+    from pydantic_ai import Agent, UsageLimits
+
+    from code_puppy.model_factory import ModelFactory, make_model_settings
+    from code_puppy.model_utils import prepare_prompt_for_model
+
+    models_config = ModelFactory.load_config()
+    if model_name not in models_config:
+        raise ValueError(f"model {model_name!r} not present in the model config")
+
+    model = ModelFactory.get_model(model_name, models_config)
+    prepared = prepare_prompt_for_model(
+        model_name,
+        _INSTRUCTIONS,
+        question,
+        prepend_system_to_user=True,
+    )
+    agent = Agent(
+        model=model,
+        instructions=prepared.instructions,
+        retries=1,
+        model_settings=make_model_settings(model_name),
+    )
+    result = await agent.run(
+        prepared.user_prompt,
+        usage_limits=UsageLimits(request_limit=3),
+    )
+    return str(result.output)
+
+
+def ask_blocking(
+    model_name: str,
+    question: str,
+    timeout_s: float = QUERY_TIMEOUT_S,
+) -> str:
+    """Run the one-shot query on a worker thread; block until answered."""
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(lambda: asyncio.run(_ask(model_name, question)))
+        return future.result(timeout=timeout_s)
+
+
+__all__ = ["QUERY_TIMEOUT_S", "ask_blocking", "resolve_model_name"]