regcode 0.6.3__tar.gz → 0.7.0__tar.gz

{regcode-0.6.3 → regcode-0.7.0}/AGENTS.md

@@ -3,25 +3,17 @@ Always make sure to comply to these rules. Under Project Stack, you will find te
 
 ## Project Stack:
 - `uv`: Dependency management for Python runtime
-- Alembic: Database migrations
-- FastAPI: Backend Logic
-- SQLAlchemy ORM: Python database ORM
-- PostgreSQL/SQLITE: Target databases
 - Pytest: Test suite under `tests`
-- NextJS/React: Frontend Code under `frontend/`
 - GitLab: Code Repository/ CI CD
 - .gitlab-ci.yml: Gitlab Runner Config
 - `ruff`: Linting and Code Quality Control
-- `docker`: Deployment is done via `docker-compose.yml`
 - `pyproject.toml`: Project Setup Config
 
 ## Coding/Implentation Instructions:
-- Always use `alembic` for database structure. Using `Base.create_all()` and similar syntax is PROHIBITED!
-- Use `alembic revision -m <revision explanation>` to create new revisions. Making arbitrary strings as versions etc. is PROHIBITED!
+
 - ALWAYS run `uv run ruff check --fix` after all changes at the end and fix linting issues
 - ALWAYS run `uv run pytest` to run test suite after all changes and fix issues shown by tests.
 - ALWAYS add test cases if relevant.
-- NEVER use emojis! Use icon packs (for example `lucid-react`) if needed. 
 - NEVER commit changes. It is upto user to review your code and commit and push it. Unless user specifically asks for it, commiting code is PROHIBITED!
 
 ## Project Vision

{regcode-0.6.3 → regcode-0.7.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.6.3
+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.3 → regcode-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.6.3"
+version = "0.7.0"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -15,6 +15,7 @@ dependencies = [
     "pydantic-monty>=0.0.18",
     "mlflow>=3.14.0",
     "textual>=2.0.0",
+    "pathspec>=1.1.1",
 ]
 
 [project.scripts]

{regcode-0.6.3 → regcode-0.7.0}/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-0.6.3 → regcode-0.7.0}/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 # 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"]
@@ -547,7 +846,12 @@ class Agent:
             response_message: dict[str, Any] = {}
             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.
+                maybe_compacted = self._maybe_compact(messages)
+                if maybe_compacted is not None:
+                    messages = maybe_compacted
+
                 system_prompt_text = self._build_system_prompt_no_tools()
                 messages = [
                     {"role": "system", "content": system_prompt_text},
@@ -571,12 +875,16 @@ 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)
 
                 # 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.
@@ -584,6 +892,9 @@ class Agent:
                 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
@@ -648,6 +959,25 @@ class Agent:
                 if self._tool_budget_exhausted:
                     break
 
+                # 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
+
+                # 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
+
                 if valid_tool_calls:
                     for tc_dict in valid_tool_calls:
                         tool_name = str(tc_dict["function"]["name"])
@@ -787,8 +1117,7 @@ class Agent:
                         )
                         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
@@ -797,9 +1126,6 @@ class Agent:
                     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",
@@ -1063,3 +1389,4 @@ class Agent:
     def __exit__(self, *args: Any) -> None:
         """Exit context manager."""
         self.cleanup()
+

{regcode-0.6.3 → regcode-0.7.0}/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-0.6.3 → regcode-0.7.0}/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.3 → regcode-0.7.0}/tests/test_main.py

@@ -959,8 +959,8 @@ def test_chat_reprompt_loop_single_empty():
         assert re_prompt_found, "Re-prompt message not found in second call"
 
 
-def test_chat_reprompt_loop_five_empty_then_give_up():
-    """Test that after 5 empty responses, chat() gives up."""
+def test_chat_reprompt_loop_empty_until_max_tool_calls():
+    """Test that chat() re-prompts on empty responses until max_tool_calls is hit."""
     from unittest.mock import MagicMock, patch
 
     from regcode.config import Config
@@ -969,7 +969,7 @@ def test_chat_reprompt_loop_five_empty_then_give_up():
     agent = Agent(config=config)
 
     with patch("regcode.main.litellm.completion") as mock_completion:
-        # 6 empty responses in a row
+        # Empty responses in a row — loop is bounded by max_tool_calls=10
         empty_response = MagicMock(
             choices=[
                 MagicMock(
@@ -984,8 +984,9 @@ def test_chat_reprompt_loop_five_empty_then_give_up():
 
         result = agent.chat("Hello")
         assert result == ""
-        # Should be called up to 6 times (1 initial + 5 re-prompts)
-        assert mock_completion.call_count == 6
+        # Called 10 times (max_tool_calls default) — loop bounded by max_tool_calls,
+        # not by an arbitrary empty-response limit
+        assert mock_completion.call_count == 10
 
 
 def test_chat_no_reprompt_when_has_content():
@@ -1105,8 +1106,8 @@ def test_stream_reprompt_loop_single_empty():
         assert re_prompt_found
 
 
-def test_stream_reprompt_five_empty_then_give_up():
-    """Test that after 5 empty responses in stream, it gives up."""
+def test_stream_reprompt_empty_until_max_tool_calls():
+    """Test that _stream() re-prompts on empty responses until max_tool_calls is hit."""
     from unittest.mock import MagicMock, patch
 
     from regcode.config import Config
@@ -1115,6 +1116,7 @@ def test_stream_reprompt_five_empty_then_give_up():
     agent = Agent(config=config)
 
     with patch("regcode.main.litellm.completion") as mock_completion:
+        # Empty responses in a row — loop is bounded by max_tool_calls=10
         empty_response = [
             MagicMock(choices=[MagicMock(delta=MagicMock(
                 content=None, tool_calls=None,
@@ -1126,5 +1128,6 @@ def test_stream_reprompt_five_empty_then_give_up():
             [{"role": "user", "content": "Hello"}]
         )
         assert result == ""
-        # Called up to 6 times (1 initial + 5 re-prompts)
-        assert mock_completion.call_count == 6
+        # Called 10 times (max_tool_calls default) — loop bounded by max_tool_calls,
+        # not by an arbitrary empty-response limit
+        assert mock_completion.call_count == 10

{regcode-0.6.3 → regcode-0.7.0}/uv.lock

@@ -2961,6 +2961,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c9/b0/2e83f9245e08db9f5d1ed10e5be581feac18ed3b5eadd5dbe32aa487567b/patchright-1.61.1-py3-none-win_arm64.whl", hash = "sha256:be79b2931a76a93e77b2e75970be5e4a65ed856de1f6cd170386fbc78f7f55a8", size = 33932055, upload-time = "2026-06-29T10:37:47.083Z" },
 ]
 
+[[package]]
+name = "pathspec"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
+]
+
 [[package]]
 name = "pillow"
 version = "12.2.0"
@@ -3805,13 +3814,14 @@ wheels = [
 
 [[package]]
 name = "regcode"
-version = "0.6.3"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
     { name = "crawl4ai" },
     { name = "litellm" },
     { name = "mlflow" },
+    { name = "pathspec" },
     { name = "pydantic-monty" },
     { name = "pydantic-settings" },
     { name = "pytest" },
@@ -3826,6 +3836,7 @@ requires-dist = [
     { name = "crawl4ai", specifier = ">=0.4.0" },
     { name = "litellm", specifier = ">=1.83.17" },
     { name = "mlflow", specifier = ">=3.14.0" },
+    { name = "pathspec", specifier = ">=1.1.1" },
     { name = "pydantic-monty", specifier = ">=0.0.18" },
     { name = "pydantic-settings", specifier = ">=2.14.2" },
     { name = "pytest", specifier = ">=8.0" },