code-puppy 0.0.97__py3-none-any.whl → 0.0.118__py3-none-any.whl

code_puppy/summarization_agent.py

@@ -1,41 +1,67 @@
-import os
-from pathlib import Path
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import List
 
 from pydantic_ai import Agent
 
+from code_puppy.config import get_model_name
 from code_puppy.model_factory import ModelFactory
-from code_puppy.tools.common import console
 
-# Environment variables used in this module:
-# - MODELS_JSON_PATH: Optional path to a custom models.json configuration file.
-#                     If not set, uses the default file in the package directory.
-# - MODEL_NAME: The model to use for code generation. Defaults to "gpt-4o".
-#               Must match a key in the models.json configuration.
+# Keep a module-level agent reference to avoid rebuilding per call
+_summarization_agent = None
 
-MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
+# Safe sync runner for async agent.run calls
+# Avoids "event loop is already running" by offloading to a separate thread loop when needed
+_thread_pool: ThreadPoolExecutor | None = None
+
+
+def _ensure_thread_pool():
+    global _thread_pool
+    if _thread_pool is None:
+        _thread_pool = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="summarizer-loop"
+        )
+    return _thread_pool
+
+
+async def _run_agent_async(agent: Agent, prompt: str, message_history: List):
+    return await agent.run(prompt, message_history=message_history)
 
-_LAST_MODEL_NAME = None
-_summarization_agent = None
+
+def run_summarization_sync(prompt: str, message_history: List) -> List:
+    agent = get_summarization_agent()
+    try:
+        # Try to detect if we're already in an event loop
+        asyncio.get_running_loop()
+
+        # We're in an event loop: offload to a dedicated thread with its own loop
+        def _worker(prompt_: str):
+            return asyncio.run(
+                _run_agent_async(agent, prompt_, message_history=message_history)
+            )
+
+        pool = _ensure_thread_pool()
+        result = pool.submit(_worker, prompt).result()
+    except RuntimeError:
+        # No running loop, safe to run directly
+        result = asyncio.run(
+            _run_agent_async(agent, prompt, message_history=message_history)
+        )
+    return result.new_messages()
 
 
 def reload_summarization_agent():
     """Create a specialized agent for summarizing messages when context limit is reached."""
-    global _summarization_agent, _LAST_MODEL_NAME
-    from code_puppy.config import get_model_name
-
-    model_name = get_model_name()
-    console.print(f"[bold cyan]Loading Summarization Model: {model_name}[/bold cyan]")
-    models_path = (
-        Path(MODELS_JSON_PATH)
-        if MODELS_JSON_PATH
-        else Path(__file__).parent / "models.json"
-    )
-    model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
+    models_config = ModelFactory.load_config()
+    model_name = "gemini-2.5-pro"
+    if model_name not in models_config:
+        model_name = get_model_name()
+    model = ModelFactory.get_model(model_name, models_config)
 
     # Specialized instructions for summarization
-    instructions = """You are a message summarization expert. Your task is to summarize conversation messages 
-while preserving important context and information. The summaries should be concise but capture the essential 
-content and intent of the original messages. This is to help manage token usage in a conversation history 
+    instructions = """You are a message summarization expert. Your task is to summarize conversation messages
+while preserving important context and information. The summaries should be concise but capture the essential
+content and intent of the original messages. This is to help manage token usage in a conversation history
 while maintaining context for the AI to continue the conversation effectively.
 
 When summarizing:
@@ -51,20 +77,15 @@ When summarizing:
         output_type=str,
         retries=1,  # Fewer retries for summarization
     )
-    _summarization_agent = agent
-    _LAST_MODEL_NAME = model_name
-    return _summarization_agent
+    return agent
 
 
-def get_summarization_agent(force_reload=False):
+def get_summarization_agent(force_reload=True):
     """
     Retrieve the summarization agent with the currently set MODEL_NAME.
     Forces a reload if the model has changed, or if force_reload is passed.
     """
-    global _summarization_agent, _LAST_MODEL_NAME
-    from code_puppy.config import get_model_name
-
-    model_name = get_model_name()
-    if _summarization_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
-        return reload_summarization_agent()
+    global _summarization_agent
+    if force_reload or _summarization_agent is None:
+        _summarization_agent = reload_summarization_agent()
     return _summarization_agent

code_puppy/token_utils.py

@@ -4,14 +4,12 @@ import pydantic
 from pydantic_ai.messages import ModelMessage
 
 
-def estimate_tokens(text: str) -> int:
+def estimate_token_count(text: str) -> int:
     """
-    Estimate the number of tokens using the len/4 heuristic.
-    This is a simple approximation that works reasonably well for most text.
+    Simple token estimation using len(message) - 4.
+    This replaces tiktoken with a much simpler approach.
     """
-    if not text:
-        return 0
-    return max(1, len(text) // 4)
+    return max(1, len(text) - 4)
 
 
 def stringify_message_part(part) -> str:
@@ -56,14 +54,14 @@ def stringify_message_part(part) -> str:
 
 def estimate_tokens_for_message(message: ModelMessage) -> int:
     """
-    Estimate the number of tokens in a message using the len/4 heuristic.
-    This is a simple approximation that works reasonably well for most text.
+    Estimate the number of tokens in a message using len(message) - 4.
+    Simple and fast replacement for tiktoken.
     """
     total_tokens = 0
 
     for part in message.parts:
         part_str = stringify_message_part(part)
         if part_str:
-            total_tokens += estimate_tokens(part_str)
+            total_tokens += estimate_token_count(part_str)
 
     return max(1, total_tokens)

code_puppy/tools/__init__.py

@@ -1,13 +1,10 @@
-from code_puppy.tools.command_runner import (
-    register_command_runner_tools, kill_all_running_shell_processes
-)
+from code_puppy.tools.command_runner import register_command_runner_tools
 from code_puppy.tools.file_modifications import register_file_modifications_tools
 from code_puppy.tools.file_operations import register_file_operations_tools
 
 
 def register_all_tools(agent):
     """Register all available tools to the provided agent."""
-
     register_file_operations_tools(agent)
     register_file_modifications_tools(agent)
     register_command_runner_tools(agent)

code_puppy/tools/command_runner.py

@@ -1,10 +1,10 @@
 import os
 import signal
 import subprocess
+import sys
 import threading
 import time
 import traceback
-import sys
 from typing import Set
 
 from pydantic import BaseModel
@@ -12,7 +12,15 @@ from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.text import Text
 
-from code_puppy.tools.common import console
+from code_puppy.messaging import (
+    emit_divider,
+    emit_error,
+    emit_info,
+    emit_system_message,
+    emit_warning,
+)
+from code_puppy.state_management import is_tui_mode
+from code_puppy.tools.common import generate_group_id
 
 _AWAITING_USER_INPUT = False
 
@@ -91,7 +99,7 @@ def _kill_process_group(proc: subprocess.Popen) -> None:
             except Exception:
                 pass
     except Exception as e:
-        console.print(f"Kill process error: {e}")
+        emit_error(f"Kill process error: {e}")
 
 
 def kill_all_running_shell_processes() -> int:
@@ -114,6 +122,38 @@ def kill_all_running_shell_processes() -> int:
     return count
 
 
+# Function to check if user input is awaited
+def is_awaiting_user_input():
+    """Check if command_runner is waiting for user input."""
+    global _AWAITING_USER_INPUT
+    return _AWAITING_USER_INPUT
+
+
+# Function to set user input flag
+def set_awaiting_user_input(awaiting=True):
+    """Set the flag indicating if user input is awaited."""
+    global _AWAITING_USER_INPUT
+    _AWAITING_USER_INPUT = awaiting
+
+    # When we're setting this flag, also pause/resume all active spinners
+    if awaiting:
+        # Pause all active spinners (imported here to avoid circular imports)
+        try:
+            from code_puppy.messaging.spinner import pause_all_spinners
+
+            pause_all_spinners()
+        except ImportError:
+            pass  # Spinner functionality not available
+    else:
+        # Resume all active spinners
+        try:
+            from code_puppy.messaging.spinner import resume_all_spinners
+
+            resume_all_spinners()
+        except ImportError:
+            pass  # Spinner functionality not available
+
+
 class ShellCommandOutput(BaseModel):
     success: bool
     command: str | None
@@ -127,7 +167,10 @@ class ShellCommandOutput(BaseModel):
 
 
 def run_shell_command_streaming(
-    process: subprocess.Popen, timeout: int = 60, command: str = ""
+    process: subprocess.Popen,
+    timeout: int = 60,
+    command: str = "",
+    group_id: str = None,
 ):
     start_time = time.time()
     last_output_time = [start_time]
@@ -146,7 +189,7 @@ def run_shell_command_streaming(
                 if line:
                     line = line.rstrip("\n\r")
                     stdout_lines.append(line)
-                    console.print(line)
+                    emit_system_message(line, message_group=group_id)
                     last_output_time[0] = time.time()
         except Exception:
             pass
@@ -157,7 +200,7 @@ def run_shell_command_streaming(
                 if line:
                     line = line.rstrip("\n\r")
                     stderr_lines.append(line)
-                    console.print(line)
+                    emit_system_message(line, message_group=group_id)
                     last_output_time[0] = time.time()
         except Exception:
             pass
@@ -188,19 +231,21 @@ def run_shell_command_streaming(
             if stdout_thread and stdout_thread.is_alive():
                 stdout_thread.join(timeout=3)
                 if stdout_thread.is_alive():
-                    console.print(
-                        f"stdout reader thread failed to terminate after {timeout_type} seconds"
+                    emit_warning(
+                        f"stdout reader thread failed to terminate after {timeout_type} timeout",
+                        message_group=group_id,
                     )
 
             if stderr_thread and stderr_thread.is_alive():
                 stderr_thread.join(timeout=3)
                 if stderr_thread.is_alive():
-                    console.print(
-                        f"stderr reader thread failed to terminate after {timeout_type} seconds"
+                    emit_warning(
+                        f"stderr reader thread failed to terminate after {timeout_type} timeout",
+                        message_group=group_id,
                     )
 
         except Exception as e:
-            console.log(f"Error during process cleanup {e}")
+            emit_warning(f"Error during process cleanup: {e}", message_group=group_id)
 
         execution_time = time.time() - start_time
         return ShellCommandOutput(
@@ -231,7 +276,7 @@ def run_shell_command_streaming(
                 error_msg.append(
                     "Process killed: inactivity timeout reached", style="bold red"
                 )
-                console.print(error_msg)
+                emit_error(error_msg, message_group=group_id)
                 return cleanup_process_and_threads("absolute")
 
             if current_time - last_output_time[0] > timeout:
@@ -239,7 +284,7 @@ def run_shell_command_streaming(
                 error_msg.append(
                     "Process killed: inactivity timeout reached", style="bold red"
                 )
-                console.print(error_msg)
+                emit_error(error_msg, message_group=group_id)
                 return cleanup_process_and_threads("inactivity")
 
             time.sleep(0.1)
@@ -265,10 +310,10 @@ def run_shell_command_streaming(
         _unregister_process(process)
 
         if exit_code != 0:
-            console.print(
-                f"Command failed with exit code {exit_code}", style="bold red"
+            emit_error(
+                f"Command failed with exit code {exit_code}", message_group=group_id
             )
-            console.print(f"Took {execution_time:.2f}s", style="dim")
+            emit_info(f"Took {execution_time:.2f}s", message_group=group_id)
             time.sleep(1)
             return ShellCommandOutput(
                 success=False,
@@ -296,7 +341,7 @@ def run_shell_command_streaming(
         return ShellCommandOutput(
             success=False,
             command=command,
-            error=f"Error durign streaming execution {str(e)}",
+            error=f"Error during streaming execution: {str(e)}",
             stdout="\n".join(stdout_lines[-1000:]),
             stderr="\n".join(stderr_lines[-1000:]),
             exit_code=-1,
@@ -308,14 +353,21 @@ def run_shell_command(
     context: RunContext, command: str, cwd: str = None, timeout: int = 60
 ) -> ShellCommandOutput:
     command_displayed = False
+
+    # Generate unique group_id for this command execution
+    group_id = generate_group_id("shell_command", command)
+
     if not command or not command.strip():
-        console.print("[bold red]Error:[/bold red] Command cannot be empty")
+        emit_error("Command cannot be empty", message_group=group_id)
         return ShellCommandOutput(
             **{"success": False, "error": "Command cannot be empty"}
         )
-    console.print(
-        f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] \U0001f4c2 [bold green]$ {command}[/bold green]"
+
+    emit_info(
+        f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] 📂 [bold green]$ {command}[/bold green]",
+        message_group=group_id,
     )
+
     from code_puppy.config import get_yolo_mode
 
     yolo_mode = get_yolo_mode()
@@ -335,7 +387,11 @@ def run_shell_command(
         command_displayed = True
 
         if cwd:
-            console.print(f"[dim] Working directory: {cwd} [/dim]")
+            emit_info(f"[dim] Working directory: {cwd} [/dim]", message_group=group_id)
+
+        # Set the flag to indicate we're awaiting user input
+        set_awaiting_user_input(True)
+
         time.sleep(0.2)
         sys.stdout.write("Are you sure you want to run this command? (y(es)/n(o))\n")
         sys.stdout.flush()
@@ -344,9 +400,11 @@ def run_shell_command(
             user_input = input()
             confirmed = user_input.strip().lower() in {"yes", "y"}
         except (KeyboardInterrupt, EOFError):
-            console.print("\n Cancelled by user")
+            emit_warning("\n Cancelled by user")
             confirmed = False
         finally:
+            # Clear the flag regardless of the outcome
+            set_awaiting_user_input(False)
             if confirmation_lock_acquired:
                 _CONFIRMATION_LOCK.release()
 
@@ -357,6 +415,7 @@ def run_shell_command(
             return result
     else:
         start_time = time.time()
+
     try:
         creationflags = 0
         preexec_fn = None
@@ -367,6 +426,7 @@ def run_shell_command(
                 creationflags = 0
         else:
             preexec_fn = os.setsid if hasattr(os, "setsid") else None
+
         process = subprocess.Popen(
             command,
             shell=True,
@@ -382,13 +442,13 @@ def run_shell_command(
         _register_process(process)
         try:
             return run_shell_command_streaming(
-                process, timeout=timeout, command=command
+                process, timeout=timeout, command=command, group_id=group_id
             )
         finally:
             # Ensure unregistration in case streaming returned early or raised
             _unregister_process(process)
     except Exception as e:
-        console.print(traceback.format_exc())
+        emit_error(traceback.format_exc(), message_group=group_id)
         if "stdout" not in locals():
             stdout = None
         if "stderr" not in locals():
@@ -411,25 +471,120 @@ class ReasoningOutput(BaseModel):
 def share_your_reasoning(
     context: RunContext, reasoning: str, next_steps: str | None = None
 ) -> ReasoningOutput:
-    console.print("\n[bold white on purple] AGENT REASONING [/bold white on purple]")
-    console.print("[bold cyan]Current reasoning:[/bold cyan]")
-    console.print(Markdown(reasoning))
+    # Generate unique group_id for this reasoning session
+    group_id = generate_group_id(
+        "agent_reasoning", reasoning[:50]
+    )  # Use first 50 chars for context
+
+    if not is_tui_mode():
+        emit_divider(message_group=group_id)
+        emit_info(
+            "\n[bold white on purple] AGENT REASONING [/bold white on purple]",
+            message_group=group_id,
+        )
+    emit_info("[bold cyan]Current reasoning:[/bold cyan]", message_group=group_id)
+    emit_system_message(Markdown(reasoning), message_group=group_id)
     if next_steps is not None and next_steps.strip():
-        console.print("\n[bold cyan]Planned next steps:[/bold cyan]")
-        console.print(Markdown(next_steps))
-    console.print("[dim]" + "-" * 60 + "[/dim]\n")
+        emit_info(
+            "\n[bold cyan]Planned next steps:[/bold cyan]", message_group=group_id
+        )
+        emit_system_message(Markdown(next_steps), message_group=group_id)
+    emit_info("[dim]" + "-" * 60 + "[/dim]\n", message_group=group_id)
     return ReasoningOutput(**{"success": True})
 
 
 def register_command_runner_tools(agent):
     @agent.tool
     def agent_run_shell_command(
-        context: RunContext, command: str, cwd: str = None, timeout: int = 60
+        context: RunContext, command: str = "", cwd: str = None, timeout: int = 60
     ) -> ShellCommandOutput:
+        """Execute a shell command with comprehensive monitoring and safety features.
+
+        This tool provides robust shell command execution with streaming output,
+        timeout handling, user confirmation (when not in yolo mode), and proper
+        process lifecycle management. Commands are executed in a controlled
+        environment with cross-platform process group handling.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            command (str): The shell command to execute. Cannot be empty or whitespace-only.
+            cwd (str, optional): Working directory for command execution. If None,
+                uses the current working directory. Defaults to None.
+            timeout (int, optional): Inactivity timeout in seconds. If no output is
+                produced for this duration, the process will be terminated.
+                Defaults to 60 seconds.
+
+        Returns:
+            ShellCommandOutput: A structured response containing:
+                - success (bool): True if command executed successfully (exit code 0)
+                - command (str | None): The executed command string
+                - error (str | None): Error message if execution failed
+                - stdout (str | None): Standard output from the command (last 1000 lines)
+                - stderr (str | None): Standard error from the command (last 1000 lines)
+                - exit_code (int | None): Process exit code
+                - execution_time (float | None): Total execution time in seconds
+                - timeout (bool | None): True if command was terminated due to timeout
+                - user_interrupted (bool | None): True if user killed the process
+
+        Note:
+            - In interactive mode (not yolo), user confirmation is required before execution
+            - Commands have an absolute timeout of 270 seconds regardless of activity
+            - Process groups are properly managed for clean termination
+            - Output is streamed in real-time and displayed to the user
+            - Large output is truncated to the last 1000 lines for memory efficiency
+
+        Examples:
+            >>> result = agent_run_shell_command(ctx, "ls -la", cwd="/tmp", timeout=30)
+            >>> if result.success:
+            ...     print(f"Command completed in {result.execution_time:.2f}s")
+            ...     print(result.stdout)
+
+        Warning:
+            This tool can execute arbitrary shell commands. Exercise caution when
+            running untrusted commands, especially those that modify system state.
+        """
         return run_shell_command(context, command, cwd, timeout)
 
     @agent.tool
     def agent_share_your_reasoning(
-        context: RunContext, reasoning: str, next_steps: str | None = None
+        context: RunContext, reasoning: str = "", next_steps: str | None = None
     ) -> ReasoningOutput:
+        """Share the agent's current reasoning and planned next steps with the user.
+
+        This tool provides transparency into the agent's decision-making process
+        by displaying the current reasoning and upcoming actions in a formatted,
+        user-friendly manner. It's essential for building trust and understanding
+        between the agent and user.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            reasoning (str): The agent's current thought process, analysis, or
+                reasoning for the current situation. This should be clear,
+                comprehensive, and explain the 'why' behind decisions.
+            next_steps (str | None, optional): Planned upcoming actions or steps
+                the agent intends to take. Can be None if no specific next steps
+                are determined. Defaults to None.
+
+        Returns:
+            ReasoningOutput: A simple response object containing:
+                - success (bool): Always True, indicating the reasoning was shared
+
+        Note:
+            - Reasoning is displayed with Markdown formatting for better readability
+            - Next steps are only shown if provided and non-empty
+            - Output is visually separated with dividers in TUI mode
+            - This tool should be called before major actions to explain intent
+
+        Examples:
+            >>> reasoning = "I need to analyze the codebase structure before making changes"
+            >>> next_steps = "First, I'll list the directory contents, then read key files"
+            >>> result = agent_share_your_reasoning(ctx, reasoning, next_steps)
+
+        Best Practice:
+            Use this tool frequently to maintain transparency. Call it:
+            - Before starting complex operations
+            - When changing strategy or approach
+            - To explain why certain decisions are being made
+            - When encountering unexpected situations
+        """
         return share_your_reasoning(context, reasoning, next_steps)

code_puppy/tools/common.py

@@ -1,43 +1,27 @@
-import os
 import fnmatch
-
+import hashlib
+import os
+import time
+from pathlib import Path
 from typing import Optional, Tuple
+
 from rapidfuzz.distance import JaroWinkler
 from rich.console import Console
 
-from pathlib import Path
-# get_model_context_length will be imported locally where needed to avoid circular imports
-
-NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
-console = Console(no_color=NO_COLOR)
-
-
-def get_model_context_length() -> int:
-    """
-    Get the context length for the currently configured model from models.json
-    """
-    # Import locally to avoid circular imports
-    from code_puppy.model_factory import ModelFactory
-    from code_puppy.config import get_model_name
-    import os
-    from pathlib import Path
-
-    # Load model configuration
-    models_path = os.environ.get("MODELS_JSON_PATH")
-    if not models_path:
-        models_path = Path(__file__).parent.parent / "models.json"
-    else:
-        models_path = Path(models_path)
-
-    model_configs = ModelFactory.load_config(str(models_path))
-    model_name = get_model_name()
-
-    # Get context length from model config
-    model_config = model_configs.get(model_name, {})
-    context_length = model_config.get("context_length", 128000)  # Default value
+# Import our queue-based console system
+try:
+    from code_puppy.messaging import get_queue_console
 
-    # Reserve 10% of context for response
-    return int(context_length)
+    # Use queue console by default, but allow fallback
+    NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
+    _rich_console = Console(no_color=NO_COLOR)
+    console = get_queue_console()
+    # Set the fallback console for compatibility
+    console.fallback_console = _rich_console
+except ImportError:
+    # Fallback to regular Rich console if messaging system not available
+    NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
+    console = Console(no_color=NO_COLOR)
 
 
 # -------------------
@@ -77,7 +61,7 @@ IGNORE_PATTERNS = [
     "**/.parcel-cache/**",
     "**/.vite/**",
     "**/storybook-static/**",
-    "**/*.tsbuildinfo/*",
+    "**/*.tsbuildinfo/**",
     # Python
     "**/__pycache__/**",
     "**/__pycache__",
@@ -104,6 +88,7 @@ IGNORE_PATTERNS = [
     "**/*.egg-info/**",
     "**/dist/**",
     "**/wheels/**",
+    "**/pytest-reports/**",
     # Java (Maven, Gradle, SBT)
     "**/target/**",
     "**/target",
@@ -384,3 +369,27 @@ def _find_best_window(
     console.log(f"Best window: {best_window}")
     console.log(f"Best score: {best_score}")
     return best_span, best_score
+
+
+def generate_group_id(tool_name: str, extra_context: str = "") -> str:
+    """Generate a unique group_id for tool output grouping.
+
+    Args:
+        tool_name: Name of the tool (e.g., 'list_files', 'edit_file')
+        extra_context: Optional extra context to make group_id more unique
+
+    Returns:
+        A string in format: tool_name_hash
+    """
+    # Create a unique identifier using timestamp, context, and a random component
+    import random
+
+    timestamp = str(int(time.time() * 1000000))  # microseconds for more uniqueness
+    random_component = random.randint(1000, 9999)  # Add randomness
+    context_string = f"{tool_name}_{timestamp}_{random_component}_{extra_context}"
+
+    # Generate a short hash
+    hash_obj = hashlib.md5(context_string.encode())
+    short_hash = hash_obj.hexdigest()[:8]
+
+    return f"{tool_name}_{short_hash}"