regcode 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

regcode/__init__.py

@@ -2,4 +2,4 @@ from regcode.config import Config
 from regcode.main import Agent, AgentStatus, ToolCall
 
 __all__ = ["Agent", "Config", "AgentStatus", "ToolCall"]
-__version__ = "0.6.2"
+__version__ = "0.6.3"

regcode/config.py

@@ -125,6 +125,7 @@ class Config(BaseModel):
     tool_budget: int = 20
     permissions: list[AgentPermission] = [AgentPermission.READ, AgentPermission.EXECUTE]
     toolset_config: ToolSetConfig = ToolSetConfig()
+    debug_mode: bool = False
 
     @classmethod
     def load(cls, path: str | None = None) -> "Config":

regcode/main.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import json
+import logging
+import sys
 import warnings
 from datetime import datetime, timezone
 from enum import Enum
@@ -24,6 +26,9 @@ from regcode.tracing import setup_mlflow_tracing
 
 setup_mlflow_tracing()
 
+logger = logging.getLogger(__name__)
+
+
 class _SafeEncoder(json.JSONEncoder):
     def default(self, o):
         if hasattr(o, "__repr__"):
@@ -83,6 +88,10 @@ class Agent:
         self._tool_budget_exhausted = False
         self._cumulative_cost: float = 0.0
         self._total_tokens: int = 0
+        self._llm_call_log_file: str | None = None
+
+        if self.config.debug_mode:
+            self.enable_llm_call_logging("llm_calls.json")
 
         # Context window manager
         self.context_manager = ConversationManager()
@@ -129,7 +138,9 @@ class Agent:
     def _format_tool_descriptions(self) -> str:
         """Format tool definitions for inclusion in system prompts.
 
-        Returns a formatted string with each tool's name and description.
+        Returns a formatted string with each tool's name and description,
+        plus explicit restrictions to prevent the model from generating
+        tool calls that are guaranteed to fail.
         """
         tool_defs = self.registry.list_tools()
         if not tool_defs:
@@ -145,6 +156,37 @@ class Agent:
             "You have access to the following tools.\n"
             "Use them when appropriate to gather information\n"
             "or perform tasks:\n"
+            "\n"
+            "### TOOL RESTRICTIONS (MUST FOLLOW)\n"
+            "The sandboxed tools have strict limitations. If a tool\n"
+            "execution returns an error, do NOT repeat the same call.\n"
+            "Instead, try a different approach or provide a text answer.\n"
+            "\n"
+            "1. **python_code / run_script**: Run in a sandboxed Python\n"
+            "    environment. Available stdlib modules are\n"
+            "    limited — NO subprocess, NO urllib, NO socket, NO\n"
+            "    network access, NO external packages. Use only\n"
+            "    built-in modules like os, sys, json, re, pathlib.\n"
+            "    If it fails once, try a different approach — do not\n"
+            "    retry the same failing call.\n"
+            "\n"
+            "2. **shell_command**: Runs in a restricted shell. The\n"
+            "    following are FORBIDDEN and will be rejected:\n"
+            "    - Pipes, redirects, or I/O redirection (no |, >,\n"
+            "      >>, 2>&1, |&, etc.)\n"
+            "    - The `uv` command is not available\n"
+            "    - Only whitelisted commands are allowed (ls, cat,\n"
+            "      echo, grep, head, tail, find, wc, sort, etc.)\n"
+            "    - If a command is rejected, try a different\n"
+            "      approach or use another tool.\n"
+            "\n"
+            "3. **General rule**: If a tool call fails, do NOT\n"
+            "    repeat the exact same call. The model should adapt\n"
+            "    to the error and try an alternative. After 3\n"
+            "    consecutive turns where ALL tool calls failed, the\n"
+            "    agent loop will force-terminate and fall back to\n"
+            "    producing a text response. So be smart about\n"
+            "    switching strategies early.\n"
         )
         return header + "\n".join(lines)
 
@@ -177,6 +219,212 @@ class Agent:
         base_kwargs["messages"] = messages
         return base_kwargs
 
+    def _log_llm_call(
+        self,
+        messages: list[dict[str, Any]],
+        response,
+        turn_index: int = 0,
+    ) -> None:
+        """Log every LLM invocation to a JSON file.
+
+        Writes one JSON object per call so you can inspect the exact
+        message thread and response for each LLM call. Helps diagnose
+        issues where the agent says one thing and then stops.
+
+        Args:
+            messages: The messages sent to litellm.completion().
+            response: The litellm completion response object.
+            turn_index: Which LLM call in the current chat turn (1-based).
+        """
+        if not self._llm_call_log_file:
+            return
+
+        log_path = Path(self._llm_call_log_file)
+        if not log_path.is_absolute():
+            log_path = Path.cwd() / log_path
+
+        try:
+            tool_calls = []
+            if (
+                hasattr(response.choices[0].message, "tool_calls")
+                and response.choices[0].message.tool_calls
+            ):
+                for tc in response.choices[0].message.tool_calls:
+                    if hasattr(tc, "function"):
+                        tool_calls.append(
+                            {
+                                "id": tc.id,
+                                "function": {
+                                    "name": tc.function.name,
+                                    "arguments": tc.function.arguments,
+                                },
+                            }
+                        )
+
+            log_entry = {
+                "turn_index": turn_index,
+                "messages": messages,
+                "response": {
+                    "content": (
+                        response.choices[0].message.content
+                        if hasattr(response.choices[0].message, "content")
+                        and response.choices[0].message.content
+                        else ""
+                    ),
+                    "tool_calls": tool_calls,
+                    "finish_reason": (
+                        getattr(response.choices[0], "finish_reason", None)
+                    ),
+                    "usage": (
+                        {
+                            "prompt_tokens": getattr(
+                                response.usage, "prompt_tokens", None
+                            ),
+                            "completion_tokens": getattr(
+                                response.usage, "completion_tokens", None
+                            ),
+                            "total_tokens": getattr(
+                                response.usage, "total_tokens", None
+                            ),
+                        }
+                        if hasattr(response, "usage") and response.usage
+                        else None
+                    ),
+                },
+            }
+
+            with open(log_path, "a") as f:
+                f.write(json.dumps(log_entry, cls=_SafeEncoder, indent=2) + "\n")
+
+        except Exception as exc:
+            print(
+                f"WARNING: Failed to write LLM call log to {log_path}: {exc}",
+                file=sys.stderr,
+            )
+
+    def enable_llm_call_logging(self, log_file: str = "llm_calls.json") -> None:
+        """Enable per-call LLM logging to the given file.
+
+        Call this to start logging every LLM completion call with the
+        full message thread and response.
+
+        Args:
+            log_file: Path to the JSON log file.
+        """
+        self._llm_call_log_file = log_file
+        logger.info("LLM call logging enabled: %s", self._llm_call_log_file)
+
+    def _maybe_compact(
+        self, messages: list[dict[str, Any]]
+    ) -> list[dict[str, Any]] | None:
+        """Auto-compact context if tool results caused token explosion.
+
+        Checks the current token count and compacts if we're approaching
+        the context window limit. This prevents ContextWindowExceeded errors
+        after large tool outputs (e.g., reading large files).
+
+        Args:
+            messages: Current message list to check.
+
+        Returns:
+            The compacted messages list if compaction occurred, or None if no
+            compaction was needed.
+        """
+        if not self.config.agent.enable_compaction:
+            return None
+
+        try:
+            # Estimate current token count
+            token_count = litellm.token_counter(
+                model=self.config.provider.model,
+                messages=messages,
+            )
+
+            # Check if we need compaction
+            if token_count > 0:
+                available_space = max(
+                    1, self._context_window - self.config.provider.max_tokens
+                )
+                threshold = available_space * self.config.agent.compaction_threshold
+                if token_count > threshold:
+                    logger.info(
+                        "Auto-compaction triggered: %d tokens (threshold: %d)",
+                        token_count,
+                        int(available_space * self.config.agent.compaction_threshold),
+                    )
+                    # Notify TUI if active
+                    if self._status_callback is not None:
+                        self._status_callback(AgentStatus.COMPACTION_START, None)
+                    # Compact context manager
+                    self.context_manager.compact()
+                    # Also compact the local messages list
+                    compacted_messages = self._compact_messages(messages)
+                    logger.info(
+                        "Compaction complete, new token count: %d",
+                        litellm.token_counter(
+                            model=self.config.provider.model,
+                            messages=compacted_messages,
+                        ),
+                    )
+                    return compacted_messages
+        except Exception:
+            # Never crash on compaction failure
+            pass
+
+        return None
+
+    def _compact_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Compact a messages list similar to ConversationManager.compact().
+
+        Keeps the first message (system prompt), the most recent user query,
+        and the last N messages. This ensures a valid user query always
+        survives compaction so the model never receives "No user query found".
+
+        Args:
+            messages: The messages to compact.
+
+        Returns:
+            The compacted messages list.
+        """
+        if len(messages) <= 2:
+            return messages
+
+        # Keep the first message (system prompt)
+        first_msg = messages[0]
+
+        # Keep only the last N messages — cap aggressively so the compacted
+        # list actually fits inside the context window. Tool results are huge;
+        # keeping 1/3 of messages with 200+ entries still overflows.
+        # Target: last 6 messages (1.5 roundtrips: user/assistant/tool/tool_result).
+        total_remaining = len(messages) - 1
+        if total_remaining <= 0:
+            recent_count = 0
+        else:
+            recent_count = min(6, total_remaining)
+
+        if recent_count == 0:
+            # Even if we can only keep system prompt, ensure there's a user msg
+            recent_msgs = [m for m in messages[1:] if m["role"] == "user"]
+            return [first_msg] + recent_msgs
+
+        recent_msgs = list(messages[-recent_count:])
+
+        # Ensure there's at least one user message in the compacted list.
+        # If the recent window contains no user message, find the most recent
+        # user message from the discarded section and include it.
+        has_user = any(m["role"] == "user" for m in recent_msgs)
+        if not has_user:
+            discarded = messages[1:-recent_count]
+            # Walk backwards to find the latest user message
+            for i in range(len(discarded) - 1, -1, -1):
+                if discarded[i]["role"] == "user":
+                    # Insert just before the recent messages
+                    recent_msgs.insert(0, discarded[i])
+                    break
+
+        # Build compacted list
+        return [first_msg] + recent_msgs
+
     def chat(
         self,
         message: str | None = None,
@@ -234,7 +482,14 @@ class Agent:
         final_text = ""
         total_tool_calls = 0
 
-        for _ in range(max_tool_calls):
+        for iteration in range(max_tool_calls):
+            # Compact context BEFORE each request to prevent token overflow.
+            # After multiple tool roundtrips the accumulated messages can
+            # easily exceed the model's context window.
+            maybe_compacted = self._maybe_compact(messages)
+            if maybe_compacted is not None:
+                messages = maybe_compacted
+
             # When budget is exhausted, rebuild system prompt without tools
             # to prevent the model from hallucinating tool calls
             if self._tool_budget_exhausted:
@@ -259,11 +514,21 @@ class Agent:
 
             response = litellm.completion(**completion_kwargs)
 
+            # Log every LLM call with full message thread and response
+            self._log_llm_call(messages, response, turn_index=iteration + 1)
+
             # Track cost and tokens from this response
             self._track_response_cost(response)
 
             choice = response.choices[0] # type: ignore
-            message_obj = choice.message
+            message_obj = choice.message # type: ignore
+            finish_reason = getattr(choice, "finish_reason", None)
+            # Normalize finish_reason to handle Mock objects that auto-create
+            # attributes — MagicMock() is not None, which prevents the break
+            # logic from triggering on normal responses.
+            if finish_reason is not None and not isinstance(finish_reason, str):
+                finish_reason = None
+
             response_message = {
                 "role": "assistant",
                 "content": message_obj.content or "",
@@ -277,13 +542,30 @@ class Agent:
             if message_obj.content:
                 final_text = message_obj.content
 
-            # If budget was exhausted in a previous iteration, the LLM was
-            # called without tools and returned text. Break and return it.
+            # Route based on finish_reason, not just tool_calls presence
+            if finish_reason == "stop":
+                # Model explicitly done — break and return the accumulated text
+                break
+
+            # Fallback: if finish_reason is None (legacy/mocked) but we have
+            # content with no tool_calls, the model is done
+            if (
+                finish_reason is None
+                and message_obj.content
+                and (not message_obj.tool_calls or len(message_obj.tool_calls) == 0)
+            ):
+                break
+
             if self._tool_budget_exhausted:
+                # Budget exhausted: the LLM was called without tools and
+                # returned text. Break and return it.
                 break
 
-            # If the model returned actual tool calls, execute them
-            if message_obj.tool_calls and len(message_obj.tool_calls) > 0:
+            # Tool execution: either model explicitly said "tool_calls" or
+            # finish_reason is None (legacy/mocked responses) but tool_calls exist
+            if message_obj.tool_calls:
+                assert message_obj.tool_calls is not None
+                # Model requested tool execution — execute them and continue
                 for tool_call in message_obj.tool_calls:
                     # Validate tool call before processing - skip malformed calls
                     if (not tool_call.id or
@@ -413,9 +695,27 @@ class Agent:
                     )
                     total_tool_calls += 1
                     self._update_context_progress(messages)
-                # Safety: if model keeps calling tools without text, force break
-                if total_tool_calls >= 30:
-                    break
+
+                continue
+
+            # Recovery: model said "tool_calls" but provided none
+            # This happens when the model scrambled its last tool call.
+            # Only `stop` terminates the loop; for malformed tool_calls
+            # we keep re-prompting until the model complies or stops.
+            if finish_reason == "tool_calls" and (
+                not message_obj.tool_calls or len(message_obj.tool_calls) == 0
+            ):
+                messages.append({
+                    "role": "user",
+                    "content": (
+                        "You indicated tool calls but provided none. "
+                        "Your response was malformed. Please provide a valid "
+                        "text answer or a properly formatted tool call. "
+                        "Do not use any special formatting, tags, or "
+                        "code markers. Just the answer."
+                    ),
+                })
+                total_tool_calls += 1
                 continue
 
             # Model returned neither text content nor tool calls — re-prompt it
@@ -423,9 +723,6 @@ class Agent:
             if not message_obj.content and (
                 not message_obj.tool_calls or len(message_obj.tool_calls) == 0
             ):
-                if total_tool_calls >= 5:
-                    # After 5 empty responses, just give up and return empty
-                    break
                 messages.append(
                     {
                         "role": "user",
@@ -439,7 +736,9 @@ class Agent:
                 total_tool_calls += 1
                 continue
 
-            break
+        # Only exit the loop on budget exhaustion or finish_reason == "stop".
+        # All other paths re-prompt or continue to allow the model to adapt.
+        # We do not break here on non-stop finish_reasons.
 
         self._update_context_progress(messages)
         self._history = [m for m in messages if m.get("role") != "system"]
@@ -513,231 +812,301 @@ class Agent:
         return "".join(parts)
 
     def _stream(
-        self,
-        messages: list[dict],
-        tool_definitions: list[dict[str, Any]] | None = None,
-        on_text_chunk: Callable[[str], None] | None = None,
-    ) -> str:
-        """Stream response with tool support.
-
-        Runs the same tool-call loop as chat() but streams the final
-        text response chunk-by-chunk. Tool calls are executed normally
-        and their results are communicated via the callbacks registered
-        on __init__ (status_callback / result_callback).
+            self,
+            messages: list[dict],
+            tool_definitions: list[dict[str, Any]] | None = None,
+            on_text_chunk: Callable[[str], None] | None = None,
+            max_tool_calls: int = 10,
+        ) -> str:
+            """Stream response with tool support.
+
+            Runs the same tool-call loop as chat() but streams the final
+            text response chunk-by-chunk. Tool calls are executed normally
+            and their results are communicated via the callbacks registered
+            on __init__ (status_callback / result_callback).
+
+            Args:
+                messages: The message list for the completion.
+                tool_definitions: Tool definitions for the LLM.
+                on_text_chunk: Optional callback invoked for each text chunk
+                    from the LLM stream. Useful for the CLI to print
+                    progressively.
+
+            Returns:
+                The complete final text response.
+            """
+            completion_kwargs = self.config.get_litellm_completion_kwargs()
+            completion_kwargs["messages"] = messages
+            if tool_definitions:
+                completion_kwargs["tools"] = tool_definitions
+                completion_kwargs["tool_choice"] = "auto"
 
-        Args:
-            messages: The message list for the completion.
-            tool_definitions: Tool definitions for the LLM.
-            on_text_chunk: Optional callback invoked for each text chunk
-                from the LLM stream. Useful for the CLI to print
-                progressively.
+            full_text = ""
+            final_text = ""
+            response_message: dict[str, Any] = {}
+            total_tool_calls = 0
 
-        Returns:
-            The complete final text response.
-        """
-        completion_kwargs = self.config.get_litellm_completion_kwargs()
-        completion_kwargs["messages"] = messages
-        if tool_definitions:
-            completion_kwargs["tools"] = tool_definitions
-            completion_kwargs["tool_choice"] = "auto"
+            for iteration in range(max_tool_calls):
+                # Compact context BEFORE each request to prevent token overflow.
+                maybe_compacted = self._maybe_compact(messages)
+                if maybe_compacted is not None:
+                    messages = maybe_compacted
 
-        full_text = ""
-        final_text = ""
-        response_message: dict[str, Any] = {}
-        total_tool_calls = 0
-
-        for _ in range(10):
-            # When budget is exhausted, rebuild system prompt without tools
-            if self._tool_budget_exhausted:
                 system_prompt_text = self._build_system_prompt_no_tools()
                 messages = [
                     {"role": "system", "content": system_prompt_text},
                     *messages[1:],
                 ]
 
-            current_tool_defs = (
-                tool_definitions if not self._tool_budget_exhausted else None
-            )
-
-            if current_tool_defs:
-                completion_kwargs["tools"] = current_tool_defs
-                completion_kwargs["tool_choice"] = "auto"
-            elif self._tool_budget_exhausted:
-                completion_kwargs["tool_choice"] = "none"
-                # Remove tools key if present
-                completion_kwargs.pop("tools", None)
-
-            completion_kwargs["stream"] = True
-            completion_kwargs["messages"] = messages
+                current_tool_defs = (
+                    tool_definitions if not self._tool_budget_exhausted else None
+                )
 
-            response = litellm.completion(**completion_kwargs)
+                if current_tool_defs:
+                    completion_kwargs["tools"] = current_tool_defs
+                    completion_kwargs["tool_choice"] = "auto"
+                elif self._tool_budget_exhausted:
+                    completion_kwargs["tool_choice"] = "none"
+                    # Remove tools key if present
+                    completion_kwargs.pop("tools", None)
+
+                completion_kwargs["stream"] = True
+                completion_kwargs["messages"] = messages
+
+                response = litellm.completion(**completion_kwargs)
+
+                # Log every LLM call with full message thread and response
+                self._log_llm_call(messages, response, turn_index=iteration + 1)
+
+                # Track cost and tokens from this response
+                self._track_response_cost(response)
+
+                # Stream the response — accumulate text and tool_calls
+                # across ALL chunks, not just the last one.
+                full_text = ""
+                stream_finish_reason: str | None = None
+                # Accumulate delta tool calls by index so we can merge partial
+                # chunks (id in first chunk, function name in second, arguments
+                # accumulating in subsequent chunks) into a single per-call object.
+                accumulated_by_index: dict[int, dict[str, Any]] = {}
+                try:
+                    for chunk in response:
+                        delta = chunk.choices[0].delta # type: ignore
+                        # Capture finish_reason from the last chunk
+                        if delta.finish_reason is not None:
+                            stream_finish_reason = delta.finish_reason
+                        # Accumulate text content
+                        if delta.content:
+                            full_text += delta.content
+                            if on_text_chunk:
+                                on_text_chunk(delta.content)
+                        # Accumulate tool calls from any chunk
+                        if delta.tool_calls:
+                            for tc_delta in delta.tool_calls:
+                                idx = tc_delta.index  # type: ignore
+                                if idx not in accumulated_by_index:
+                                    accumulated_by_index[idx] = {
+                                        "id": tc_delta.id or "",
+                                        "type": tc_delta.type or "function",
+                                        "function_name": "",
+                                        "function_arguments": "",
+                                    }
+                                acc = accumulated_by_index[idx]
+                                if tc_delta.id is not None:
+                                    acc["id"] = tc_delta.id
+                                if tc_delta.function is not None:
+                                    if tc_delta.function.name:
+                                        acc["function_name"] = tc_delta.function.name
+                                    if tc_delta.function.arguments:
+                                        acc["function_arguments"] += (
+                                            tc_delta.function.arguments
+                                        )
+                except Exception:
+                    # Litellm's streaming iterator can crash on malformed responses
+                    # or sentinel markers like [DONE]. If iteration fails, just use
+                    # whatever text we accumulated so far.
+                    pass
+
+                # Reconstruct tool call dicts from accumulated chunks and validate
+                valid_tool_calls = []
+                for idx, acc in accumulated_by_index.items():
+                    if not acc.get("id") or not acc.get("function_name"):
+                        continue
+                    valid_tool_calls.append({
+                        "id": acc["id"],
+                        "type": acc["type"],
+                        "index": idx,
+                        "function": {
+                            "name": acc["function_name"],
+                            "arguments": acc["function_arguments"],
+                        },
+                    })
+
+                response_message = {
+                    "role": "assistant",
+                    "content": full_text or "",
+                }
+
+                # Attach only valid accumulated tool calls
+                if valid_tool_calls:
+                    response_message["tool_calls"] = valid_tool_calls
+
+                messages.append(response_message)
+
+                if full_text:
+                    final_text = full_text
+
+                if self._tool_budget_exhausted:
+                    break
 
-            # Track cost and tokens from this response
-            self._track_response_cost(response)
+                # Route based on finish_reason, not just tool_calls presence
+                if stream_finish_reason == "stop":
+                    # Model is done — break and return the accumulated text
+                    break
 
-            # Stream the response — accumulate text and tool_calls
-            # across ALL chunks, not just the last one.
-            full_text = ""
-            # Accumulate delta tool calls by index so we can merge partial
-            # chunks (id in first chunk, function name in second, arguments
-            # accumulating in subsequent chunks) into a single per-call object.
-            accumulated_by_index: dict[int, dict[str, Any]] = {}
-            try:
-                for chunk in response:
-                    delta = chunk.choices[0].delta # type: ignore
-                    # Accumulate text content
-                    if delta.content:
-                        full_text += delta.content
-                        if on_text_chunk:
-                            on_text_chunk(delta.content)
-                    # Accumulate tool calls from any chunk
-                    if delta.tool_calls:
-                        for tc_delta in delta.tool_calls:
-                            idx = tc_delta.index  # type: ignore
-                            if idx not in accumulated_by_index:
-                                accumulated_by_index[idx] = {
-                                    "id": tc_delta.id or "",
-                                    "type": tc_delta.type or "function",
-                                    "function_name": "",
-                                    "function_arguments": "",
-                                }
-                            acc = accumulated_by_index[idx]
-                            if tc_delta.id is not None:
-                                acc["id"] = tc_delta.id
-                            if tc_delta.function is not None:
-                                if tc_delta.function.name:
-                                    acc["function_name"] = tc_delta.function.name
-                                if tc_delta.function.arguments:
-                                    acc["function_arguments"] += (
-                                        tc_delta.function.arguments
-                                    )
-            except Exception:
-                # Litellm's streaming iterator can crash on malformed responses
-                # or sentinel markers like [DONE]. If iteration fails, just use
-                # whatever text we accumulated so far.
-                pass
-
-            # Reconstruct tool call dicts from accumulated chunks and validate
-            valid_tool_calls = []
-            for idx, acc in accumulated_by_index.items():
-                if not acc.get("id") or not acc.get("function_name"):
+                # Recovery: model said "tool_calls" but provided none
+                # This happens when the model scrambled its last tool call
+                if stream_finish_reason == "tool_calls" and not valid_tool_calls:
+                    messages.append({
+                        "role": "user",
+                        "content": (
+                            "You indicated tool calls but provided none. "
+                            "Your response was malformed. Please provide a valid "
+                            "text answer or a properly formatted tool call."
+                        ),
+                    })
+                    total_tool_calls += 1
                     continue
-                valid_tool_calls.append({
-                    "id": acc["id"],
-                    "type": acc["type"],
-                    "index": idx,
-                    "function": {
-                        "name": acc["function_name"],
-                        "arguments": acc["function_arguments"],
-                    },
-                })
-
-            response_message = {
-                "role": "assistant",
-                "content": full_text or "",
-            }
-
-            # Attach only valid accumulated tool calls
-            if valid_tool_calls:
-                response_message["tool_calls"] = valid_tool_calls
-
-            messages.append(response_message)
-
-            if full_text:
-                final_text = full_text
 
-            if self._tool_budget_exhausted:
-                break
-
-            if valid_tool_calls:
-                for tc_dict in valid_tool_calls:
-                    tool_name = str(tc_dict["function"]["name"])
-                    tool_call_obj = ToolCall(tool_name, {})
+                if valid_tool_calls:
+                    for tc_dict in valid_tool_calls:
+                        tool_name = str(tc_dict["function"]["name"])
+                        tool_call_obj = ToolCall(tool_name, {})
+
+                        try:
+                            tool_args = json.loads(tc_dict["function"]["arguments"])
+                        except (json.JSONDecodeError, AttributeError):
+                            tool_args = {}
+                            if self._status_callback is not None:
+                                self._status_callback(
+                                    AgentStatus.TOOL_CALL, tool_call_obj
+                                )
+                            if self._result_callback is not None:
+                                self._result_callback(
+                                    AgentStatus.TOOL_RESULT,
+                                    (
+                                        f"Error: Failed to parse arguments for "
+                                        f"tool '{tool_name}'."
+                                    ),
+                                    True,
+                                    tool_call_obj,
+                                )
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tc_dict["id"],
+                                "name": tool_name,
+                                "content": (
+                                    f"Error: Failed to parse arguments for "
+                                    f"tool '{tool_name}'."
+                                ),
+                            })
+                            total_tool_calls += 1
+                            continue
+
+                        if self._allowed_dir is not None:
+                            for arg_name in ["path", "file_path"]:
+                                if arg_name in tool_args:
+                                    arg_path = Path(tool_args[arg_name])
+                                    try:
+                                        if arg_path.is_absolute():
+                                            raise ValueError(
+                                                "Access denied: "
+                                                "absolute paths are not allowed"
+                                            )
+                                        if ".." in arg_path.parts:
+                                            raise ValueError(
+                                                "Access denied: "
+                                                "paths with '..' are not allowed"
+                                            )
+                                        if not arg_path.is_absolute():
+                                            arg_path = Path(
+                                                self._allowed_dir
+                                            ) / arg_path
+                                        arg_path = arg_path.resolve()
+                                        if not arg_path.is_relative_to(
+                                            Path(self._allowed_dir).resolve()
+                                        ):
+                                            raise ValueError(
+                                                (
+                                                    f"Access denied: "
+                                                    f"'{arg_path}' is outside "
+                                                    f"allowed directory "
+                                                    f"'{self._allowed_dir}'"
+                                                )
+                                            )
+                                    except ValueError as e:
+                                        messages.append(
+                                            {
+                                                "role": "tool",
+                                                "tool_call_id": tc_dict["id"],
+                                                "name": tool_name,
+                                                "content": str(e),
+                                            }
+                                        )
+                                        continue
 
-                    try:
-                        tool_args = json.loads(tc_dict["function"]["arguments"])
-                    except (json.JSONDecodeError, AttributeError):
-                        tool_args = {}
+                        tool_call_obj = ToolCall(tool_name, tool_args)
+                        if self._status_callback is not None:
+                            self._status_callback(
+                                AgentStatus.TOOL_CALL, tool_call_obj
+                            )
+                        result = self.registry.execute(tool_name, **tool_args)
+                        result_str = str(result)
                         if self._status_callback is not None:
-                            self._status_callback(AgentStatus.TOOL_CALL, tool_call_obj)
+                            self._status_callback(
+                                AgentStatus.TOOL_RESULT, tool_call_obj
+                            )
                         if self._result_callback is not None:
+                            is_error = (
+                                "Error" in result_str
+                                or "Traceback" in result_str
+                            )
                             self._result_callback(
                                 AgentStatus.TOOL_RESULT,
-                                (
-                                    f"Error: Failed to parse arguments for "
-                                    f"tool '{tool_name}'."
-                                ),
-                                True,
+                                result_str,
+                                is_error,
                                 tool_call_obj,
                             )
-                        messages.append({
-                            "role": "tool",
-                            "tool_call_id": tc_dict["id"],
-                            "name": tool_name,
-                            "content": (
-                                f"Error: Failed to parse arguments for "
-                                f"tool '{tool_name}'."
-                            ),
-                        })
-                        total_tool_calls += 1
-                        continue
-
-                    if self._allowed_dir is not None:
-                        for arg_name in ["path", "file_path"]:
-                            if arg_name in tool_args:
-                                arg_path = Path(tool_args[arg_name])
-                                try:
-                                    if arg_path.is_absolute():
-                                        raise ValueError(
-                                            "Access denied: "
-                                            "absolute paths are not allowed"
-                                        )
-                                    if ".." in arg_path.parts:
-                                        raise ValueError(
-                                            "Access denied: "
-                                            "paths with '..' are not allowed"
-                                        )
-                                    if not arg_path.is_absolute():
-                                        arg_path = Path(self._allowed_dir) / arg_path
-                                    arg_path = arg_path.resolve()
-                                    if not arg_path.is_relative_to(
-                                        Path(self._allowed_dir).resolve()
-                                    ):
-                                        raise ValueError(
-                                            f"Access denied: '{arg_path}' is outside "
-                                            f"allowed directory '{self._allowed_dir}'"
-                                        )
-                                except ValueError as e:
-                                    messages.append(
-                                        {
-                                            "role": "tool",
-                                            "tool_call_id": tc_dict["id"],
-                                            "name": tool_name,
-                                            "content": str(e),
-                                        }
-                                    )
-                                    continue
 
-                    tool_call_obj = ToolCall(tool_name, tool_args)
-                    if self._status_callback is not None:
-                        self._status_callback(AgentStatus.TOOL_CALL, tool_call_obj)
-                    result = self.registry.execute(tool_name, **tool_args)
-                    result_str = str(result)
-                    if self._status_callback is not None:
-                        self._status_callback(AgentStatus.TOOL_RESULT, tool_call_obj)
-                    if self._result_callback is not None:
-                        is_error = "Error" in result_str or "Traceback" in result_str
-                        self._result_callback(
-                            AgentStatus.TOOL_RESULT, result_str, is_error, tool_call_obj
-                        )
-
-                    self._tool_budget_remaining -= 1
-                    if self._tool_budget_remaining <= 0:
-                        self._tool_budget_exhausted = True
-                        if self._status_callback is not None:
-                            self._status_callback(
-                                AgentStatus.BUDGET_EXHAUSTED, tool_call_obj
+                        self._tool_budget_remaining -= 1
+                        if self._tool_budget_remaining <= 0:
+                            self._tool_budget_exhausted = True
+                            if self._status_callback is not None:
+                                self._status_callback(
+                                    AgentStatus.BUDGET_EXHAUSTED, tool_call_obj
+                                )
+                            messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_dict["id"],
+                                    "name": tool_name,
+                                    "content": str(result),
+                                }
+                            )
+                            messages.append(
+                                {
+                                    "role": "user",
+                                    "content": (
+                                        "You have exhausted your tool budget. "
+                                        "Provide your final answer in plain text only. "
+                                        "Do not use any special formatting, tags, or "
+                                        "code markers. Just the answer."
+                                    ),
+                                }
                             )
+                            total_tool_calls += 1
+                            continue
+
                         messages.append(
                             {
                                 "role": "tool",
@@ -746,61 +1115,35 @@ class Agent:
                                 "content": str(result),
                             }
                         )
-                        messages.append(
-                            {
-                                "role": "user",
-                                "content": (
-                                    "You have exhausted your tool budget. "
-                                    "Provide your final answer in plain text only. "
-                                    "Do not use any special formatting, tags, or "
-                                    "code markers. Just the answer."
-                                ),
-                            }
-                        )
                         total_tool_calls += 1
-                        continue
+                        self._update_context_progress(messages)
+
+                    continue
 
+                # Model returned neither text content nor tool calls — re-prompt it
+                # to force an answer with the current context state.
+                if not full_text and (
+                    not response_message.get("tool_calls") or
+                    len(response_message.get("tool_calls", [])) == 0
+                ):
                     messages.append(
                         {
-                            "role": "tool",
-                            "tool_call_id": tc_dict["id"],
-                            "name": tool_name,
-                            "content": str(result),
+                            "role": "user",
+                            "content": (
+                                "You returned an empty response with no tool calls. "
+                                "Please provide your answer now based on the current "
+                                "conversation state. Respond in plain text only."
+                            ),
                         }
                     )
                     total_tool_calls += 1
-                    self._update_context_progress(messages)
-                if total_tool_calls >= 30:
-                    break
-                continue
-
-            # Model returned neither text content nor tool calls — re-prompt it
-            # to force an answer with the current context state.
-            if not full_text and (
-                not response_message.get("tool_calls") or
-                len(response_message.get("tool_calls", [])) == 0
-            ):
-                if total_tool_calls >= 5:
-                    # After 5 empty responses, just give up and return empty
-                    break
-                messages.append(
-                    {
-                        "role": "user",
-                        "content": (
-                            "You returned an empty response with no tool calls. "
-                            "Please provide your answer now based on the current "
-                            "conversation state. Respond in plain text only."
-                        ),
-                    }
-                )
-                total_tool_calls += 1
-                continue
+                    continue
 
-            break
+                break
 
-        self._update_context_progress(messages)
-        self._history = [m for m in messages if m.get("role") != "system"]
-        return final_text or response_message.get("content", "") or ""
+            self._update_context_progress(messages)
+            self._history = [m for m in messages if m.get("role") != "system"]
+            return final_text or response_message.get("content", "") or ""
 
     def _update_context_progress(self, messages: list[dict[str, Any]]) -> None:
         """Estimate token usage and report progress via context_callback."""
@@ -1046,3 +1389,4 @@ class Agent:
     def __exit__(self, *args: Any) -> None:
         """Exit context manager."""
         self.cleanup()
+

regcode/tools/builtins.py

@@ -15,6 +15,9 @@ import urllib.request
 from pathlib import Path
 from typing import Any
 
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+
 from regcode.monty_sandbox import MontySandbox
 from regcode.tools.base import BaseTool, ToolParam, ToolResult
 from regcode.tools.web_crawl import WebCrawlerTool
@@ -271,11 +274,92 @@ class ShellCommandTool(BaseTool):
 
 
 class ReadFileTool(BaseTool):
-    """Read files from the sandbox filesystem."""
+    """Read files from the sandbox filesystem.
+
+    Blocklist prevents reading large token-heavy files that waste context
+    and provide no value (lock files, node_modules, binary artifacts, etc).
+    Also respects .gitignore patterns from the repository root.
+    """
 
     name = "read_file"
     description = "Read the contents of a file from the sandbox filesystem."
 
+    # Files and patterns that are too large/toxic for context — never read them
+    BLOCKED_NAMES: frozenset[str] = frozenset((
+        # Package lock files
+        "uv.lock",
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        "Cargo.lock",
+        "Gemfile.lock",
+        "podfile.lock",
+        "composer.lock",
+        "go.sum",
+        "pubspec.lock",
+        "mix.lock",
+        # Node modules (traverse blocks)
+        "node_modules",
+        "__pycache__",
+        ".git",
+        ".venv",
+        "venv",
+        # Binary / generated artifacts
+        ".DS_Store",
+        "Thumbs.db",
+        ".env",
+        ".env.local",
+        ".env.production",
+        # Large generated files
+        "coverage.json",
+        "coverage.xml",
+    ))
+
+    BLOCKED_EXTENSIONS: frozenset[str] = frozenset((
+        # Binary formats
+        ".pyc", ".pyo", ".pyd", ".so", ".dll", ".dylib", ".o", ".obj",
+        ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp", ".svg",
+        ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z", ".rar",
+        ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+        ".mp3", ".mp4", ".avi", ".mov", ".wav", ".ogg",
+        ".woff", ".woff2", ".ttf", ".eot",
+    ))
+
+    # Cached .gitignore specs, keyed by repo root
+    _gitignore_specs: dict[str, PathSpec] = {}
+
+    @classmethod
+    def _load_gitignore_spec(cls, repo_root: Path) -> PathSpec | None:
+        """Load and parse .gitignore from repo_root if it exists.
+
+        Returns a PathSpec object, or None if no .gitignore found.
+        """
+        cache_key = str(repo_root.resolve())
+        if cache_key in cls._gitignore_specs:
+            return cls._gitignore_specs[cache_key]
+
+        gitignore_path = repo_root / ".gitignore"
+        if not gitignore_path.exists():
+            return None
+
+        try:
+            lines = gitignore_path.read_text().splitlines()
+            patterns = []
+            for line in lines:
+                line = line.strip()
+                # Skip empty lines and comments
+                if not line or line.startswith("#"):
+                    continue
+                patterns.append(GitWildMatchPattern(line))
+            if patterns:
+                spec = PathSpec.from_lines(GitWildMatchPattern, patterns)
+                cls._gitignore_specs[cache_key] = spec
+                return spec
+        except Exception:
+            # Never crash on .gitignore parse failure
+            pass
+        return None
+
     @property
     def params(self) -> list[ToolParam]:
         return [
@@ -289,14 +373,61 @@ class ReadFileTool(BaseTool):
                 output="Missing required parameter: path",
                 error=True,
             )
-        # Read from host filesystem (same as browse_dir)
+        # Check for blocked paths
         p = Path(path)
+        # Walk all parts of the path — if any matches a blocked name, reject
+        for part in p.parts:
+            if part in self.BLOCKED_NAMES:
+                return ToolResult(
+                    output=f"Access denied: '{path}' is a blocked path ({part}). "
+                           "Reading lock files, node_modules, binary artifacts, and "
+                           "generated data is not permitted — they waste context "
+                           "tokens and provide no value.",
+                    error=True,
+                    exit_code=1,
+                )
+            # Check extension
+            if p.suffix and p.suffix.lower() in self.BLOCKED_EXTENSIONS:
+                return ToolResult(
+                    output=(
+                        f"Access denied: '{path}' has blocked extension "
+                        f"'{p.suffix}'. "
+                        "Reading binary/artifact files is not permitted."
+                    ),
+                    error=True,
+                    exit_code=1,
+                )
         if not p.exists():
             return ToolResult(
                 output=f"File not found: {path}",
                 error=True,
                 exit_code=1,
             )
+
+        # Check against .gitignore patterns
+        # Find the git repository root (or project root)
+        repo_root = self._find_git_root(p)
+        if repo_root is not None:
+            spec = self._load_gitignore_spec(repo_root)
+            if spec is not None:
+                # Get relative path from repo_root
+                try:
+                    rel_path = p.resolve().relative_to(repo_root.resolve())
+                    # pathspec expects forward slashes
+                    rel_path_str = str(rel_path).replace("\\", "/")
+                    if spec.match_file(rel_path_str):
+                        return ToolResult(
+                            output=(
+                                f"Access denied: '{path}' matches a .gitignore "
+                                "pattern in the repository."
+                            ),
+                            error=True,
+                            exit_code=1,
+                        )
+                except ValueError:
+                    # File is outside repo root, skip gitignore check
+                    pass
+
         try:
             content = p.read_text()
             return ToolResult(output=f"File: {path}\n{content}", exit_code=0)
@@ -307,6 +438,19 @@ class ReadFileTool(BaseTool):
                 exit_code=1,
             )
 
+    @classmethod
+    def _find_git_root(cls, file_path: Path) -> Path | None:
+        """Find the git repository root containing the given file.
+
+        Walks up the directory tree looking for .git directory.
+        Returns the repository root, or None if not found.
+        """
+        current = file_path.resolve()
+        for parent in current.parents:
+            if (parent / ".git").exists():
+                return parent
+        return None
+
 
 class FetchGitDiffTool(BaseTool):
     """Fetch the git diff of the current repository."""

regcode/tui.py

@@ -374,6 +374,21 @@ class ChatApp(App):
             self._handle_reset_session()
             return
 
+        if message == "/dump":
+            if self._agent is not None:
+                try:
+                    dump_file = "agent_history.json"
+                    self._agent.dump_history(dump_file)
+                    self._append_rich(
+                        f"[dim]Agent history dumped to {dump_file}[/]\n"
+                    )
+                    self._append_rich("─" * 60 + "\n")
+                except Exception as e:
+                    _logger.exception("Error dumping history: %s", e)
+                    self._append_rich(f"[red]Error: {e}[/]\n")
+                    self._append_rich("─" * 60 + "\n")
+            return
+
         if self._agent_running:
             self._msg_queue.append(message)
             return
@@ -434,15 +449,13 @@ class ChatApp(App):
 
                 result = self._agent.chat(
                     message,
-                    stream=True,
-                    on_text_chunk=self.on_text_chunk,
+                    stream=False,
                 )
 
-                # Fallback: if no chunks were emitted, render final text
-                if result and not self._current_response:
-                    self.call_from_thread(
-                        self._set_fallback_response, result
-                    )
+                # Non-streaming: result is the full response.
+                # Put it in _current_response so _finish_message renders it.
+                if result:
+                    self._current_response.append(result)
         except Exception as e:
             _logger.exception("Agent error: %s", e)
             self.call_from_thread(

{regcode-0.6.2.dist-info → regcode-0.7.0.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.6.2
+Version: 0.7.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
 Requires-Dist: crawl4ai>=0.4.0
 Requires-Dist: litellm>=1.83.17
 Requires-Dist: mlflow>=3.14.0
+Requires-Dist: pathspec>=1.1.1
 Requires-Dist: pydantic-monty>=0.0.18
 Requires-Dist: pydantic-settings>=2.14.2
 Requires-Dist: pytest>=8.0

{regcode-0.6.2.dist-info → regcode-0.7.0.dist-info}/RECORD

@@ -1,22 +1,22 @@
-regcode/__init__.py,sha256=PDGu5z3A9XTW8PUPY3nSTva-m21BiTnKIowZ0j_sdC0,168
+regcode/__init__.py,sha256=fJ1FEfFe0m5THrydkDVhx_pWDIYmT52upqaL-4fw2XU,168
 regcode/cli.py,sha256=jygDB1u_T5_sXm3TxvUPe9VZpC3-42A4pEMwW4PVLcc,5432
-regcode/config.py,sha256=b0_uyquT2zVUa14cMG0NE-0zJJnsP6Pc73uu3gXf84Y,6664
+regcode/config.py,sha256=h3alI_qyNoHZDR4RyNmMGsbrfc0Lx88QZ56M1PEhOfA,6693
 regcode/conversation_manager.py,sha256=7b1hB7881ydPkCvePJIZ-HgtUi95FglJ7MyFAYw2H1o,5636
 regcode/dependencies.py,sha256=xi6_XuL4xOqk3ORIe7a92q5oHidiECeefVTjevHiIwU,2357
-regcode/main.py,sha256=vNqKd_Mbhj00ybtlduBYBI4NwwwiQ90AWNsNT-sJfqM,44054
+regcode/main.py,sha256=c64uEL4s0iy5dDjVoU7LRo4qqCpvVhhMdG7-K7F1rto,59923
 regcode/monty_sandbox.py,sha256=UxTFmczQr5F4nlDe1gJ5Ul6GX_5KJkVYekVia-JKKvw,12930
 regcode/permissions.py,sha256=9R1dz6ypxBq_tNj-l4ixq_KJ-kAbXHarOey5EmnZzgU,784
 regcode/sandbox.py,sha256=v7oyl4PZVs4uMGGJRQC7YdQNLf7pbtRpVMXuNfnslJI,11414
 regcode/tracing.py,sha256=Uq6h_fT8k2_oVY5cJgM88IFaqN4hSjYyD7xnG1gJuy0,3568
-regcode/tui.py,sha256=Zc_3JdpvtuAuvJFDVd1v7wxDIfc2sK4W3xMy8gNosxo,33036
+regcode/tui.py,sha256=5Ust2krVgfpHHu9igwqrUQFpRXSHfxzgiLbGsxrxy1M,33592
 regcode/tools/__init__.py,sha256=VG2pxPkVSRUaLZ-tgNTcvcJSXUOuVLeCT0yx7k1g2pQ,325
 regcode/tools/base.py,sha256=D4oalxZb-cKvCMFeghyKSoLy_M7LUVPMeFTUPmrcuyY,3538
-regcode/tools/builtins.py,sha256=FhyXiyriV35HKrEsVLGa25eqBhEBHDAVpfXN08DgG3M,46330
+regcode/tools/builtins.py,sha256=ktyvTxmOjRLI7U5AD-2Z9WMcEvZkpv8Z6HR-4IHs-e0,51675
 regcode/tools/registry.py,sha256=jrGtKLlRPgfFQFGlCAaxEfoR0ZXForQUmZexM5-HnEo,2638
 regcode/tools/review_notes.py,sha256=zdbKTKv2hlnfd7Q-F0xlg8n2IHt7h0KssS0OyyY2gcM,3743
 regcode/tools/web_crawl.py,sha256=7weNwU6RAJNiyc04vcPD64ODh5_oqoFlec5vyMRKh90,5594
 regcode/tools/web_search.py,sha256=g9na3CrlPvefYIIfopdMN1H3Xh5K8DonqeRuf1-ucWk,5010
-regcode-0.6.2.dist-info/METADATA,sha256=uSxfmg3H0vGSibzpYpHIBL_aA89EUSM9pRMDdqGlIMU,9091
-regcode-0.6.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-regcode-0.6.2.dist-info/entry_points.txt,sha256=DzSdoP-DefYTNnnuwctq7neSx19XjfB78Jzk-c1UcsQ,44
-regcode-0.6.2.dist-info/RECORD,,
+regcode-0.7.0.dist-info/METADATA,sha256=WZsAQsjzjRHKj0Jj5H2T61zA0rE3z6SC4I_a0RNV1AI,9122
+regcode-0.7.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+regcode-0.7.0.dist-info/entry_points.txt,sha256=DzSdoP-DefYTNnnuwctq7neSx19XjfB78Jzk-c1UcsQ,44
+regcode-0.7.0.dist-info/RECORD,,