code-puppy 0.0.586__tar.gz → 0.0.587__tar.gz

{code_puppy-0.0.586 → code_puppy-0.0.587}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.586
+Version: 0.0.587
 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.587/code_puppy/plugins/btw/__init__.py

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

code_puppy-0.0.587/code_puppy/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-0.0.587/code_puppy/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-0.0.587/code_puppy/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"]

{code_puppy-0.0.586 → code_puppy-0.0.587}/pyproject.toml

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