code-puppy 0.0.186__tar.gz → 0.0.188__tar.gz

{code_puppy-0.0.186 → code_puppy-0.0.188}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.186
+Version: 0.0.188
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -39,8 +39,6 @@ Requires-Dist: tenacity>=8.2.0
 Requires-Dist: termcolor>=3.1.0
 Requires-Dist: textual-dev>=1.7.0
 Requires-Dist: textual>=5.0.0
-Requires-Dist: tree-sitter-language-pack>=0.8.0
-Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: uvicorn>=0.29.0
 Description-Content-Type: text/markdown
 

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/agents/base_agent.py

@@ -42,6 +42,10 @@ from code_puppy.messaging import (
     emit_system_message,
     emit_warning,
 )
+from code_puppy.messaging.spinner import (
+    SpinnerBase,
+    update_spinner_context,
+)
 from code_puppy.model_factory import ModelFactory
 from code_puppy.summarization_agent import run_summarization_sync
 from code_puppy.tools.common import console
@@ -527,6 +531,11 @@ class BaseAgent(ABC):
         # Check if we're in TUI mode and can update the status bar
         from code_puppy.tui_state import get_tui_app_instance, is_tui_mode
 
+        context_summary = SpinnerBase.format_context_info(
+            total_current_tokens, model_max, proportion_used
+        )
+        update_spinner_context(context_summary)
+
         if is_tui_mode():
             tui_app = get_tui_app_instance()
             if tui_app:
@@ -538,22 +547,11 @@ class BaseAgent(ABC):
                     )
                 except Exception as e:
                     emit_error(e)
-                    # Fallback to chat message if status bar update fails
-                    emit_info(
-                        f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n",
-                        message_group="token_context_status",
-                    )
             else:
-                # Fallback if no TUI app instance
                 emit_info(
-                    f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n",
+                    f"Final token count after processing: {total_current_tokens}",
                     message_group="token_context_status",
                 )
-        else:
-            # Non-TUI mode - emit to console as before
-            emit_info(
-                f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n"
-            )
         # Get the configured compaction threshold
         compaction_threshold = get_compaction_threshold()
 
@@ -578,6 +576,11 @@ class BaseAgent(ABC):
                 self.estimate_tokens_for_message(msg) for msg in result_messages
             )
             # Update status bar with final token count if in TUI mode
+            final_summary = SpinnerBase.format_context_info(
+                final_token_count, model_max, final_token_count / model_max
+            )
+            update_spinner_context(final_summary)
+
             if is_tui_mode():
                 tui_app = get_tui_app_instance()
                 if tui_app:
@@ -596,8 +599,6 @@ class BaseAgent(ABC):
                         f"Final token count after processing: {final_token_count}",
                         message_group="token_context_status",
                     )
-            else:
-                emit_info(f"Final token count after processing: {final_token_count}")
             self.set_message_history(result_messages)
             for m in summarized_messages:
                 self.add_compacted_message_hash(self.hash_message(m))

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/callbacks.py

@@ -15,6 +15,8 @@ PhaseType = Literal[
     "load_model_config",
     "load_prompt",
     "agent_reload",
+    "custom_command",
+    "custom_command_help",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -30,6 +32,8 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "load_model_config": [],
     "load_prompt": [],
     "agent_reload": [],
+    "custom_command": [],
+    "custom_command_help": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -174,3 +178,31 @@ def on_agent_reload(*args, **kwargs) -> Any:
 
 def on_load_prompt():
     return _trigger_callbacks_sync("load_prompt")
+
+
+def on_custom_command_help() -> List[Any]:
+    """Collect custom command help entries from plugins.
+
+    Each callback should return a list of tuples [(name, description), ...]
+    or a single tuple, or None. We'll flatten and sanitize results.
+    """
+    return _trigger_callbacks_sync("custom_command_help")
+
+
+def on_custom_command(command: str, name: str) -> List[Any]:
+    """Trigger custom command callbacks.
+
+    This allows plugins to register handlers for slash commands
+    that are not built into the core command handler.
+
+    Args:
+        command: The full command string (e.g., "/foo bar baz").
+        name: The primary command name without the leading slash (e.g., "foo").
+
+    Returns:
+        Implementations may return:
+        - True if the command was handled (and no further action is needed)
+        - A string to be processed as user input by the caller
+        - None to indicate not handled
+    """
+    return _trigger_callbacks_sync("custom_command", command, name)

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/command_line/command_handler.py

@@ -11,6 +11,9 @@ def get_commands_help():
     """Generate commands help using Rich Text objects to avoid markup conflicts."""
     from rich.text import Text
 
+    # Ensure plugins are loaded so custom help can register
+    _ensure_plugins_loaded()
+
     # Build help text programmatically
     help_lines = []
 
@@ -90,6 +93,33 @@ def get_commands_help():
         + Text("            Show unknown command warning")
     )
 
+    # Add custom commands from plugins (if any)
+    try:
+        from code_puppy import callbacks
+
+        custom_help_results = callbacks.on_custom_command_help()
+        # Flatten various returns into a list of (name, description)
+        custom_entries = []
+        for res in custom_help_results:
+            if not res:
+                continue
+            if isinstance(res, tuple) and len(res) == 2:
+                custom_entries.append(res)
+            elif isinstance(res, list):
+                for item in res:
+                    if isinstance(item, tuple) and len(item) == 2:
+                        custom_entries.append(item)
+        if custom_entries:
+            help_lines.append(Text("\n", style="dim"))
+            help_lines.append(Text("Custom Commands", style="bold magenta"))
+            for name, desc in custom_entries:
+                help_lines.append(
+                    Text(f"/{name}", style="cyan") + Text(f"  {desc}")
+                )
+    except Exception:
+        # If callbacks fail, skip custom help silently
+        pass
+
     # Combine all lines
     final_text = Text()
     for i, line in enumerate(help_lines):
@@ -100,8 +130,32 @@ def get_commands_help():
     return final_text
 
 
+_PLUGINS_LOADED = False
+
+
+def _ensure_plugins_loaded() -> None:
+    global _PLUGINS_LOADED
+    if _PLUGINS_LOADED:
+        return
+    try:
+        from code_puppy import plugins
+
+        plugins.load_plugin_callbacks()
+        _PLUGINS_LOADED = True
+    except Exception as e:
+        # If plugins fail to load, continue gracefully but note it
+        try:
+            from code_puppy.messaging import emit_warning
+
+            emit_warning(f"Plugin load error: {e}")
+        except Exception:
+            pass
+        _PLUGINS_LOADED = True
+
+
 def handle_command(command: str):
     from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+    _ensure_plugins_loaded()
 
     """
     Handle commands prefixed with '/'.
@@ -400,6 +454,8 @@ def handle_command(command: str):
 
         handler = MCPCommandHandler()
         return handler.handle_mcp_command(command)
+
+    # Built-in help
     if command in ("/help", "/h"):
         import uuid
 
@@ -705,8 +761,30 @@ def handle_command(command: str):
         # Signal to the main app that we want to exit
         # The actual exit handling is done in main.py
         return True
+
+    # Try plugin-provided custom commands before unknown warning
     if command.startswith("/"):
+        # Extract command name without leading slash and arguments intact
         name = command[1:].split()[0] if len(command) > 1 else ""
+        try:
+            from code_puppy import callbacks
+
+            results = callbacks.on_custom_command(command=command, name=name)
+            # Iterate through callback results; treat str as handled (no model run)
+            for res in results:
+                if res is True:
+                    return True
+                if isinstance(res, str):
+                    # Display returned text to the user and treat as handled
+                    try:
+                        emit_info(res)
+                    except Exception:
+                        pass
+                    return True
+        except Exception as e:
+            # Log via emit_error but do not block default handling
+            emit_warning(f"Custom command hook error: {e}")
+
         if name:
             emit_warning(
                 f"Unknown command: {command}\n[dim]Type /help for options.[/dim]"

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/messaging/spinner/__init__.py

@@ -44,6 +44,16 @@ def resume_all_spinners():
             pass
 
 
+def update_spinner_context(info: str) -> None:
+    """Update the shared context information displayed beside active spinners."""
+    SpinnerBase.set_context_info(info)
+
+
+def clear_spinner_context() -> None:
+    """Clear any context information displayed beside active spinners."""
+    SpinnerBase.clear_context_info()
+
+
 __all__ = [
     "SpinnerBase",
     "TextualSpinner",
@@ -52,4 +62,6 @@ __all__ = [
     "unregister_spinner",
     "pause_all_spinners",
     "resume_all_spinners",
+    "update_spinner_context",
+    "clear_spinner_context",
 ]

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/messaging/spinner/console_spinner.py

@@ -103,6 +103,11 @@ class ConsoleSpinner(SpinnerBase):
 
         text.append(self.current_frame, style="bold cyan")
 
+        context_info = SpinnerBase.get_context_info()
+        if context_info:
+            text.append(" ")
+            text.append(context_info, style="bold white")
+
         # Return a simple Text object instead of a Panel for a cleaner look
         return text
 

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/messaging/spinner/spinner_base.py

@@ -3,6 +3,7 @@ Base spinner implementation to be extended for different UI modes.
 """
 
 from abc import ABC, abstractmethod
+from threading import Lock
 
 from code_puppy.config import get_puppy_name
 
@@ -33,6 +34,9 @@ class SpinnerBase(ABC):
     # Current message - starts with thinking by default
     MESSAGE = THINKING_MESSAGE
 
+    _context_info: str = ""
+    _context_lock: Lock = Lock()
+
     def __init__(self):
         """Initialize the spinner."""
         self._is_spinning = False
@@ -64,3 +68,30 @@ class SpinnerBase(ABC):
     def is_spinning(self):
         """Check if the spinner is currently spinning."""
         return self._is_spinning
+
+    @classmethod
+    def set_context_info(cls, info: str) -> None:
+        """Set shared context information displayed beside the spinner."""
+        with cls._context_lock:
+            cls._context_info = info
+
+    @classmethod
+    def clear_context_info(cls) -> None:
+        """Clear any context information displayed beside the spinner."""
+        cls.set_context_info("")
+
+    @classmethod
+    def get_context_info(cls) -> str:
+        """Return the current spinner context information."""
+        with cls._context_lock:
+            return cls._context_info
+
+    @staticmethod
+    def format_context_info(total_tokens: int, capacity: int, proportion: float) -> str:
+        """Create a concise context summary for spinner display."""
+        if capacity <= 0:
+            return ""
+        proportion_pct = proportion * 100
+        return (
+            f"Tokens: {total_tokens:,}/{capacity:,} ({proportion_pct:.1f}% used)"
+        )

{code_puppy-0.0.186 → code_puppy-0.0.188}/code_puppy/messaging/spinner/textual_spinner.py

@@ -70,8 +70,13 @@ class TextualSpinner(Static):
                 # Show thinking message during normal processing
                 message = SpinnerBase.THINKING_MESSAGE
 
+            context_info = SpinnerBase.get_context_info()
+            context_segment = (
+                f" [bold white]{context_info}[/bold white]" if context_info else ""
+            )
+
             self.update(
-                f"[bold cyan]{message}[/bold cyan][bold cyan]{current_frame}[/bold cyan]"
+                f"[bold cyan]{message}[/bold cyan][bold cyan]{current_frame}[/bold cyan]{context_segment}"
             )
 
     def pause(self):

code_puppy-0.0.188/code_puppy/plugins/example_custom_command/register_callbacks.py

@@ -0,0 +1,51 @@
+from code_puppy.callbacks import register_callback
+from code_puppy.messaging import emit_info
+
+
+def _custom_help():
+    return [
+        ("woof", "Emit a playful woof message (no model)"),
+        ("echo", "Echo back your text (display only)"),
+    ]
+
+
+def _handle_custom_command(command: str, name: str):
+    """Handle a demo custom command.
+
+    Policy: custom commands must NOT invoke the model. They should emit
+    messages or return True to indicate handling. Returning a string is
+    treated as a display-only message by the command handler.
+
+    Supports:
+    - /woof          → emits a fun message and returns True
+    - /echo <text>   → emits the text (display-only)
+    """
+    if not name:
+        return None
+
+    if name == "woof":
+        # If extra text is provided, pass it as a prompt; otherwise, send a fun default
+        parts = command.split(maxsplit=1)
+        if len(parts) == 2:
+            text = parts[1]
+            emit_info(f"🐶 Woof! sending prompt: {text}")
+            return text
+        emit_info("🐶 Woof! sending prompt: Tell me a dog fact")
+        return "Tell me a dog fact"
+
+    if name == "echo":
+        # Return the rest of the command (after the name) to be treated as input
+        # Example: "/echo Hello" → returns "Hello"
+        rest = command.split(maxsplit=1)
+        if len(rest) == 2:
+            text = rest[1]
+            emit_info(f"[dim]example plugin echo ->[/dim] {text}")
+            return text
+        emit_info("[dim]example plugin echo (empty)[/dim]")
+        return ""
+
+    return None
+
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

{code_puppy-0.0.186 → code_puppy-0.0.188}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.186"
+version = "0.0.188"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -23,8 +23,6 @@ dependencies = [
     "pathspec>=0.11.0",
     "rapidfuzz>=3.13.0",
     "json-repair>=0.46.2",
-    "tree-sitter-language-pack>=0.8.0",
-    "tree-sitter-typescript>=0.23.2",
     "fastapi>=0.110.0",
     "uvicorn>=0.29.0",
     "PyJWT>=2.8.0",