code-puppy 0.0.84__py3-none-any.whl → 0.0.86__py3-none-any.whl

code_puppy/__init__.py

@@ -1,5 +1,6 @@
 try:
     import importlib.metadata
+
     __version__ = importlib.metadata.version("code-puppy")
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.0.1"

code_puppy/agent.py

@@ -79,7 +79,7 @@ def reload_code_generation_agent():
         instructions=instructions,
         output_type=str,
         retries=3,
-        history_processors=[message_history_accumulator]
+        history_processors=[message_history_accumulator],
     )
     register_all_tools(agent)
     _code_generation_agent = agent

code_puppy/agent_prompts.py

@@ -101,9 +101,7 @@ Important rules:
 
 Your solutions should be production-ready, maintainable, and follow best practices for the chosen language.
 
-Return your final response as a structured output having the following fields:
- * output_message: The final output message to display to the user
- * awaiting_user_input: True if user input is needed to continue the task. If you get an error, you might consider asking the user for help.
+Return your final response as a string output
 """
 
 

code_puppy/command_line/motd.py

@@ -48,4 +48,4 @@ def print_motd(console, force: bool = False) -> bool:
         console.print(MOTD_MESSAGE)
         mark_motd_seen(MOTD_VERSION)
         return True
-    return False
+    return False

code_puppy/main.py

@@ -21,7 +21,8 @@ from code_puppy.state_management import get_message_history, set_message_history
 # Initialize rich console for pretty output
 from code_puppy.tools.common import console
 from code_puppy.version_checker import fetch_latest_version
-from code_puppy.message_history_processor import message_history_processor
+from code_puppy.message_history_processor import message_history_processor, prune_interrupted_tool_calls
+
 
 # from code_puppy.tools import *  # noqa: F403
 
@@ -193,13 +194,13 @@ async def interactive_mode(history_file_path: str) -> None:
             try:
                 prettier_code_blocks()
                 local_cancelled = False
+
                 async def run_agent_task():
                     try:
                         agent = get_code_generation_agent()
                         async with agent.run_mcp_servers():
                             return await agent.run(
-                                task,
-                                message_history=get_message_history()
+                                task, message_history=get_message_history()
                             )
                     except Exception as e:
                         console.log("Task failed", e)
@@ -207,20 +208,30 @@ async def interactive_mode(history_file_path: str) -> None:
                 agent_task = asyncio.create_task(run_agent_task())
 
                 import signal
+                from code_puppy.tools import kill_all_running_shell_processes
 
                 original_handler = None
 
+                # Ensure the interrupt handler only acts once per task
+                handled = False
                 def keyboard_interrupt_handler(sig, frame):
                     nonlocal local_cancelled
-                    if not agent_task.done():
-                        set_message_history(
-                            message_history_processor(
-                                get_message_history()
-                            )
-                        )
-                        agent_task.cancel()
-                        local_cancelled = True
-
+                    nonlocal handled
+                    if handled:
+                        return
+                    handled = True
+                    # First, nuke any running shell processes triggered by tools
+                    try:
+                        killed = kill_all_running_shell_processes()
+                        if killed:
+                            console.print(f"[yellow]Cancelled {killed} running shell process(es).[/yellow]")
+                        else:
+                            # Then cancel the agent task
+                            if not agent_task.done():
+                                agent_task.cancel()
+                                local_cancelled = True
+                    except Exception as e:
+                        console.print(f"[dim]Shell kill error: {e}[/dim]")
                 try:
                     original_handler = signal.getsignal(signal.SIGINT)
                     signal.signal(signal.SIGINT, keyboard_interrupt_handler)

code_puppy/message_history_processor.py

@@ -1,30 +1,40 @@
 import json
-import queue
-from typing import List
+from typing import List, Set
 import os
 from pathlib import Path
 
 import pydantic
 import tiktoken
-from pydantic_ai.messages import ModelMessage, ToolCallPart, ToolReturnPart, UserPromptPart, TextPart, ModelRequest, ModelResponse
+from pydantic_ai.messages import (
+    ModelMessage,
+    TextPart,
+    ModelResponse,
+    ModelRequest,
+    ToolCallPart,
+)
 
-from code_puppy.config import get_message_history_limit
 from code_puppy.tools.common import console
 from code_puppy.model_factory import ModelFactory
 from code_puppy.config import get_model_name
 
 # Import summarization agent
 try:
-    from code_puppy.summarization_agent import get_summarization_agent as _get_summarization_agent
+    from code_puppy.summarization_agent import (
+        get_summarization_agent as _get_summarization_agent,
+    )
+
     SUMMARIZATION_AVAILABLE = True
-    
+
     # Make the function available in this module's namespace for mocking
     def get_summarization_agent():
         return _get_summarization_agent()
-        
+
 except ImportError:
     SUMMARIZATION_AVAILABLE = False
-    console.print("[yellow]Warning: Summarization agent not available. Message history will be truncated instead of summarized.[/yellow]")
+    console.print(
+        "[yellow]Warning: Summarization agent not available. Message history will be truncated instead of summarized.[/yellow]"
+    )
+
     def get_summarization_agent():
         return None
 
@@ -40,10 +50,10 @@ def get_tokenizer_for_model(model_name: str):
 def stringify_message_part(part) -> str:
     """
     Convert a message part to a string representation for token estimation or other uses.
-    
+
     Args:
         part: A message part that may contain content or be a tool call
-        
+
     Returns:
         String representation of the message part
     """
@@ -54,7 +64,7 @@ def stringify_message_part(part) -> str:
         result += str(type(part)) + ": "
 
     # Handle content
-    if hasattr(part, 'content') and part.content:
+    if hasattr(part, "content") and part.content:
         # Handle different content types
         if isinstance(part.content, str):
             result = part.content
@@ -64,16 +74,16 @@ def stringify_message_part(part) -> str:
             result = json.dumps(part.content)
         else:
             result = str(part.content)
-    
+
     # Handle tool calls which may have additional token costs
     # If part also has content, we'll process tool calls separately
-    if hasattr(part, 'tool_name') and part.tool_name:
+    if hasattr(part, "tool_name") and part.tool_name:
         # Estimate tokens for tool name and parameters
         tool_text = part.tool_name
         if hasattr(part, "args"):
             tool_text += f" {str(part.args)}"
         result += tool_text
-            
+
     return result
 
 
@@ -84,27 +94,22 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     """
     tokenizer = get_tokenizer_for_model(get_model_name())
     total_tokens = 0
-    
+
     for part in message.parts:
         part_str = stringify_message_part(part)
         if part_str:
             tokens = tokenizer.encode(part_str)
             total_tokens += len(tokens)
-            
+
     return max(1, total_tokens)
 
 
 def summarize_messages(messages: List[ModelMessage]) -> ModelMessage:
-
-    # Get the summarization agent
     summarization_agent = get_summarization_agent()
-    message_strings = []
-
+    message_strings: List[str] = []
     for message in messages:
         for part in message.parts:
             message_strings.append(stringify_message_part(part))
-
-
     summary_string = "\n".join(message_strings)
     instructions = (
         "Above I've given you a log of Agentic AI steps that have been taken"
@@ -116,19 +121,53 @@ def summarize_messages(messages: List[ModelMessage]) -> ModelMessage:
         "\n Make sure your result is a bulleted list of all steps and interactions."
     )
     try:
-        # Run the summarization agent
         result = summarization_agent.run_sync(f"{summary_string}\n{instructions}")
-        
-        # Create a new message with the summarized content
-        summarized_parts = [TextPart(result.output)]
-        summarized_message = ModelResponse(parts=summarized_parts)
-        return summarized_message
+        return ModelResponse(parts=[TextPart(result.output)])
     except Exception as e:
         console.print(f"Summarization failed during compaction: {e}")
-        # Return original message if summarization fails
         return None
 
 
+# New: single-message summarization helper used by tests
+# - If the message has a ToolCallPart, return original message (no summarization)
+# - If the message has system/instructions, return original message
+# - Otherwise, summarize and return a new ModelRequest with the summarized content
+# - On any error, return the original message
+
+
+def summarize_message(message: ModelMessage) -> ModelMessage:
+    if not SUMMARIZATION_AVAILABLE:
+        return message
+    try:
+        # If the message looks like a system/instructions message, skip summarization
+        instructions = getattr(message, "instructions", None)
+        if instructions:
+            return message
+        # If any part is a tool call, skip summarization
+        for part in message.parts:
+            if isinstance(part, ToolCallPart) or getattr(part, "tool_name", None):
+                return message
+        # Build prompt from textual content parts
+        content_bits: List[str] = []
+        for part in message.parts:
+            s = stringify_message_part(part)
+            if s:
+                content_bits.append(s)
+        if not content_bits:
+            return message
+        prompt = (
+            "Please summarize the following user message:\n"
+            + "\n".join(content_bits)
+        )
+        agent = get_summarization_agent()
+        result = agent.run_sync(prompt)
+        summarized = ModelRequest([TextPart(result.output)])
+        return summarized
+    except Exception as e:
+        console.print(f"Summarization failed: {e}")
+        return message
+
+
 def get_model_context_length() -> int:
     """
     Get the context length for the currently configured model from models.json
@@ -139,33 +178,84 @@ def get_model_context_length() -> int:
         models_path = Path(__file__).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
-    
+
     # Reserve 10% of context for response
     return int(context_length)
 
+def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMessage]:
+    """
+    Remove any messages that participate in mismatched tool call sequences.
+
+    A mismatched tool call id is one that appears in a ToolCall (model/tool request)
+    without a corresponding tool return, or vice versa. We preserve original order
+    and only drop messages that contain parts referencing mismatched tool_call_ids.
+    """
+    if not messages:
+        return messages
 
-def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
+    tool_call_ids: Set[str] = set()
+    tool_return_ids: Set[str] = set()
+
+    # First pass: collect ids for calls vs returns
+    for msg in messages:
+        for part in getattr(msg, "parts", []) or []:
+            tool_call_id = getattr(part, "tool_call_id", None)
+            if not tool_call_id:
+                continue
+            # Heuristic: if it's an explicit ToolCallPart or has a tool_name/args,
+            # consider it a call; otherwise it's a return/result.
+            if part.part_kind == "tool-call":
+                tool_call_ids.add(tool_call_id)
+            else:
+                tool_return_ids.add(tool_call_id)
+
+    mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
+    if not mismatched:
+        return messages
 
+    pruned: List[ModelMessage] = []
+    dropped_count = 0
+    for msg in messages:
+        has_mismatched = False
+        for part in getattr(msg, "parts", []) or []:
+            tcid = getattr(part, "tool_call_id", None)
+            if tcid and tcid in mismatched:
+                has_mismatched = True
+                break
+        if has_mismatched:
+            dropped_count += 1
+            continue
+        pruned.append(msg)
+
+    if dropped_count:
+        console.print(f"[yellow]Pruned {dropped_count} message(s) with mismatched tool_call_id pairs[/yellow]")
+    return pruned
+
+
+def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
+    # First, prune any interrupted/mismatched tool-call conversations
     total_current_tokens = sum(estimate_tokens_for_message(msg) for msg in messages)
 
     model_max = get_model_context_length()
 
     proportion_used = total_current_tokens / model_max
     console.print(f"""
-[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used}
+[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f}
 """)
 
     if proportion_used > 0.9:
         summary = summarize_messages(messages)
         result_messages = [messages[0], summary]
-        final_token_count = sum(estimate_tokens_for_message(msg) for msg in result_messages)
+        final_token_count = sum(
+            estimate_tokens_for_message(msg) for msg in result_messages
+        )
         console.print(f"Final token count after processing: {final_token_count}")
         return result_messages
-    return messages
+    return messages

code_puppy/model_factory.py

@@ -42,15 +42,17 @@ def build_httpx_proxy(proxy):
     """Build an httpx.Proxy object from a proxy string in format ip:port:username:password"""
     proxy_tokens = proxy.split(":")
     if len(proxy_tokens) != 4:
-        raise ValueError(f"Invalid proxy format: {proxy}. Expected format: ip:port:username:password")
-    
+        raise ValueError(
+            f"Invalid proxy format: {proxy}. Expected format: ip:port:username:password"
+        )
+
     ip, port, username, password = proxy_tokens
     proxy_url = f"http://{ip}:{port}"
     proxy_auth = (username, password)
-    
+
     # Log the proxy being used
     console.log(f"Using proxy: {proxy_url} with username: {username}")
-    
+
     return httpx.Proxy(url=proxy_url, auth=proxy_auth)
 
 
@@ -58,18 +60,22 @@ def get_random_proxy_from_file(file_path):
     """Reads proxy file and returns a random proxy formatted for httpx.AsyncClient"""
     if not os.path.exists(file_path):
         raise ValueError(f"Proxy file '{file_path}' not found.")
-    
+
     with open(file_path, "r") as f:
         proxies = [line.strip() for line in f.readlines() if line.strip()]
-    
+
     if not proxies:
-        raise ValueError(f"Proxy file '{file_path}' is empty or contains only whitespace.")
-    
+        raise ValueError(
+            f"Proxy file '{file_path}' is empty or contains only whitespace."
+        )
+
     selected_proxy = random.choice(proxies)
     try:
         return build_httpx_proxy(selected_proxy)
-    except ValueError as e:
-        console.log(f"Warning: Malformed proxy '{selected_proxy}' found in file '{file_path}', ignoring and continuing without proxy.")
+    except ValueError:
+        console.log(
+            f"Warning: Malformed proxy '{selected_proxy}' found in file '{file_path}', ignoring and continuing without proxy."
+        )
         return None
 
 
@@ -147,13 +153,13 @@ class ModelFactory:
 
         elif model_type == "custom_anthropic":
             url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-            
+
             # Check for proxy configuration
             proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
             proxy = None
             if proxy_file_path:
                 proxy = get_random_proxy_from_file(proxy_file_path)
-            
+
             # Only pass proxy to client if it's valid
             client_args = {"headers": headers, "verify": ca_certs_path}
             if proxy is not None:
@@ -223,13 +229,13 @@ class ModelFactory:
 
         elif model_type == "custom_openai":
             url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-            
+
             # Check for proxy configuration
             proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
             proxy = None
             if proxy_file_path:
                 proxy = get_random_proxy_from_file(proxy_file_path)
-            
+
             # Only pass proxy to client if it's valid
             client_args = {"headers": headers, "verify": ca_certs_path}
             if proxy is not None:

code_puppy/state_management.py

@@ -1,24 +1,28 @@
 from typing import Any, List
 
-from code_puppy.tools.common import console
 from code_puppy.message_history_processor import message_history_processor
 
 _message_history: List[Any] = []
 
+
 def get_message_history() -> List[Any]:
     return _message_history
 
+
 def set_message_history(history: List[Any]) -> None:
     global _message_history
     _message_history = history
 
+
 def clear_message_history() -> None:
     global _message_history
     _message_history = []
 
+
 def append_to_message_history(message: Any) -> None:
     _message_history.append(message)
 
+
 def extend_message_history(history: List[Any]) -> None:
     _message_history.extend(history)
 
@@ -37,18 +41,18 @@ def hash_message(message):
 
 def message_history_accumulator(messages: List[Any]):
     global _message_history
-    
+
     message_history_hashes = set([hash_message(m) for m in _message_history])
     for msg in messages:
         if hash_message(msg) not in message_history_hashes:
             _message_history.append(msg)
-    
+
     # Apply message history trimming using the main processor
     # This ensures we maintain global state while still managing context limits
     trimmed_messages = message_history_processor(_message_history)
-    
+
     # Update our global state with the trimmed version
     # This preserves the state but keeps us within token limits
     _message_history = trimmed_messages
-    
+
     return _message_history

code_puppy/summarization_agent.py

@@ -1,9 +1,7 @@
 import os
 from pathlib import Path
 
-import pydantic
 from pydantic_ai import Agent
-from pydantic_ai.mcp import MCPServerSSE
 
 from code_puppy.model_factory import ModelFactory
 from code_puppy.tools.common import console
@@ -33,7 +31,7 @@ def reload_summarization_agent():
         else Path(__file__).parent / "models.json"
     )
     model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
-    
+
     # 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 
@@ -51,7 +49,7 @@ When summarizing:
         model=model,
         instructions=instructions,
         output_type=str,
-        retries=1  # Fewer retries for summarization
+        retries=1,  # Fewer retries for summarization
     )
     _summarization_agent = agent
     _LAST_MODEL_NAME = model_name

code_puppy/tools/__init__.py

@@ -1,4 +1,7 @@
-from code_puppy.tools.command_runner import register_command_runner_tools
+from code_puppy.tools.command_runner import (
+    register_command_runner_tools,
+    kill_all_running_shell_processes,
+)
 from code_puppy.tools.file_modifications import register_file_modifications_tools
 from code_puppy.tools.file_operations import register_file_operations_tools
 

code_puppy/tools/command_runner.py

@@ -1,14 +1,117 @@
+import os
+import signal
 import subprocess
+import threading
 import time
-from typing import Any, Dict
+import traceback
+import sys
+from typing import Set
 
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 from rich.markdown import Markdown
-from rich.syntax import Syntax
+from rich.text import Text
 
 from code_puppy.tools.common import console
 
+_AWAITING_USER_INPUT = False
+
+_CONFIRMATION_LOCK = threading.Lock()
+
+# Track running shell processes so we can kill them on Ctrl-C from the UI
+_RUNNING_PROCESSES: Set[subprocess.Popen] = set()
+_RUNNING_PROCESSES_LOCK = threading.Lock()
+_USER_KILLED_PROCESSES = set()
+
+def _register_process(proc: subprocess.Popen) -> None:
+    with _RUNNING_PROCESSES_LOCK:
+        _RUNNING_PROCESSES.add(proc)
+
+
+def _unregister_process(proc: subprocess.Popen) -> None:
+    with _RUNNING_PROCESSES_LOCK:
+        _RUNNING_PROCESSES.discard(proc)
+
+
+def _kill_process_group(proc: subprocess.Popen) -> None:
+    """Attempt to aggressively terminate a process and its group.
+
+    Cross-platform best-effort. On POSIX, uses process groups. On Windows, tries CTRL_BREAK_EVENT, then terminate().
+    """
+    try:
+        if sys.platform.startswith("win"):
+            try:
+                # Try a soft break first if the group exists
+                proc.send_signal(signal.CTRL_BREAK_EVENT)  # type: ignore[attr-defined]
+                time.sleep(0.8)
+            except Exception:
+                pass
+            if proc.poll() is None:
+                try:
+                    proc.terminate()
+                    time.sleep(0.8)
+                except Exception:
+                    pass
+            if proc.poll() is None:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            return
+
+        # POSIX
+        pid = proc.pid
+        try:
+            pgid = os.getpgid(pid)
+            os.killpg(pgid, signal.SIGTERM)
+            time.sleep(1.0)
+            if proc.poll() is None:
+                os.killpg(pgid, signal.SIGINT)
+                time.sleep(0.6)
+            if proc.poll() is None:
+                os.killpg(pgid, signal.SIGKILL)
+                time.sleep(0.5)
+        except (OSError, ProcessLookupError):
+            # Fall back to direct kill of the process
+            try:
+                if proc.poll() is None:
+                    proc.kill()
+            except (OSError, ProcessLookupError):
+                pass
+
+        if proc.poll() is None:
+            # Last ditch attempt; may be unkillable zombie
+            try:
+                for _ in range(3):
+                    os.kill(proc.pid, signal.SIGKILL)
+                    time.sleep(0.2)
+                    if proc.poll() is not None:
+                        break
+            except Exception:
+                pass
+    except Exception as e:
+        console.print(f"Kill process error: {e}")
+
+
+def kill_all_running_shell_processes() -> int:
+    """Kill all currently tracked running shell processes.
+
+    Returns the number of processes signaled.
+    """
+    procs: list[subprocess.Popen]
+    with _RUNNING_PROCESSES_LOCK:
+        procs = list(_RUNNING_PROCESSES)
+    count = 0
+    for p in procs:
+        try:
+            if p.poll() is None:
+                _kill_process_group(p)
+                count += 1
+                _USER_KILLED_PROCESSES.add(p.pid)
+        finally:
+            _unregister_process(p)
+    return count
+
 
 class ShellCommandOutput(BaseModel):
     success: bool
@@ -19,35 +122,250 @@ class ShellCommandOutput(BaseModel):
     exit_code: int | None
     execution_time: float | None
     timeout: bool | None = False
+    user_interrupted: bool | None = False
+
+
+def run_shell_command_streaming(
+    process: subprocess.Popen, timeout: int = 60, command: str = ""
+):
+    start_time = time.time()
+    last_output_time = [start_time]
+
+    ABSOLUTE_TIMEOUT_SECONDS = 270
+
+    stdout_lines = []
+    stderr_lines = []
+
+    stdout_thread = None
+    stderr_thread = None
+
+    def read_stdout():
+        try:
+            for line in iter(process.stdout.readline, ""):
+                if line:
+                    line = line.rstrip("\n\r")
+                    stdout_lines.append(line)
+                    console.print(line)
+                    last_output_time[0] = time.time()
+        except Exception:
+            pass
+
+    def read_stderr():
+        try:
+            for line in iter(process.stderr.readline, ""):
+                if line:
+                    line = line.rstrip("\n\r")
+                    stderr_lines.append(line)
+                    console.print(line)
+                    last_output_time[0] = time.time()
+        except Exception:
+            pass
+
+    def cleanup_process_and_threads(timeout_type: str = "unknown"):
+        nonlocal stdout_thread, stderr_thread
+
+        def nuclear_kill(proc):
+            _kill_process_group(proc)
+
+        try:
+            if process.poll() is None:
+                nuclear_kill(process)
+
+            try:
+                if process.stdout and not process.stdout.closed:
+                    process.stdout.close()
+                if process.stderr and not process.stderr.closed:
+                    process.stderr.close()
+                if process.stdin and not process.stdin.closed:
+                    process.stdin.close()
+            except (OSError, ValueError):
+                pass
+
+            # Unregister once we're done cleaning up
+            _unregister_process(process)
+
+            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"
+                    )
+
+            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"
+                    )
+
+        except Exception as e:
+            console.log(f"Error during process cleanup {e}")
+
+        execution_time = time.time() - start_time
+        return ShellCommandOutput(
+            **{
+                "success": False,
+                "command": command,
+                "stdout": "\n".join(stdout_lines[-1000:]),
+                "stderr": "\n".join(stderr_lines[-1000:]),
+                "exit_code": -9,
+                "execution_time": execution_time,
+                "timeout": True,
+                "error": f"Command timed out after {timeout} seconds",
+            }
+        )
+
+    try:
+        stdout_thread = threading.Thread(target=read_stdout, daemon=True)
+        stderr_thread = threading.Thread(target=read_stderr, daemon=True)
+
+        stdout_thread.start()
+        stderr_thread.start()
+
+        while process.poll() is None:
+            current_time = time.time()
+
+            if current_time - start_time > ABSOLUTE_TIMEOUT_SECONDS:
+                error_msg = Text()
+                error_msg.append(
+                    "Process killed: inactivity timeout reached", style="bold red"
+                )
+                console.print(error_msg)
+                return cleanup_process_and_threads("absolute")
+
+            if current_time - last_output_time[0] > timeout:
+                error_msg = Text()
+                error_msg.append(
+                    "Process killed: inactivity timeout reached", style="bold red"
+                )
+                console.print(error_msg)
+                return cleanup_process_and_threads("inactivity")
+
+            time.sleep(0.1)
+
+        if stdout_thread:
+            stdout_thread.join(timeout=5)
+        if stderr_thread:
+            stderr_thread.join(timeout=5)
+
+        exit_code = process.returncode
+        execution_time = time.time() - start_time
+
+        try:
+            if process.stdout and not process.stdout.closed:
+                process.stdout.close()
+            if process.stderr and not process.stderr.closed:
+                process.stderr.close()
+            if process.stdin and not process.stdin.closed:
+                process.stdin.close()
+        except (OSError, ValueError):
+            pass
+
+        _unregister_process(process)
+
+        if exit_code != 0:
+            console.print(
+                f"Command failed with exit code {exit_code}", style="bold red"
+            )
+            console.print(f"Took {execution_time:.2f}s", style="dim")
+            time.sleep(1)
+            return ShellCommandOutput(
+                success=False,
+                command=command,
+                error="""The process didn't exit cleanly! If the user_interrupted flag is true,
+                please stop all execution and ask the user for clarification!""",
+                stdout="\n".join(stdout_lines[-1000:]),
+                stderr="\n".join(stderr_lines[-1000:]),
+                exit_code=exit_code,
+                execution_time=execution_time,
+                timeout=False,
+                user_interrupted=process.pid in _USER_KILLED_PROCESSES
+            )
+        return ShellCommandOutput(
+            success=exit_code == 0,
+            command=command,
+            stdout="\n".join(stdout_lines[-1000:]),
+            stderr="\n".join(stderr_lines[-1000:]),
+            exit_code=exit_code,
+            execution_time=execution_time,
+            timeout=False,
+        )
+
+    except Exception as e:
+        return ShellCommandOutput(
+            success=False,
+            command=command,
+            error=f"Error durign streaming execution {str(e)}",
+            stdout="\n".join(stdout_lines[-1000:]),
+            stderr="\n".join(stderr_lines[-1000:]),
+            exit_code=-1,
+            timeout=False,
+        )
+
 
 def run_shell_command(
     context: RunContext, command: str, cwd: str = None, timeout: int = 60
 ) -> ShellCommandOutput:
+    command_displayed = False
     if not command or not command.strip():
         console.print("[bold red]Error:[/bold red] Command cannot be empty")
-        return ShellCommandOutput(**{"success": False, "error": "Command cannot be empty"})
+        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]"
     )
-    if cwd:
-        console.print(f"[dim]Working directory: {cwd}[/dim]")
-    console.print("[dim]" + "-" * 60 + "[/dim]")
     from code_puppy.config import get_yolo_mode
 
     yolo_mode = get_yolo_mode()
-    if not yolo_mode:
-        user_input = input("Are you sure you want to run this command? (yes/no): ")
-        if user_input.strip().lower() not in {"yes", "y"}:
-            console.print(
-                "[bold yellow]Command execution canceled by user.[/bold yellow]"
+
+    confirmation_lock_acquired = False
+
+    # Only ask for confirmation if we're in an interactive TTY and not in yolo mode.
+    if not yolo_mode and sys.stdin.isatty():
+        confirmation_lock_acquired = _CONFIRMATION_LOCK.acquire(blocking=False)
+        if not confirmation_lock_acquired:
+            return ShellCommandOutput(
+                success=False,
+                command=command,
+                error="Another command is currently awaiting confirmation",
             )
-            return ShellCommandOutput(**{
-                "success": False,
-                "command": command,
-                "error": "User canceled command execution",
-            })
-    try:
+
+        command_displayed = True
+
+        if cwd:
+            console.print(f"[dim] Working directory: {cwd} [/dim]")
+        time.sleep(0.2)
+        sys.stdout.write("Are you sure you want to run this command? (y(es)/n(o))\n")
+        sys.stdout.flush()
+
+        try:
+            user_input = input()
+            confirmed = user_input.strip().lower() in {"yes", "y"}
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n Cancelled by user")
+            confirmed = False
+        finally:
+            if confirmation_lock_acquired:
+                _CONFIRMATION_LOCK.release()
+
+        if not confirmed:
+            result = ShellCommandOutput(
+                success=False, command=command, error="User rejected the command!"
+            )
+            return result
+    else:
         start_time = time.time()
+    try:
+        creationflags = 0
+        preexec_fn = None
+        if sys.platform.startswith("win"):
+            try:
+                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore[attr-defined]
+            except Exception:
+                creationflags = 0
+        else:
+            preexec_fn = os.setsid if hasattr(os, "setsid") else None
         process = subprocess.Popen(
             command,
             shell=True,
@@ -55,112 +373,33 @@ def run_shell_command(
             stderr=subprocess.PIPE,
             text=True,
             cwd=cwd,
+            bufsize=1,
+            universal_newlines=True,
+            preexec_fn=preexec_fn,
+            creationflags=creationflags,
         )
+        _register_process(process)
         try:
-            stdout, stderr = process.communicate(timeout=timeout)
-            exit_code = process.returncode
-            execution_time = time.time() - start_time
-            if stdout.strip():
-                console.print("[bold white]STDOUT:[/bold white]")
-                console.print(
-                    Syntax(
-                        stdout.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            else:
-                console.print("[yellow]No STDOUT output[/yellow]")
-            if stderr.strip():
-                console.print("[bold yellow]STDERR:[/bold yellow]")
-                console.print(
-                    Syntax(
-                        stderr.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            if exit_code == 0:
-                console.print(
-                    f"[bold green]✓ Command completed successfully[/bold green] [dim](took {execution_time:.2f}s)[/dim]"
-                )
-            else:
-                console.print(
-                    f"[bold red]✗ Command failed with exit code {exit_code}[/bold red] [dim](took {execution_time:.2f}s)[/dim]"
-                )
-            if not stdout.strip() and not stderr.strip():
-                console.print(
-                    "[bold yellow]This command produced no output at all![/bold yellow]"
-                )
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return ShellCommandOutput(**{
-                "success": exit_code == 0,
-                "command": command,
-                "stdout": stdout,
-                "stderr": stderr,
-                "exit_code": exit_code,
-                "execution_time": execution_time,
-                "timeout": False,
-            })
-        except subprocess.TimeoutExpired:
-            process.kill()
-            stdout, stderr = process.communicate()
-            execution_time = time.time() - start_time
-            if stdout.strip():
-                console.print(
-                    "[bold white]STDOUT (incomplete due to timeout):[/bold white]"
-                )
-                console.print(
-                    Syntax(
-                        stdout.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            if stderr.strip():
-                console.print("[bold yellow]STDERR:[/bold yellow]")
-                console.print(
-                    Syntax(
-                        stderr.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            console.print(
-                f"[bold red]⏱ Command timed out after {timeout} seconds[/bold red] [dim](ran for {execution_time:.2f}s)[/dim]"
-            )
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return ShellCommandOutput(**{
-                "success": False,
-                "command": command,
-                "stdout": stdout[-1000:],
-                "stderr": stderr[-1000:],
-                "exit_code": None,
-                "execution_time": execution_time,
-                "timeout": True,
-                "error": f"Command timed out after {timeout} seconds",
-            })
+            return run_shell_command_streaming(process, timeout=timeout, command=command)
+        finally:
+            # Ensure unregistration in case streaming returned early or raised
+            _unregister_process(process)
     except Exception as e:
-        console.print_exception(show_locals=True)
-        console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        # Ensure stdout and stderr are always defined
+        console.print(traceback.format_exc())
         if "stdout" not in locals():
             stdout = None
         if "stderr" not in locals():
             stderr = None
-        return ShellCommandOutput(**{
-            "success": False,
-            "command": command,
-            "error": f"Error executing command: {str(e)}",
-            "stdout": stdout[-1000:] if stdout else None,
-            "stderr": stderr[-1000:] if stderr else None,
-            "exit_code": -1,
-            "timeout": False,
-        })
+        return ShellCommandOutput(
+            success=False,
+            command=command,
+            error=f"Error executing command {str(e)}",
+            stdout="\n".join(stdout[-1000:]) if stdout else None,
+            stderr="\n".join(stderr[-1000:]) if stderr else None,
+            exit_code=-1,
+            timeout=False,
+        )
+
 
 class ReasoningOutput(BaseModel):
     success: bool = True

code_puppy/tools/file_modifications.py

@@ -378,7 +378,9 @@ def register_file_modifications_tools(agent):
     """Attach file-editing tools to *agent* with mandatory diff rendering."""
 
     @agent.tool(retries=5)
-    def edit_file(context: RunContext, path: str = "", diff: str = "") -> EditFileOutput:
+    def edit_file(
+        context: RunContext, path: str = "", diff: str = ""
+    ) -> EditFileOutput:
         return EditFileOutput(**_edit_file(context, path, diff))
 
     @agent.tool(retries=5)

code_puppy/tools/file_operations.py

@@ -1,9 +1,9 @@
 # file_operations.py
 
 import os
-from typing import Any, Dict, List
+from typing import List
 
-from pydantic import BaseModel, StrictStr, StrictInt
+from pydantic import BaseModel
 from pydantic_ai import RunContext
 
 from code_puppy.tools.common import console
@@ -41,11 +41,15 @@ def _list_files(
             f"[bold red]Error:[/bold red] Directory '{directory}' does not exist"
         )
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
+        return ListFileOutput(
+            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
+        )
     if not os.path.isdir(directory):
         console.print(f"[bold red]Error:[/bold red] '{directory}' is not a directory")
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
+        return ListFileOutput(
+            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
+        )
     folder_structure = {}
     file_list = []
     for root, dirs, files in os.walk(directory):
@@ -57,13 +61,15 @@ def _list_files(
         if rel_path:
             dir_path = os.path.join(directory, rel_path)
             results.append(
-                ListedFile(**{
-                    "path": rel_path,
-                    "type": "directory",
-                    "size": 0,
-                    "full_path": dir_path,
-                    "depth": depth,
-                })
+                ListedFile(
+                    **{
+                        "path": rel_path,
+                        "type": "directory",
+                        "size": 0,
+                        "full_path": dir_path,
+                        "depth": depth,
+                    }
+                )
             )
             folder_structure[rel_path] = {
                 "path": rel_path,
@@ -131,9 +137,7 @@ def _list_files(
             return "\U0001f4c4"
 
     if results:
-        files = sorted(
-            [f for f in results if f.type == "file"], key=lambda x: x.path
-        )
+        files = sorted([f for f in results if f.type == "file"], key=lambda x: x.path)
         console.print(
             f"\U0001f4c1 [bold blue]{os.path.basename(directory) or directory}[/bold blue]"
         )
@@ -177,6 +181,7 @@ def _list_files(
 class ReadFileOutput(BaseModel):
     content: str | None
 
+
 def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
     file_path = os.path.abspath(file_path)
     console.print(
@@ -191,7 +196,7 @@ def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
         return ReadFileOutput(content=content)
-    except Exception as exc:
+    except Exception:
         return ReadFileOutput(content="FILE NOT FOUND")
 
 
@@ -200,12 +205,12 @@ class MatchInfo(BaseModel):
     line_number: int | None
     line_content: str | None
 
+
 class GrepOutput(BaseModel):
     matches: List[MatchInfo]
 
-def _grep(
-    context: RunContext, search_string: str, directory: str = "."
-) -> GrepOutput:
+
+def _grep(context: RunContext, search_string: str, directory: str = ".") -> GrepOutput:
     matches: List[MatchInfo] = []
     directory = os.path.abspath(directory)
     console.print(
@@ -229,11 +234,13 @@ def _grep(
                 with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
                     for line_number, line_content in enumerate(fh, 1):
                         if search_string in line_content:
-                            match_info = MatchInfo(**{
-                                "file_path": file_path,
-                                "line_number": line_number,
-                                "line_content": line_content.strip(),
-                            })
+                            match_info = MatchInfo(
+                                **{
+                                    "file_path": file_path,
+                                    "line_number": line_number,
+                                    "line_content": line_content.strip(),
+                                }
+                            )
                             matches.append(match_info)
                             # console.print(
                             #     f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}"

{code_puppy-0.0.84.dist-info → code_puppy-0.0.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.84
+Version: 0.0.86
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

code_puppy-0.0.86.dist-info/RECORD

@@ -0,0 +1,30 @@
+code_puppy/__init__.py,sha256=CWH46ZAmJRmHAbOiAhG07OrWYEcEt4yvDTkZU341Wag,169
+code_puppy/agent.py,sha256=7_1FpGPnw8U632OXP0hLmFIozfVvllF491q8gCpaa8c,3284
+code_puppy/agent_prompts.py,sha256=wTah_TvakCMhkb_KwuWCsw4_UR1QsjTZeOT1I8at_nc,6593
+code_puppy/config.py,sha256=r5nw5ChOP8xd_K5yo8U5OtO2gy2bFhARiyNtDp1JrwQ,5013
+code_puppy/main.py,sha256=qtBokZZfPQRGF91KNl_n_ywutONwF2f-zTwmt_ROsEU,11080
+code_puppy/message_history_processor.py,sha256=jpoxGE6emBX3MAkeeezPZ4QEOzONRhbN6mZe_efG9vI,9248
+code_puppy/model_factory.py,sha256=HXuFHNkVjkCcorAd3ScFmSvBILO932UTq6OmNAqisT8,10898
+code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
+code_puppy/state_management.py,sha256=JkTkmq6f9rl_RHPDoBqJvbAzgaMsIkJf-k38ragItIo,1692
+code_puppy/summarization_agent.py,sha256=jHUQe6iYJsMT0ywEwO7CrhUIKEamO5imhAsDwvNuvow,2684
+code_puppy/version_checker.py,sha256=aRGulzuY4C4CdFvU1rITduyL-1xTFsn4GiD1uSfOl_Y,396
+code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
+code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
+code_puppy/command_line/meta_command_handler.py,sha256=L7qP2g0Faz0V7bMH4YK3s03OWWuQFtK7Sh-Kt2zmmEQ,6182
+code_puppy/command_line/model_picker_completion.py,sha256=NkyZZG7IhcVWSJ3ADytwCA5f8DpNeVs759Qtqs4fQtY,3733
+code_puppy/command_line/motd.py,sha256=FoZsiVpXGF8WpAmEJX4O895W7MDuzCtNWvFAOShxUXY,1572
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=_gP0FIOgHDNHTTWLNL0XNzr6sO0ISe7Mec1uQNo9kcM,8337
+code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
+code_puppy/tools/__init__.py,sha256=WTHYIfRk2KMmk6o45TELpbB3GIiAm8s7GmfJ7Zy_tww,503
+code_puppy/tools/command_runner.py,sha256=9UWCSPpuEndaPx8Ecc8TRsn3rMHNd2AqerirvYPGRIw,14358
+code_puppy/tools/common.py,sha256=M53zhiXZAmPdvi1Y_bzCxgvEmifOvRRJvYPARYRZqHw,2253
+code_puppy/tools/file_modifications.py,sha256=BzQrGEacS2NZr2ru9N30x_Qd70JDudBKOAPO1XjBohg,13861
+code_puppy/tools/file_operations.py,sha256=ypk4yL90LDSVRr0xyWafttzt956J_nXhhenCXhOOit8,11326
+code_puppy/tools/ts_code_map.py,sha256=o-u8p5vsYwitfDtVEoPS-7MwWn2xHzwtIQLo1_WMhQs,17647
+code_puppy-0.0.86.data/data/code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
+code_puppy-0.0.86.dist-info/METADATA,sha256=MhZ1w27mLtvfIsjEztFH9BuAGabfD_uCS4ZQQnDVSwg,6351
+code_puppy-0.0.86.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.86.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.86.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.86.dist-info/RECORD,,

code_puppy-0.0.84.dist-info/RECORD

@@ -1,30 +0,0 @@
-code_puppy/__init__.py,sha256=oDE4GhaqOHsYi9XCGp6A2-PqhDqxJiYP_XmxmoKWoPU,168
-code_puppy/agent.py,sha256=7On9mo4RWRaoINJr4Rv4c7Ot751FdQfSnTg0grrxzp8,3283
-code_puppy/agent_prompts.py,sha256=13YIpTZa3R3lg60-fdkll7t7hgSBtQL0M53wcE1gzyQ,6834
-code_puppy/config.py,sha256=r5nw5ChOP8xd_K5yo8U5OtO2gy2bFhARiyNtDp1JrwQ,5013
-code_puppy/main.py,sha256=WL1EGw86u_yQJDrkvnZbabldRKcYgFMuWQPQDz8zUgY,10428
-code_puppy/message_history_processor.py,sha256=QOAQqxOJ2MSe6sTnZ6F4PMBqrtmV8RBQ0LmwQKh-o1A,6158
-code_puppy/model_factory.py,sha256=3j7AcJfZAHbx_plL9oOxjGJO0MMTRaQFThCErg8VpH8,10909
-code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
-code_puppy/state_management.py,sha256=1QycApDBbXjayxXsYRecJib8TQ-MYMTeYvN5P_1Ipdg,1747
-code_puppy/summarization_agent.py,sha256=N1UZg_R3wJFb7ZdVexDqx7L_8yxQ5m5nMOwGsLNfvKM,2744
-code_puppy/version_checker.py,sha256=aRGulzuY4C4CdFvU1rITduyL-1xTFsn4GiD1uSfOl_Y,396
-code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
-code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
-code_puppy/command_line/meta_command_handler.py,sha256=L7qP2g0Faz0V7bMH4YK3s03OWWuQFtK7Sh-Kt2zmmEQ,6182
-code_puppy/command_line/model_picker_completion.py,sha256=NkyZZG7IhcVWSJ3ADytwCA5f8DpNeVs759Qtqs4fQtY,3733
-code_puppy/command_line/motd.py,sha256=7ICNgfL4EgSrmCAHIsCK72R19obSQXkK8l7XGJBkvrQ,1571
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=_gP0FIOgHDNHTTWLNL0XNzr6sO0ISe7Mec1uQNo9kcM,8337
-code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
-code_puppy/tools/__init__.py,sha256=ozIGpLM7pKSjH4UeojkTodhfVYZeNzMsLtK_oyw41HA,456
-code_puppy/tools/command_runner.py,sha256=NFCL35x44McMzSUNHQyg5q4Zx7wkvqD-nH4_YAU8N2s,7229
-code_puppy/tools/common.py,sha256=M53zhiXZAmPdvi1Y_bzCxgvEmifOvRRJvYPARYRZqHw,2253
-code_puppy/tools/file_modifications.py,sha256=nGI8gRD6Vtkg8EzBkErsv3khE3VI-_M1z_PdQLvjfLo,13847
-code_puppy/tools/file_operations.py,sha256=eftkN-MxsRGQc8c1iIoNmN5r-Ppld5YJRT7a89kxpkM,11207
-code_puppy/tools/ts_code_map.py,sha256=o-u8p5vsYwitfDtVEoPS-7MwWn2xHzwtIQLo1_WMhQs,17647
-code_puppy-0.0.84.data/data/code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
-code_puppy-0.0.84.dist-info/METADATA,sha256=NWnTj01yQNciyZLXZDYgWbU8St84wCea4wE4fLn27lE,6351
-code_puppy-0.0.84.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.84.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.84.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.84.dist-info/RECORD,,