cecli-dev 0.99.8__tar.gz → 0.99.9__tar.gz

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.8
+Version: 0.99.9
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.99.7.dev"
+__version__ = "0.99.9.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.8'
-__version_tuple__ = version_tuple = (0, 99, 8)
+__version__ = version = '0.99.9'
+__version_tuple__ = version_tuple = (0, 99, 9)
 
-__commit_id__ = commit_id = 'g2e022d0e6'
+__commit_id__ = commit_id = 'g7edfde9ea'

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/coders/agent_coder.py

@@ -618,9 +618,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         editable_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         editable_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"
@@ -642,9 +640,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         readonly_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         readonly_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/coders/base_coder.py

@@ -2178,6 +2178,8 @@ class Coder:
         # Notify IO that LLM processing is starting
         self.io.llm_started()
 
+        ConversationService.get_manager(self).flush_queue()
+
         if inp:
             # Make sure current coder actually has control of conversation system
             ConversationService.get_chunks(self).initialize_conversation_system()
@@ -3723,7 +3725,7 @@ class Coder:
             self.check_for_dirty_commit(path)
             return True
 
-        if self.repo and self.repo.git_ignored_file(path):
+        if self.repo and self.repo.git_ignored_file(path) and not self.add_gitignore_files:
             self.io.tool_warning(f"Skipping edits to {path} that matches gitignore spec.")
             return
 
@@ -3742,7 +3744,8 @@ class Coder:
                 # actually already part of the repo.
                 # But let's only add if we need to, just to be safe.
                 if need_to_add:
-                    self.repo.repo.git.add(full_path)
+                    if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                        self.repo.repo.git.add(full_path)
 
             self.abs_fnames.add(full_path)
             self.check_added_files()
@@ -3756,7 +3759,8 @@ class Coder:
             return
 
         if need_to_add:
-            self.repo.repo.git.add(full_path)
+            if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                self.repo.repo.git.add(full_path)
 
         self.abs_fnames.add(full_path)
         self.check_added_files()
@@ -4003,7 +4007,10 @@ class Coder:
         return edits
 
     def local_agent_folder(self, path):
-        os.makedirs(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}", exist_ok=True)
+        os.makedirs(
+            self.abs_root_path(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}"),
+            exist_ok=True,
+        )
 
         stripped = path.lstrip("/")
         return f".cecli/agents/{GLOBAL_DATE}/{self.uuid}/{stripped}"

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/commands/load_session.py

@@ -18,7 +18,7 @@ class LoadSessionCommand(BaseCommand):
         from cecli import sessions
 
         session_manager = sessions.SessionManager(coder, io)
-        session_manager.load_session(args.strip())
+        await session_manager.load_session(args.strip())
 
         return format_command_result(io, "load-session", f"Loaded session: {args.strip()}")
 

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/helpers/conversation/integration.py

@@ -446,7 +446,7 @@ class ConversationChunks:
                 dict(role="user", content=repo_content),
                 dict(
                     role="assistant",
-                    content="Ok, I won't try and edit those files without asking first.",
+                    content="Thank you, these files will help with navigating the codebase.",
                 ),
             ]
 
@@ -781,14 +781,14 @@ class ConversationChunks:
             }
 
             # Add to conversation manager
-            ConversationService.get_manager(coder).add_message(
+            ConversationService.get_manager(coder).queue_message(
                 message_dict=user_msg,
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_user", file_path),
                 force=True,
             )
 
-            ConversationService.get_manager(coder).add_message(
+            ConversationService.get_manager(coder).queue_message(
                 message_dict=assistant_msg,
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_assistant", file_path),

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/helpers/conversation/manager.py

@@ -25,6 +25,7 @@ class ConversationManager:
         self._tag_cache: Dict[str, List[Dict[str, Any]]] = {}
         self._ALL_MESSAGES_CACHE_KEY = "__all__"
         self.DEFAULT_TAG_PROMOTION_VALUE: int = 999
+        self._queue: List[Dict[str, Any]] = []
 
     @classmethod
     def get_instance(cls, coder) -> "ConversationManager":
@@ -193,6 +194,33 @@ class ConversationManager:
             self._tag_cache.pop(self._ALL_MESSAGES_CACHE_KEY, None)
             return message
 
+    def queue_message(self, **kwargs) -> None:
+        """
+        Queue an add_message() call for later insertion.
+
+        Accepts the same keyword arguments as add_message()
+        and stores them in an internal queue to be flushed
+        later via flush_queue().
+        """
+        self._queue.append(kwargs)
+
+    def flush_queue(self) -> List[Any]:
+        """
+        Flush all queued add_message() calls.
+
+        Calls add_message() for each set of kwargs in the
+        internal queue, then clears the queue.
+
+        Returns:
+            List of BaseMessage instances returned by add_message()
+        """
+        results = []
+        while self._queue:
+            kwargs = self._queue.pop(0)
+            result = self.add_message(**kwargs)
+            results.append(result)
+        return results
+
     def base_sort(self, messages: List[BaseMessage]) -> List[BaseMessage]:
         """
         Sorts messages by effective priority (promotion if mark_for_demotion has not elapsed yet), then timestamp.

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/main.py

@@ -1198,7 +1198,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
             from cecli.sessions import SessionManager
 
             session_manager = SessionManager(coder, io)
-            session_manager.load_session(
+            await session_manager.load_session(
                 args.auto_save_session_name if args.auto_save_session_name else "auto-save"
             )
         except Exception:

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/prompts/agent.yml

@@ -14,6 +14,10 @@ files_no_full_files_with_repo_map: |
   I have a repository map. I will use it to target my navigation and add relevant files to the context.
   </context>
 
+repo_content_prefix: |
+  Here are summaries of some files present in my git repository.
+  These files should be helpful for navigating the codebase.
+
 main_system: |
   <context name="role_and_directives">
   ## Core Directives
@@ -34,7 +38,7 @@ main_system: |
   uXdn::def example_method():
   WAR5::  return "example"
   vwkS::
-   </context>
+  </context>
 
   <context name="workflow_and_tool_usage">
   ## Core Workflow
@@ -60,7 +64,6 @@ system_reminder: |
   ## Operational Rules
   - **Scope**: No unrequested refactors. Edit files incrementally; avoid full-file rewrites.
   - **Hygiene**: Use `ContextManager`/`RemoveSkill` to evict unneeded files/skills immediately after use.
-  - **Preparation**: Use `GetLines` to verify hashline ranges before every edit. Capture entire functions, logical blocks and closures.
   - **Outputs**: Tool calls trigger turns. Never include tool syntax in final user summaries.
   - **Sandbox**: Perform all verification and temp logic in `.cecli/temp`.
   - **Vibe**: Zero conversational filler. Do not confirm instructions or state "I understand." Provide status updates only when you have new information.

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/repo.py

@@ -348,12 +348,28 @@ class GitRepo:
             cmd.append("--no-verify")
         if fnames:
             fnames = [str(self.abs_root_path(fn)) for fn in fnames]
+            added_fnames = []
             for fname in fnames:
                 try:
+                    # Check if file is git-ignored before trying to add
+                    if (
+                        coder
+                        and hasattr(coder, "add_gitignore_files")
+                        and coder.add_gitignore_files
+                    ):
+                        rel_fname = self.get_rel_fname(fname)
+                        if self.git_ignored_file(rel_fname):
+                            # Skip git-ignored files when add_gitignore_files is enabled
+                            continue
                     self.repo.git.add(fname)
+                    added_fnames.append(fname)
                 except ANY_GIT_ERROR as err:
                     self.io.tool_error(f"Unable to add {fname}: {err}")
-            cmd += ["--"] + fnames
+            if added_fnames:
+                cmd += ["--"] + added_fnames
+            else:
+                # No files to commit (all were git-ignored or failed to add)
+                return
         else:
             cmd += ["-a"]
 
@@ -392,6 +408,12 @@ class GitRepo:
         except (ValueError, OSError):
             return self.repo.git_dir
 
+    def get_rel_fname(self, fname):
+        try:
+            return os.path.relpath(fname, self.root)
+        except ValueError:
+            return fname
+
     async def get_commit_message(self, diffs, context, user_language=None):
         diffs = "# Diffs:\n" + diffs
 

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/sessions.py

@@ -88,7 +88,7 @@ class SessionManager:
 
         return sessions
 
-    def load_session(self, session_identifier: str) -> bool:
+    async def load_session(self, session_identifier: str) -> bool:
         """Load a saved session by name or file path."""
         if not session_identifier:
             self.io.tool_error("Please provide a session name or file path.")
@@ -112,7 +112,17 @@ class SessionManager:
             return False
 
         # Apply session data
-        return self._apply_session_data(session_data, session_file)
+        applied = await self._apply_session_data(session_data, session_file)
+        if applied:
+            from cecli.commands import SwitchCoderSignal
+
+            raise SwitchCoderSignal(
+                edit_format=self.coder.edit_format,
+                from_coder=self.coder,
+                summarize_from_coder=False,
+                show_announcements=True,
+            )
+        return applied
 
     def _build_session_data(self, session_name) -> Dict:
         """Build session data dictionary from current coder state."""
@@ -140,6 +150,39 @@ class SessionManager:
             self.io.tool_warning(f"Could not read todo list file: {e}")
 
         # Get CUR and DONE messages from ConversationManager
+        connected_mcps = []
+        if hasattr(self.coder, "mcp_manager") and self.coder.mcp_manager:
+            connected_mcps = [server.name for server in self.coder.mcp_manager.connected_servers]
+
+        # Get CUR and DONE messages from ConversationManager
+        connected_mcps = []
+        if hasattr(self.coder, "mcp_manager") and self.coder.mcp_manager:
+            connected_mcps = [server.name for server in self.coder.mcp_manager.connected_servers]
+
+        skills_data = None
+        if hasattr(self.coder, "skills_manager") and self.coder.skills_manager:
+            skills_data = {
+                "skills_paths": [str(p) for p in self.coder.skills_manager.directory_paths],
+                "skills_includelist": (
+                    list(self.coder.skills_manager.include_list)
+                    if self.coder.skills_manager.include_list is not None
+                    else []
+                ),
+                "skills_excludelist": (
+                    list(self.coder.skills_manager.exclude_list)
+                    if self.coder.skills_manager.exclude_list is not None
+                    else []
+                ),
+            }
+
+        agent_config_data = None
+        if hasattr(self.coder, "agent_config"):
+            agent_config_data = {
+                "tools_paths": self.coder.agent_config.get("tools_paths", []),
+                "tools_includelist": self.coder.agent_config.get("tools_includelist", []),
+                "tools_excludelist": self.coder.agent_config.get("tools_excludelist", []),
+            }
+
         return {
             "version": 1,
             "session_name": session_name,
@@ -168,6 +211,9 @@ class SessionManager:
                 "auto_test": self.coder.auto_test,
             },
             "todo_list": todo_content,
+            "mcps": connected_mcps,
+            "skills": skills_data,
+            "tools": agent_config_data,
         }
 
     def _find_session_file(self, session_identifier: str) -> Optional[Path]:
@@ -194,7 +240,7 @@ class SessionManager:
         self.io.tool_output("Use /list-sessions to see available sessions.")
         return None
 
-    def _apply_session_data(self, session_data: Dict, session_file: Path) -> bool:
+    async def _apply_session_data(self, session_data: Dict, session_file: Path) -> bool:
         """Apply session data to current coder state."""
         try:
             # Clear current state
@@ -303,6 +349,40 @@ class SessionManager:
             )
             self.io.tool_output(f"Loaded {num_messages} messages and {num_files} files")
 
+            # Load MCPs
+            saved_mcps = session_data.get("mcps", [])
+            if hasattr(self.coder, "mcp_manager") and self.coder.mcp_manager:
+                current_mcps = {server.name for server in self.coder.mcp_manager.connected_servers}
+                saved_mcps_set = set(saved_mcps)
+
+                to_disconnect = current_mcps - saved_mcps_set
+                for mcp_name in to_disconnect:
+                    await self.coder.mcp_manager.disconnect_server(mcp_name)
+
+                to_connect = saved_mcps_set - current_mcps
+                for mcp_name in to_connect:
+                    await self.coder.mcp_manager.connect_server(mcp_name)
+
+            # Load skills
+            skills_data = session_data.get("skills")
+            if skills_data and hasattr(self.coder, "skills_manager") and self.coder.skills_manager:
+                self.coder.skills_manager.directory_paths = skills_data.get("skills_paths", [])
+                self.coder.skills_manager.include_list = set(
+                    skills_data.get("skills_includelist", [])
+                )
+                self.coder.skills_manager.exclude_list = set(
+                    skills_data.get("skills_excludelist", [])
+                )
+
+            # Load tools config
+            agent_config_data = session_data.get("tools")
+            if agent_config_data and hasattr(self.coder, "agent_config"):
+                self.coder.agent_config.update(agent_config_data)
+                from cecli.tools.utils.registry import ToolRegistry
+
+                ToolRegistry.build_registry(agent_config=self.coder.agent_config)
+                self.coder.loaded_custom_tools = ToolRegistry.loaded_custom_tools
+
             return True
 
         except Exception as e:

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/tools/edit_text.py

@@ -56,9 +56,9 @@ class Tool(BaseTool):
                                     "type": "string",
                                     "enum": ["replace", "delete", "insert"],
                                     "description": (
-                                        "The type of operation: 'replace' (replace range with text), "
-                                        "'delete' (remove range), or 'insert' (insert text after start_line). "
-                                        "Defaults to 'replace'."
+                                        "The type of operation: 'replace' (replace range with"
+                                        " text), 'delete' (remove range), or 'insert' (insert text"
+                                        " after start_line). Defaults to 'replace'."
                                     ),
                                 },
                                 "text": {
@@ -78,8 +78,8 @@ class Tool(BaseTool):
                                 "end_line": {
                                     "type": "string",
                                     "description": (
-                                        'Hashline format for end line: "{4 char hash}" (without the '
-                                        "braces)"
+                                        'Hashline format for end line: "{4 char hash}" (without the'
+                                        " braces)"
                                     ),
                                 },
                             },
@@ -179,8 +179,8 @@ class Tool(BaseTool):
                             if operation in ("replace", "delete"):
                                 if edit_start_line is None:
                                     raise ToolError(
-                                        f"Edit {edit_index + 1}: 'start_line' parameter is required "
-                                        f"for '{operation}' operation"
+                                        f"Edit {edit_index + 1}: 'start_line' parameter is required"
+                                        f" for '{operation}' operation"
                                     )
                                 if edit_end_line is None:
                                     raise ToolError(
@@ -190,8 +190,8 @@ class Tool(BaseTool):
                             if operation == "insert":
                                 if edit_start_line is None:
                                     raise ToolError(
-                                        f"Edit {edit_index + 1}: 'start_line' parameter is required "
-                                        "for 'insert' operation"
+                                        f"Edit {edit_index + 1}: 'start_line' parameter is required"
+                                        " for 'insert' operation"
                                     )
                                 # For insert, end_line defaults to start_line
                                 edit_end_line = edit_end_line or edit_start_line

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/tools/get_lines.py

@@ -19,16 +19,17 @@ class Tool(BaseTool):
         "function": {
             "name": "GetLines",
             "description": (
-                "Get hashline prefixes of context between start and end patterns in multiple files."
-                " Accepts an array of show objects, each with file_path, start_text,"
-                " end_text, and optional padding. Special markers '@000' and '000@' can be"
-                " used for start_text and end_text to represent the first and last lines of"
-                " the file respectively. Never use hashlines as the start_text and end_text"
-                " values. These values must be lines from the content of the file."
+                "Get hashline prefixes of content between start and end patterns in files."
+                " Accepts an array of `show` objects, each with file_path, start_text,"
+                " end_text, and optional padding."
+                " These values must be lines from the content of the file."
                 " They can contain up to 3 lines but newlines should generally be avoided."
-                " Avoid using generic keywords."
+                " Avoid using generic keywords and symbols. Special markers '@000' and '000@' can be"
+                " used for start_text and end_text to represent the first and last lines of"
+                " the file respectively. Avoid using the special markers on non-empty files."
+                " Never use hashlines as the start_text and end_text values."
                 " Do not use the same pattern for the start_text and end_text."
-                " It is usually best to use function names and other block identifiers as "
+                " It is best to use function names, variable declarations and other block identifiers as "
                 " start_texts and end_texts."
             ),
             "parameters": {
@@ -47,14 +48,14 @@ class Tool(BaseTool):
                                     "type": "string",
                                     "description": (
                                         "The content marking the beginning of the context range."
-                                        " Use '@000' for the first line."
+                                        " Use '@000' for the first line on empty files."
                                     ),
                                 },
                                 "end_text": {
                                     "type": "string",
                                     "description": (
-                                        "The content marking the end of the context range. Use"
-                                        " '000@' for the last line."
+                                        "The content marking the end of the context range."
+                                        " Use '000@' for the last line on empty files."
                                     ),
                                 },
                                 "padding": {
@@ -76,6 +77,8 @@ class Tool(BaseTool):
         },
     }
 
+    _last_invocation = {}  # file_path -> {start_idx, end_idx}
+
     @classmethod
     def execute(cls, coder, show, **kwargs):
         """
@@ -172,59 +175,68 @@ class Tool(BaseTool):
                                 end_indices.append(i + len(end_pattern_lines) - 1)
 
                     if len(start_indices) > 5:
-                        raise ToolError(
-                            f"Start pattern '{start_text}' too broad. Do not search for"
-                            " it again. Be more specific."
-                        )
-
-                    # if len(end_indices) > 5:
-                    #     raise ToolError(
-                    #         f"End pattern '{end_text}' too broad. Do not search for it"
-                    #         " again. Be more specific."
-                    #     )
-
-                    best_pair = None
-                    min_dist = float("inf")
-
-                    for s in start_indices:
-                        for e in [idx for idx in end_indices if idx >= s]:
-                            dist = e - s
-                            if dist < min_dist:
-                                min_dist = dist
-                                best_pair = (s, e)
-
-                    if not start_indices:
-                        raise ToolError(
-                            f"Start pattern '{start_text}' not found in {file_path}. Do not search"
-                            " for it again."
-                        )
-
-                    if not end_indices:
-                        raise ToolError(
-                            f"End pattern '{end_text}' not found in {file_path}. Do not search for"
-                            " it again."
-                        )
-
-                    if best_pair is None:
-                        raise ToolError(
-                            f"End pattern '{end_text}' not found after start pattern in"
-                            f" {file_path}."
-                        )
+                        # Too many matches - use _last_invocation to disambiguate
+                        last = cls._last_invocation.get(abs_path)
+                        if last is None:
+                            raise ToolError(
+                                f"Start pattern '{start_text}' too broad. Do not search for"
+                                " it again. Be more specific."
+                            )
+                        # Find the best match: smallest sum of absolute distances to last start/end
+                        # that comes after the range, with tie-breaking by smallest sum
+                        last_s, last_e = last["start_idx"], last["end_idx"]
+                        candidates = []
+                        for s in start_indices:
+                            for e in [idx for idx in end_indices if idx >= s]:
+                                dist_sum = abs(s - last_s) + abs(e - last_e)
+                                candidates.append((dist_sum, s, e))
+                        # Sort by distance sum, then prefer ranges after the last range
+                        candidates.sort(key=lambda x: (x[0], x[1] < last_s, x[1], x[2]))
+                        best_pair = (candidates[0][1], candidates[0][2])
+                    else:
+                        best_pair = None
+                        min_dist = float("inf")
+
+                        for s in start_indices:
+                            for e in [idx for idx in end_indices if idx >= s]:
+                                dist = e - s
+                                if dist < min_dist:
+                                    min_dist = dist
+                                    best_pair = (s, e)
+
+                        if not start_indices:
+                            raise ToolError(
+                                f"Start pattern '{start_text}' not found in {file_path}. Do not search"
+                                " for it again."
+                            )
+
+                        if not end_indices:
+                            raise ToolError(
+                                f"End pattern '{end_text}' not found in {file_path}. Do not search for"
+                                " it again."
+                            )
+
+                        if best_pair is None:
+                            raise ToolError(
+                                f"End pattern '{end_text}' not found after start pattern in"
+                                f" {file_path}."
+                            )
                     s_idx, e_idx = best_pair
+                # Store the found indices for future disambiguation
+                cls._last_invocation[abs_path] = {"start_idx": s_idx, "end_idx": e_idx}
 
-                    found_by = f"range '{start_text}' to '{end_text}'"
-
-                    try:
-                        padding_int = int(padding)
-                        if padding_int < 0:
-                            raise ValueError()
-                    except ValueError:
-                        coder.io.tool_warning(f"Invalid padding '{padding}', using default 5.")
-                        padding_int = 5
+                found_by = f"range '{start_text}' to '{end_text}'"
 
-                    start_line_idx = max(0, s_idx - padding_int)
-                    end_line_idx = min(num_lines - 1, e_idx + padding_int)
+                try:
+                    padding_int = int(padding)
+                    if padding_int < 0:
+                        raise ValueError()
+                except ValueError:
+                    coder.io.tool_warning(f"Invalid padding '{padding}', using default 5.")
+                    padding_int = 5
 
+                start_line_idx = max(0, s_idx - padding_int)
+                end_line_idx = min(num_lines - 1, e_idx + padding_int)
                 if start_line_idx == -1 or end_line_idx == -1:
                     raise ToolError("Internal error: Could not determine line range.")
                 # 6. Format output for this operation
@@ -279,7 +291,7 @@ class Tool(BaseTool):
                 coder.io.tool_output("File contents already up to date")
                 return (
                     "File contents already up to date."
-                    "Do not call GetLines again with these parameters until you edit the file."
+                    " Do not call `GetLines` again with these parameters until you edit the file."
                 )
             else:
                 coder.io.tool_output(f"✅ Successfully retrieved context for {len(show)} file(s)")

{cecli_dev-0.99.8 → cecli_dev-0.99.9}/cecli/tools/utils/helpers.py

@@ -55,11 +55,11 @@ def validate_file_for_edit(coder, file_path):
             raise ToolError(
                 f"File '{file_path}' is read-only. Make editable with `ContextManager` first."
             )
-        else:
-            # File exists but is not in context at all
-            raise ToolError(
-                f"File '{file_path}' not in context. Make editable with `ContextManager` first."
-            )
+        # else:
+        #    # File exists but is not in context at all
+        #    raise ToolError(
+        #        f"File '{file_path}' not in context. Make editable with `ContextManager` first."
+        #    )
 
     # Reread content immediately before potential modification
     content = coder.io.read_text(abs_path)