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

code_puppy_core_plugins/stack_dump/register_callbacks.py

@@ -0,0 +1,79 @@
+"""Register callbacks for the ``stack_dump`` plugin.
+
+Wedge forensics: when Code Puppy hangs hard (deadlock, stuck lock
+acquire, wedged event loop), ``kill -USR1 <pid>`` dumps EVERY thread's
+Python stack to ``<state>/logs/stacks.log`` — no debugger, no py-spy,
+no sudo required.
+
+Why ``faulthandler`` and not a Python-level ``signal.signal`` handler:
+Python signal handlers only run on the main thread between bytecodes.
+A main thread stuck in a C-level ``lock.acquire()`` never reaches a
+bytecode boundary, so a Python handler would hang right along with it
+— the exact scenario we need to diagnose. ``faulthandler.register``
+installs a C-level handler that writes stacks async-signal-safely,
+even while the main thread is wedged.
+
+POSIX-only (``SIGUSR1`` doesn't exist on Windows); silently no-ops
+there and on any registration failure — never crash the app over
+diagnostics plumbing.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+#: Kept module-global on purpose: faulthandler holds the raw fd, so the
+#: file object must outlive the whole process. Never close it.
+_dump_file = None
+
+
+def _stacks_log_path() -> str:
+    """Path of the dump log, next to the existing error log."""
+    from code_puppy.error_logging import LOGS_DIR
+
+    return os.path.join(LOGS_DIR, "stacks.log")
+
+
+def _on_startup() -> None:
+    """Arm SIGUSR1 → all-thread stack dump (best-effort, POSIX only)."""
+    global _dump_file
+    import faulthandler
+    import signal
+
+    if not hasattr(signal, "SIGUSR1") or not hasattr(faulthandler, "register"):
+        return  # Windows: no SIGUSR1 / no faulthandler.register
+    if _dump_file is not None:
+        return  # already armed (idempotent across repeated startups)
+    try:
+        from code_puppy.error_logging import _ensure_logs_dir
+
+        _ensure_logs_dir()
+        path = _stacks_log_path()
+        _dump_file = open(path, "a", encoding="utf-8")
+        # Human breadcrumb: faulthandler output has no pid/timestamp of
+        # its own, so mark which process armed the handler and when.
+        from datetime import datetime
+
+        _dump_file.write(
+            f"\n=== stack_dump armed: pid={os.getpid()} "
+            f"at {datetime.now().isoformat()} "
+            f"(kill -USR1 {os.getpid()} to dump all threads) ===\n"
+        )
+        _dump_file.flush()
+        faulthandler.register(signal.SIGUSR1, file=_dump_file, all_threads=True)
+    except Exception:
+        logger.debug("stack_dump: failed to arm SIGUSR1 handler", exc_info=True)
+        try:
+            if _dump_file is not None:
+                _dump_file.close()
+        except Exception:
+            pass
+        _dump_file = None
+
+
+register_callback("startup", _on_startup)

code_puppy_core_plugins/statusline/__init__.py

@@ -0,0 +1,14 @@
+"""Status line plugin — a customizable bottom status line for Code Puppy.
+
+Mirrors Claude Code's ``statusLine`` feature: you configure a shell command;
+Code Puppy feeds it JSON session data on stdin; whatever the command prints to
+stdout becomes your status line (ANSI colors supported).
+
+Configure with the ``/statusline`` command or directly via ``/set``:
+
+    /set statusline_enabled=true
+    /set statusline_command=~/.code_puppy/statusline.sh
+
+The command runs throttled in a background thread, so it never blocks the
+prompt. Run ``/statusline json`` to see every field your script receives.
+"""

code_puppy_core_plugins/statusline/config.py

@@ -0,0 +1,68 @@
+"""Configuration for the statusline plugin (persisted in puppy.cfg)."""
+
+from __future__ import annotations
+
+import logging
+
+from code_puppy.config import get_value, set_value
+
+logger = logging.getLogger(__name__)
+
+KEY_ENABLED = "statusline_enabled"
+KEY_COMMAND = "statusline_command"
+KEY_TIMEOUT = "statusline_timeout_ms"
+KEY_REFRESH = "statusline_refresh_ms"
+KEY_MODE = "statusline_mode"
+
+DEFAULT_TIMEOUT_MS = 1000
+DEFAULT_REFRESH_MS = 1000
+DEFAULT_MODE = "replace"
+_VALID_MODES = ("replace", "above", "newline")
+
+
+def _get_int(key: str, default: int) -> int:
+    raw = get_value(key)
+    if raw is None or raw == "":
+        return default
+    try:
+        return int(str(raw).strip())
+    except (TypeError, ValueError):
+        return default
+
+
+def is_enabled() -> bool:
+    raw = get_value(KEY_ENABLED)
+    if raw is None or raw == "":
+        return False
+    return str(raw).strip().lower() in ("1", "true", "yes", "on")
+
+
+def set_enabled(value: bool) -> None:
+    set_value(KEY_ENABLED, "true" if value else "false")
+
+
+def get_command() -> str:
+    return (get_value(KEY_COMMAND) or "").strip()
+
+
+def set_command(command: str) -> None:
+    set_value(KEY_COMMAND, command or "")
+
+
+def get_timeout_ms() -> int:
+    return max(100, _get_int(KEY_TIMEOUT, DEFAULT_TIMEOUT_MS))
+
+
+def get_refresh_ms() -> int:
+    return max(200, _get_int(KEY_REFRESH, DEFAULT_REFRESH_MS))
+
+
+def get_mode() -> str:
+    raw = (get_value(KEY_MODE) or "").strip().lower()
+    return raw if raw in _VALID_MODES else DEFAULT_MODE
+
+
+def set_mode(mode: str) -> None:
+    mode = (mode or "").strip().lower()
+    if mode in _VALID_MODES:
+        set_value(KEY_MODE, mode)

code_puppy_core_plugins/statusline/payload.py

@@ -0,0 +1,138 @@
+"""Build the JSON session payload fed to the status line command on stdin.
+
+Schema mirrors Claude Code's ``statusLine`` stdin contract where the data
+exists in Code Puppy, so scripts written for one are easy to port. Every field
+is best-effort: a failure in one source must never break the payload.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _safe(fn, default=None):
+    try:
+        return fn()
+    except Exception:
+        return default
+
+
+def _model_block() -> Dict[str, Any]:
+    from code_puppy.command_line.model_picker_completion import get_active_model
+
+    model_id = _safe(get_active_model) or "(default)"
+    return {"id": model_id, "display_name": model_id}
+
+
+def _agent_block() -> Optional[Dict[str, Any]]:
+    from code_puppy.agents.agent_manager import get_current_agent
+
+    agent = _safe(get_current_agent)
+    if not agent:
+        return None
+    name = getattr(agent, "display_name", None) or getattr(agent, "name", None)
+    return {"name": name} if name else None
+
+
+def detect_git_branch(cwd: str) -> Optional[str]:
+    """Return the active git branch for cwd, or None outside a branch/repo.
+
+    Windows hardening: ``capture_output=True`` uses reader threads, and if the
+    spawned git (or a grandchild) keeps a pipe write-handle open, ``run`` hangs
+    forever joining them -- even with a timeout -- which deadlocks the ACP event
+    loop when this runs from a ``post_tool_call`` hook. Route stdout through a
+    temp file (no reader threads) and detach stdin from any inherited pipe.
+    """
+    try:
+        import tempfile
+
+        with tempfile.TemporaryFile() as out_f:
+            proc = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=cwd,
+                stdin=subprocess.DEVNULL,
+                stdout=out_f,
+                stderr=subprocess.DEVNULL,
+                timeout=5,
+                encoding="utf-8",
+                errors="replace",
+            )
+            if proc.returncode == 0:
+                out_f.seek(0)
+                branch = out_f.read().decode("utf-8", "replace").strip()
+                return branch or None
+    except Exception:
+        return None
+    return None
+
+
+# Back-compat alias: quick-resume (config.py) reuses this public helper.
+_git_branch = detect_git_branch
+
+
+def _context_block() -> Dict[str, Any]:
+    block: Dict[str, Any] = {}
+    try:
+        from code_puppy.token_usage import get_current_usage
+
+        usage = get_current_usage()
+        if usage is not None:
+            block["total_input_tokens"] = int(getattr(usage, "used_tokens", 0))
+            block["context_window_size"] = int(getattr(usage, "capacity", 0))
+            block["used_percentage"] = round(float(usage.percent), 1)
+            block["remaining_percentage"] = round(100.0 - float(usage.percent), 1)
+            block["indicator"] = usage.indicator
+    except Exception:
+        pass
+    return block
+
+
+def _tokens_per_second() -> float:
+    try:
+        from code_puppy.status_display import StatusDisplay
+
+        return round(float(StatusDisplay.get_current_rate()), 1)
+    except Exception:
+        return 0.0
+
+
+def build_payload() -> Dict[str, Any]:
+    """Assemble the full session payload (all fields best-effort)."""
+    from code_puppy.config import get_puppy_name
+
+    cwd = _safe(os.getcwd, "") or ""
+    payload: Dict[str, Any] = {
+        "cwd": cwd,
+        "puppy_name": _safe(get_puppy_name) or "code-puppy",
+        "model": _model_block(),
+        "workspace": {"current_dir": cwd},
+        "context_window": _context_block(),
+        "tokens_per_second": _tokens_per_second(),
+    }
+
+    agent = _agent_block()
+    if agent:
+        payload["agent"] = agent
+
+    branch = detect_git_branch(cwd)
+    if branch:
+        payload["workspace"]["git_branch"] = branch
+
+    try:
+        from importlib.metadata import version
+
+        payload["version"] = version("code-puppy")
+    except Exception:
+        pass
+
+    return payload
+
+
+def build_payload_json() -> str:
+    return json.dumps(build_payload(), indent=2)

code_puppy_core_plugins/statusline/prompt_patch.py

@@ -0,0 +1,76 @@
+"""Monkey-patch ``get_prompt_with_active_model`` to render the status line.
+
+Same proven seam the ``context_indicator`` plugin uses. The status command's
+stdout may contain ANSI color codes, so we convert it to prompt_toolkit
+``FormattedText`` via ``ANSI``.
+
+Three modes (config ``statusline_mode``):
+
+* ``replace`` (default): the custom status line **replaces** Code Puppy's
+  default prompt content (puppy/agent/model/cwd), keeping only the trailing
+  arrow. No duplicated info, no extra stacked line.
+* ``above``: the custom status line is shown on its own line *above* the
+  unchanged default prompt.
+* ``newline``: like ``replace`` but the trailing arrow is pushed to its own
+  line, so the user types below the status line::
+
+       [model] code-puppy (main) 0.9%ctx
+      >>> typed text
+"""
+
+from __future__ import annotations
+
+import logging
+
+from .config import get_mode
+from .runner import get_status_text
+
+logger = logging.getLogger(__name__)
+
+_PATCH_ATTR = "_statusline_original_prompt_fn"
+_DEFAULT_ARROW = ">>> "
+
+
+def _render(formatted_text, base: str):
+    from prompt_toolkit.formatted_text import ANSI, FormattedText, to_formatted_text
+
+    text = get_status_text()
+    if not text:
+        return formatted_text
+
+    try:
+        status_fragments = list(to_formatted_text(ANSI(text)))
+    except Exception:
+        logger.debug("statusline: failed to parse status text", exc_info=True)
+        return formatted_text
+
+    mode = get_mode()
+
+    if mode == "above":
+        # Status line on its own line, default prompt unchanged below it.
+        return FormattedText(status_fragments + [("", "\n")] + list(formatted_text))
+
+    if mode == "newline":
+        # Status line on its own line, arrow on the next line.
+        arrow = base if base else _DEFAULT_ARROW
+        return FormattedText(status_fragments + [("", "\n"), ("class:arrow", arrow)])
+
+    # replace mode (default): status line + trailing arrow on same line.
+    arrow = base if base else _DEFAULT_ARROW
+    return FormattedText(status_fragments + [("class:arrow", " " + arrow)])
+
+
+def install_prompt_patch() -> None:
+    """Wrap ``get_prompt_with_active_model`` exactly once."""
+    from code_puppy.command_line import prompt_toolkit_completion as ptc
+
+    if getattr(ptc, _PATCH_ATTR, None) is not None:
+        return  # already patched
+
+    original = ptc.get_prompt_with_active_model
+    setattr(ptc, _PATCH_ATTR, original)
+
+    def patched(base: str = ">>> "):
+        return _render(original(base), base)
+
+    ptc.get_prompt_with_active_model = patched

code_puppy_core_plugins/statusline/register_callbacks.py

@@ -0,0 +1,45 @@
+"""Wire up the statusline plugin."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+
+from .payload import detect_git_branch
+from .prompt_patch import install_prompt_patch
+from .statusline_command import handle_statusline_command, statusline_command_help
+
+logger = logging.getLogger(__name__)
+
+
+def _on_startup() -> None:
+    try:
+        install_prompt_patch()
+    except Exception:
+        logger.debug("statusline: failed to install prompt patch", exc_info=True)
+
+
+def _custom_command_help() -> List[Tuple[str, str]]:
+    return statusline_command_help()
+
+
+def _handle_custom_command(command: str, name: str) -> Optional[Any]:
+    try:
+        return handle_statusline_command(command, name)
+    except Exception:
+        logger.debug("statusline: command handler failed", exc_info=True)
+        return None
+
+
+register_callback("git_branch_provider", detect_git_branch)
+register_callback("startup", _on_startup)
+register_callback("custom_command_help", _custom_command_help)
+register_callback("custom_command", _handle_custom_command)
+
+# Install immediately too, in case startup already fired before this plugin
+# loaded (plugin load order is not guaranteed relative to the startup hook).
+_on_startup()
+
+logger.debug("statusline plugin registered")

code_puppy_core_plugins/statusline/runner.py

@@ -0,0 +1,122 @@
+"""Run the status line command (JSON on stdin -> stdout) without blocking.
+
+The prompt is re-rendered frequently; running a shell command synchronously
+each time would make the prompt janky. So we cache the last stdout and refresh
+it in a background thread no more often than ``statusline_refresh_ms``. The
+prompt always reads the cached value instantly.
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+import threading
+import time
+
+from .config import get_command, get_refresh_ms, get_timeout_ms, is_enabled
+from .payload import build_payload_json
+
+logger = logging.getLogger(__name__)
+
+_lock = threading.Lock()
+_cached_output: str = ""
+_last_run_monotonic: float = 0.0
+_running: bool = False
+
+
+def _run_command_blocking(command: str) -> str:
+    payload = build_payload_json()
+    try:
+        proc = subprocess.run(
+            command,
+            shell=True,
+            input=payload,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",  # explicit UTF-8: prevents cp1252 crash on Windows with umlauts
+            errors="replace",  # never raise UnicodeDecodeError — bad chars become '?'
+            timeout=get_timeout_ms() / 1000.0,
+        )
+    except subprocess.TimeoutExpired:
+        return ""
+    except Exception:
+        logger.debug("statusline command failed", exc_info=True)
+        return ""
+    out = (proc.stdout or "").strip("\n")
+    # Status line is a single line: collapse any extra newlines.
+    return out.replace("\n", " ").strip()
+
+
+def _refresh_async(command: str) -> None:
+    global _cached_output, _running, _last_run_monotonic
+    try:
+        result = _run_command_blocking(command)
+        with _lock:
+            _cached_output = result
+            _last_run_monotonic = time.monotonic()
+    finally:
+        with _lock:
+            _running = False
+
+
+def get_status_text() -> str:
+    """Return the status line, refreshing in the background when stale.
+
+    First call (cold cache) runs **synchronously** once so the very first
+    prompt — including the one shown at startup — has a status line. After that
+    it never blocks: it returns the cached value and schedules a background
+    refresh when the value goes stale.
+    """
+    global _running, _last_run_monotonic, _cached_output
+    if not is_enabled():
+        return ""
+    command = get_command()
+    if not command:
+        return ""
+
+    now = time.monotonic()
+    with _lock:
+        cached = _cached_output
+        cold = _last_run_monotonic == 0.0
+        if cold:
+            # Reserve the slot so we don't also spawn an async refresh below.
+            _last_run_monotonic = now
+
+    if cold:
+        # One-time synchronous warm-up so the FIRST prompt (startup) has a
+        # status line. Bounded by the command timeout.
+        result = _run_command_blocking(command)
+        with _lock:
+            _cached_output = result
+            _last_run_monotonic = time.monotonic()
+        return result
+
+    with _lock:
+        due = (now - _last_run_monotonic) * 1000.0 >= get_refresh_ms()
+        should_start = due and not _running
+        if should_start:
+            _running = True
+            # Reserve the slot immediately so concurrent prompt renders don't
+            # spawn a thundering herd of refreshes.
+            _last_run_monotonic = now
+
+    if should_start:
+        threading.Thread(target=_refresh_async, args=(command,), daemon=True).start()
+
+    return cached
+
+
+def run_once_sync() -> str:
+    """Run the command synchronously once (for /statusline show preview)."""
+    command = get_command()
+    if not command:
+        return ""
+    return _run_command_blocking(command)
+
+
+def reset_cache() -> None:
+    global _cached_output, _last_run_monotonic, _running
+    with _lock:
+        _cached_output = ""
+        _last_run_monotonic = 0.0
+        _running = False