cecli-dev 0.99.10__tar.gz → 0.99.11__tar.gz

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.10
+Version: 0.99.11
 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.10 → cecli_dev-0.99.11}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.10'
-__version_tuple__ = version_tuple = (0, 99, 10)
+__version__ = version = '0.99.11'
+__version_tuple__ = version_tuple = (0, 99, 11)
 
-__commit_id__ = commit_id = 'gdd5ec67da'
+__commit_id__ = commit_id = 'g2e5e3b75c'

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/coders/agent_coder.py

@@ -145,7 +145,7 @@ class AgentCoder(Coder):
                     "context_summary",
                     # "directory_structure",
                     "environment_info",
-                    "git_status",
+                    # "git_status",
                     # "symbol_outline",
                     "todo_list",
                     "skills",
@@ -246,132 +246,6 @@ class AgentCoder(Coder):
         else:
             await self.mcp_manager.connect_server(server_name)
 
-    async def _execute_local_tool_calls(self, tool_calls_list):
-        tool_responses = []
-        used_write_tool = False
-
-        for tool_call in tool_calls_list:
-            tool_name = tool_call.function.name
-            result_message = ""
-            try:
-                if responses.unprefix_tool_name(tool_name)[1].lower() in self.write_tools:
-                    used_write_tool = True
-
-                args_string = tool_call.function.arguments.strip()
-                parsed_args_list = []
-
-                if not await HookIntegration.call_pre_tool_hooks(self, tool_name, args_string):
-                    tool_responses.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tool_call.id,
-                            "content": "Tool Request Aborted.",
-                        }
-                    )
-                    continue
-
-                if args_string:
-                    json_chunks = utils.split_concatenated_json(args_string)
-                    for chunk in json_chunks:
-                        try:
-                            parsed_args_list.append(json.loads(chunk))
-                        except json.JSONDecodeError as e:
-                            self.model_kwargs = {}
-                            self.io.tool_warning(
-                                f"Malformed JSON arguments in tool {tool_name}: {chunk}"
-                            )
-                            tool_responses.append(
-                                {
-                                    "role": "tool",
-                                    "tool_call_id": tool_call.id,
-                                    "content": (
-                                        f"Malformed JSON arguments in tool {tool_name}: {str(e)}"
-                                    ),
-                                }
-                            )
-                            continue
-                if not parsed_args_list and not args_string:
-                    parsed_args_list.append({})
-                all_results_content = []
-                norm_tool_name = tool_name.lower()
-                tasks = []
-                if norm_tool_name in ToolRegistry.get_registered_tools():
-                    tool_module = ToolRegistry.get_tool(norm_tool_name)
-                    for params in parsed_args_list:
-                        result = tool_module.process_response(self, params)
-                        if asyncio.iscoroutine(result):
-                            tasks.append(result)
-                        else:
-                            tasks.append(asyncio.to_thread(lambda: result))
-                else:
-                    all_results_content.append(f"Error: Unknown tool name '{tool_name}'")
-                if tasks:
-
-                    async def gather_and_await():
-                        return await asyncio.gather(*tasks, return_exceptions=True)
-
-                    task_results, interrupted = await interruptible(
-                        gather_and_await(), self.interrupt_event
-                    )
-
-                    if interrupted:
-                        self.io.tool_warning("Tool execution interrupted.")
-                        all_results_content.append("Tool execution interrupted by user.")
-                    elif task_results:
-                        for res in task_results:
-                            if isinstance(res, Exception):
-                                all_results_content.append(f"Error in tool execution: {res}")
-                            else:
-                                all_results_content.append(str(res))
-
-                if not await HookIntegration.call_post_tool_hooks(
-                    self, tool_name, args_string, "\n\n".join(all_results_content)
-                ):
-                    tool_responses.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tool_call.id,
-                            "content": "Tool Response Redacted.",
-                        }
-                    )
-                    continue
-
-                result_message = "\n\n".join(all_results_content)
-            except Exception as e:
-                self.model_kwargs = {}
-                result_message = f"Error executing {tool_name}: {e}"
-                self.io.tool_error(f"""Error during {tool_name} execution: {e}
-{traceback.format_exc()}""")
-            tool_responses.append(
-                {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
-            )
-
-        if self.auto_lint and used_write_tool:
-            edited = list(self.files_edited_by_tools)
-            lint_errors = self.lint_edited(edited, show_output=False)
-            self.lint_outcome = not lint_errors
-
-            if lint_errors:
-                lint_errors = lint_errors.replace(
-                    "# Fix any linting errors below, if possible.",
-                    "# Fix any linting errors below, if possible and then continue with your task.",
-                    1,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict=dict(role="user", content=lint_errors),
-                    tag=MessageTag.CUR,
-                    hash_key=("lint_errors", "agent"),
-                    promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
-                    mark_for_demotion=1,
-                    force=True,
-                )
-            else:
-                ConversationService.get_manager(self).remove_message_by_hash_key(
-                    ("lint_errors", "agent")
-                )
-
-        return tool_responses
-
     async def _execute_mcp_tool(self, server, tool_name, params):
         """Helper to execute a single MCP tool call, created from legacy format."""
 
@@ -408,9 +282,9 @@ class AgentCoder(Coder):
                             content_parts.append(item.text)
                 return "".join(content_parts)
             except Exception as e:
-                self.io.tool_warning(f"""Executing {tool_name} on {server.name} failed:
-  Error: {e}
-""")
+                self.io.tool_warning(
+                    (f"Executing {tool_name} on {server.name} failed:\nError: {e}")
+                )
                 return f"Error executing tool call {tool_name}: {e}"
 
         result, interrupted = await interruptible(_exec_async(), self.interrupt_event)
@@ -507,9 +381,8 @@ class AgentCoder(Coder):
         try:
             result = '<context name="symbol_outline" from="agent">\n'
             result += "## Symbol Outline (Current Context)\n\n"
-            result += """Code definitions (classes, functions, methods, etc.) found in files currently in chat context.
-
-"""
+            result += "Code definitions (classes, functions, methods, etc.) found in files currently in chat context."
+            result += "\n\n"
             files_to_outline = list(self.abs_fnames) + list(self.abs_read_only_fnames)
             if not files_to_outline:
                 result += "No files currently in context.\n"
@@ -649,9 +522,7 @@ class AgentCoder(Coder):
                         )
                 if editable_files:
                     result += "\n".join(editable_files) + "\n\n"
-                    result += f"""**Total editable: {len(editable_files)} files, {editable_tokens:,} tokens**
-
-"""
+                    result += f"**Total editable: {len(editable_files)} files, {editable_tokens:,} tokens**\n\n"
                 else:
                     result += "No editable files in context\n\n"
             if self.abs_read_only_fnames:
@@ -671,9 +542,7 @@ class AgentCoder(Coder):
                         )
                 if readonly_files:
                     result += "\n".join(readonly_files) + "\n\n"
-                    result += f"""**Total read-only: {len(readonly_files)} files, {readonly_tokens:,} tokens**
-
-"""
+                    result += f"**Total read-only: {len(readonly_files)} files, {readonly_tokens:,} tokens**\n\n"
                 else:
                     result += "No read-only files in context\n\n"
             extra_tokens = sum(self.context_block_tokens.values())
@@ -765,9 +634,133 @@ class AgentCoder(Coder):
         # Ensure we call base implementation to trigger execution of all tools (native + extracted)
         return await super().process_tool_calls(tool_call_response)
 
-    async def _execute_local_tools(self, tool_calls):
+    async def _execute_local_tools(self, tool_calls_list):
         """Execute local tools via ToolRegistry."""
-        return await self._execute_local_tool_calls(tool_calls)
+        tool_responses = []
+        used_write_tool = False
+
+        for tool_call in tool_calls_list:
+            tool_name = tool_call.function.name
+            result_message = ""
+            try:
+                if responses.unprefix_tool_name(tool_name)[1].lower() in self.write_tools:
+                    used_write_tool = True
+
+                args_string = tool_call.function.arguments.strip()
+                parsed_args_list = []
+
+                if not await HookIntegration.call_pre_tool_hooks(self, tool_name, args_string):
+                    tool_responses.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "content": "Tool Request Aborted.",
+                        }
+                    )
+                    continue
+
+                if args_string:
+                    json_chunks = utils.split_concatenated_json(args_string)
+                    for chunk in json_chunks:
+                        try:
+                            parsed_args_list.append(json.loads(chunk))
+                        except json.JSONDecodeError as e:
+                            self.model_kwargs = {}
+                            self.io.tool_warning(
+                                f"Malformed JSON arguments in tool {tool_name}: {chunk}"
+                            )
+                            tool_responses.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tool_call.id,
+                                    "content": (
+                                        f"Malformed JSON arguments in tool {tool_name}: {str(e)}"
+                                    ),
+                                }
+                            )
+                            continue
+                if not parsed_args_list and not args_string:
+                    parsed_args_list.append({})
+                all_results_content = []
+                norm_tool_name = tool_name.lower()
+                tasks = []
+                if norm_tool_name in ToolRegistry.get_registered_tools():
+                    tool_module = ToolRegistry.get_tool(norm_tool_name)
+                    for params in parsed_args_list:
+                        result = tool_module.process_response(self, params)
+                        if asyncio.iscoroutine(result):
+                            tasks.append(result)
+                        else:
+                            tasks.append(asyncio.to_thread(lambda: result))
+                else:
+                    all_results_content.append(f"Error: Unknown tool name '{tool_name}'")
+                if tasks:
+
+                    async def gather_and_await():
+                        return await asyncio.gather(*tasks, return_exceptions=True)
+
+                    task_results, interrupted = await interruptible(
+                        gather_and_await(), self.interrupt_event
+                    )
+
+                    if interrupted:
+                        self.io.tool_warning("Tool execution interrupted.")
+                        all_results_content.append("Tool execution interrupted by user.")
+                    elif task_results:
+                        for res in task_results:
+                            if isinstance(res, Exception):
+                                all_results_content.append(f"Error in tool execution: {res}")
+                            else:
+                                all_results_content.append(str(res))
+
+                if not await HookIntegration.call_post_tool_hooks(
+                    self, tool_name, args_string, "\n\n".join(all_results_content)
+                ):
+                    tool_responses.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "content": "Tool Response Redacted.",
+                        }
+                    )
+                    continue
+
+                result_message = "\n\n".join(all_results_content)
+            except Exception as e:
+                self.model_kwargs = {}
+                result_message = f"Error executing {tool_name}: {e}"
+                self.io.tool_error(
+                    (f"Error during {tool_name} execution: {e}\n{traceback.format_exc()}")
+                )
+            tool_responses.append(
+                {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
+            )
+
+        if self.auto_lint and used_write_tool:
+            edited = list(self.files_edited_by_tools)
+            lint_errors = self.lint_edited(edited, show_output=False)
+            self.lint_outcome = not lint_errors
+
+            if lint_errors:
+                lint_errors = lint_errors.replace(
+                    "# Fix any linting errors below, if possible.",
+                    "# Fix any linting errors below, if possible and then continue with your task.",
+                    1,
+                )
+                ConversationService.get_manager(self).add_message(
+                    message_dict=dict(role="user", content=lint_errors),
+                    tag=MessageTag.CUR,
+                    hash_key=("lint_errors", "agent"),
+                    promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
+                    mark_for_demotion=1,
+                    force=True,
+                )
+            else:
+                ConversationService.get_manager(self).remove_message_by_hash_key(
+                    ("lint_errors", "agent")
+                )
+
+        return tool_responses
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
@@ -860,6 +853,12 @@ class AgentCoder(Coder):
                 self.tool_usage_history = []
             return True
 
+        if content and not tool_calls_found and self.num_reflections < self.max_reflections:
+            self.reflected_message = (
+                "Continue with your task. If you have completed it, call the `Finished` tool."
+            )
+            return True
+
         if tool_calls_found and self.num_reflections < self.max_reflections:
             self.tool_call_count = 0
             self.files_added_in_exploration = set()
@@ -877,8 +876,9 @@ class AgentCoder(Coder):
                 "I have processed the results of the previous tool calls. Let me analyze them"
                 " and continue working towards your request."
             )
-            next_prompt_parts.append("""
-I will proceed based on the tool results and updated context.""")
+            next_prompt_parts.append(
+                "\nI will proceed based on the tool results and updated context."
+            )
             next_prompt_parts.append(f"\nYour original question was: {original_question}")
             self.reflected_message = "\n".join(next_prompt_parts)
             self.io.tool_output("Continuing exploration...")
@@ -1019,8 +1019,8 @@ I will proceed based on the tool results and updated context.""")
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled.Use `ReadRange` to determine the"
-                " current hashline prefixes needed to perform an edit and activate them when you"
+                "File editing tools are currently disabled. Use `ReadRange` to determine the"
+                " current content hash prefixes needed to perform an edit and activate them when you"
                 " are ready to edit a file."
             )
 

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/coders/base_coder.py

@@ -1612,6 +1612,7 @@ class Coder:
             return
 
         if not self.commands.is_command(user_message):
+            ConversationService.get_chunks(self).flush_removals()
             self.last_user_message = user_message
 
         while True:
@@ -1865,6 +1866,7 @@ class Coder:
             manager.clear_tag(MessageTag.DIFFS)
             manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
+            ConversationService.get_chunks(self).flush_removals()
 
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/coders/hashline_coder.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from cecli import utils
 from cecli.coders.base_coder import Coder
 from cecli.helpers.hashline import (
-    HashlineError,
+    ContentHashError,
     apply_hashline_operations,
     strip_hashline,
 )
@@ -141,7 +141,7 @@ class HashLineCoder(Coder):
                     self.io.write_text(full_path, new_content)
                 passed.append((path, operations, "Batch hashline operations"))
 
-            except (ValueError, HashlineError) as e:
+            except (ValueError, ContentHashError) as e:
                 # Record failure
                 failed.append((path, operations, f"Hashline batch operation failed: {e}"))
                 continue

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/commands/drop.py

@@ -16,6 +16,10 @@ class DropCommand(BaseCommand):
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
+        from cecli.helpers.conversation import ConversationService
+
+        ConversationService.get_chunks(coder).flush_removals()
+
         try:
             if not args.strip():
                 if kwargs.get("original_read_only_fnames"):

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/commands/reset.py

@@ -11,6 +11,8 @@ class ResetCommand(BaseCommand):
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
+        ConversationService.get_chunks(coder).flush_removals()
+
         try:
             # Drop all files
             cls._drop_all_files(io, coder, kwargs.get("original_read_only_fnames"))

{cecli_dev-0.99.10 → cecli_dev-0.99.11}/cecli/helpers/conversation/files.py

@@ -3,6 +3,8 @@ import weakref
 from typing import Any, Dict, List, Optional, Tuple
 from uuid import UUID
 
+import xxhash
+
 from cecli.helpers.hashline import get_hashline_content_diff, hashline
 from cecli.repomap import RepoMap
 
@@ -25,9 +27,11 @@ class ConversationFiles:
         self._file_contents_snapshot: Dict[str, str] = {}
         self._file_timestamps: Dict[str, float] = {}
         self._file_diffs: Dict[str, str] = {}
+        self._file_stub_contents: Dict[str, str] = {}
         self._file_to_message_id: Dict[str, str] = {}
         self._image_files: Dict[str, bool] = {}
         self._numbered_contexts: Dict[str, List[Tuple[int, int]]] = {}
+        self._last_merged_ranges: Dict[str, List[Tuple[int, int]]] = {}
         self._initialized = True
 
     @classmethod
@@ -153,8 +157,13 @@ class ConversationFiles:
         if content_length <= large_file_token_threshold:
             return content
 
-        # Use RepoMap to generate file stub
-        return RepoMap.get_file_stub(fname, coder.io, line_numbers=True)
+        # Use RepoMap to generate file stub (with read-through cache)
+        if abs_fname not in self._file_stub_contents:
+            self._file_stub_contents[abs_fname] = RepoMap.get_file_stub(
+                fname, coder.io, line_numbers=True
+            )
+
+        return self._file_stub_contents[abs_fname]
 
     def has_file_changed(self, fname: str) -> bool:
         """
@@ -250,6 +259,7 @@ class ConversationFiles:
                 rel_fname = coder.get_rel_fname(fname)
 
             # Add diff message to conversation
+            content_hash = xxhash.xxh3_128_hexdigest(diff.encode("utf-8"))
             diff_message = {
                 "role": "user",
                 "content": (
@@ -258,11 +268,21 @@ class ConversationFiles:
                 ),
             }
 
+            assistant_msg = {
+                "role": "assistant",
+                "content": f"Thank you for sharing this diff of the updates to {rel_fname}.",
+            }
+
             ConversationService.get_manager(coder).add_message(
                 message_dict=diff_message,
                 tag=MessageTag.DIFFS,
-                # promotion=ConversationService.get_manager(coder).DEFAULT_TAG_PROMOTION_VALUE,
-                # mark_for_demotion=1,
+                hash_key=("file_diff_user", rel_fname, content_hash),
+            )
+
+            ConversationService.get_manager(coder).add_message(
+                message_dict=assistant_msg,
+                tag=MessageTag.DIFFS,
+                hash_key=("file_diff_assistant", rel_fname, content_hash),
             )
 
         return diff
@@ -298,7 +318,7 @@ class ConversationFiles:
 
         return content or ""
 
-    def clear_file_cache(self, fname: Optional[str] = None) -> None:
+    def clear_file_cache(self, fname: Optional[str] = None, clear_contexts=True) -> None:
         """
         Clear cache for specific file or all files.
 
@@ -310,17 +330,21 @@ class ConversationFiles:
             self._file_contents_snapshot.clear()
             self._file_timestamps.clear()
             self._file_diffs.clear()
+            self._file_stub_contents.clear()
             self._file_to_message_id.clear()
-            self._numbered_contexts.clear()
+            if clear_contexts:
+                self._numbered_contexts.clear()
         else:
             abs_fname = os.path.abspath(fname)
             self._file_contents_original.pop(abs_fname, None)
             self._file_contents_snapshot.pop(abs_fname, None)
             self._file_timestamps.pop(abs_fname, None)
             self._file_diffs.pop(abs_fname, None)
+            self._file_stub_contents.pop(abs_fname, None)
             self._file_to_message_id.pop(abs_fname, None)
             self._image_files.pop(abs_fname, None)
-            self._numbered_contexts.pop(abs_fname, None)
+            if clear_contexts:
+                self._numbered_contexts.pop(abs_fname, None)
 
     def add_image_file(self, fname: str) -> None:
         """
@@ -355,7 +379,7 @@ class ConversationFiles:
 
     def update_file_context(
         self, file_path: str, start_line: int, end_line: int, auto_remove=True
-    ) -> None:
+    ) -> Tuple[int, int]:
         """
         Update numbered contexts for a file with a new range.
 
@@ -363,6 +387,9 @@ class ConversationFiles:
             file_path: Absolute file path
             start_line: Start line number (1-based)
             end_line: End line number (1-based)
+
+        Returns:
+            The merged range (start_line, end_line) that contains the input range.
         """
         abs_fname = os.path.abspath(file_path)
 
@@ -388,8 +415,9 @@ class ConversationFiles:
             else:
                 last_start, last_end = merged_ranges[-1]
 
-                # Check if ranges overlap or are close (within 20 lines)
-                if current_start <= last_end + 20:  # Overlap or close
+                # Check if new range overlaps/contains with the last range
+                # (since sorted by start, this means current_start is between last_start and last_end)
+                if current_start <= last_end:  # Overlap or adjacent
                     # Extend the range
                     merged_ranges[-1][1] = max(last_end, current_end)
                 else:
@@ -404,7 +432,46 @@ class ConversationFiles:
         if coder and auto_remove:
             self.remove_file_messages(abs_fname)
 
-    def get_file_context(self, file_path: str) -> str:
+        # Find the merged range that contains the input range
+        for merged_start, merged_end in self._numbered_contexts[abs_fname]:
+            if merged_start <= start_line and merged_end >= end_line:
+                return (merged_start, merged_end)
+
+        return (start_line, end_line)  # fallback
+
+    def push_range(self, file_path: str, ranges: List[Tuple[int, int]]) -> None:
+        """
+        Push merged ranges into the _last_merged_ranges cache for a file.
+
+        Args:
+            file_path: Absolute file path
+            ranges: List of (start_line, end_line) tuples, as returned by
+                update_file_context()
+        """
+        abs_fname = os.path.abspath(file_path)
+        if abs_fname not in self._last_merged_ranges:
+            self._last_merged_ranges[abs_fname] = []
+        self._last_merged_ranges[abs_fname].extend(ranges)
+        # Deduplicate and sort by start_line
+        self._last_merged_ranges[abs_fname] = sorted(
+            set(self._last_merged_ranges[abs_fname]),
+            key=lambda x: x[0],
+        )
+
+    def clear_ranges(self, file_path: Optional[str] = None) -> None:
+        """
+        Clear the _last_merged_ranges cache for a specific file or all files.
+
+        Args:
+            file_path: Optional absolute file path (None = clear all)
+        """
+        if file_path is None:
+            self._last_merged_ranges.clear()
+        else:
+            abs_fname = os.path.abspath(file_path)
+            self._last_merged_ranges.pop(abs_fname, None)
+
+    def get_file_context(self, file_path: str, all_ranges=False) -> str:
         """
         Generate hashline representation of cached context ranges.
 
@@ -416,8 +483,14 @@ class ConversationFiles:
         """
         abs_fname = os.path.abspath(file_path)
 
-        # Get cached ranges
-        ranges = self._numbered_contexts.get(abs_fname, [])
+        # Get cached ranges - prefer _last_merged_ranges over full _numbered_contexts
+        ranges = self._last_merged_ranges.get(abs_fname, []) or self._numbered_contexts.get(
+            abs_fname, []
+        )
+
+        if all_ranges:
+            ranges = self._numbered_contexts.get(abs_fname, [])
+
         if not ranges:
             return ""
 
@@ -516,6 +589,7 @@ class ConversationFiles:
         """Clear all file caches and reset to initial state."""
         self.clear_file_cache()
         self.clear_all_numbered_contexts()
+        self.clear_ranges()
         self._initialized = False
 
     def debug_print_cache(self) -> None: