cecli-dev 0.100.12rc5__tar.gz → 1.0.0rc2__tar.gz

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.12rc5
+Version: 1.0.0rc2
 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.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.12rc5'
-__version_tuple__ = version_tuple = (0, 100, 12, 'rc5')
+__version__ = version = '1.0.0rc2'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc2')
 
-__commit_id__ = commit_id = 'g7a6568913'
+__commit_id__ = commit_id = 'g394025597'

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/coders/agent_coder.py

@@ -98,7 +98,7 @@ class AgentCoder(Coder):
         self.skip_cli_confirmations = False
         self.agent_finished = False
         self.agent_config = self._get_agent_config()
-        self.max_sub_agents = self.agent_config.get("max_sub_agents", 3)
+        self.max_sub_agents = self.agent_config.get("max_sub_agents", 30)
         self.sub_agent_paths = self.agent_config.get("subagent_paths", [])
         self._setup_agent()
 
@@ -167,6 +167,11 @@ class AgentCoder(Coder):
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
         config["diff_colors"] = nested.getter(config, "diff_colors", True)
         config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
+        config["allow_orchestration"] = nested.getter(config, "allow_orchestration", True)
+        config["max_sub_agents"] = nested.getter(config, "max_sub_agents", 30)
+
+        if config["max_sub_agents"] == -1:
+            config["max_sub_agents"] = 2 ^ 31 - 1
 
         config["tools_paths"] = nested.getter(config, ["tools_paths", "tool_paths"], [])
         config["tools_includelist"] = nested.getter(
@@ -184,6 +189,7 @@ class AgentCoder(Coder):
         config["servers_excludelist"] = nested.getter(
             config, ["servers_excludelist", "servers_blacklist"], []
         )
+
         config["include_context_blocks"] = set(
             nested.getter(
                 config,
@@ -203,6 +209,10 @@ class AgentCoder(Coder):
         )
         config["exclude_context_blocks"] = set(nested.getter(config, "exclude_context_blocks", []))
 
+        if config["allow_orchestration"]:
+            config["include_context_blocks"].add("orchestration")
+            config["exclude_context_blocks"].discard("orchestration")
+
         self.large_file_token_threshold = config["large_file_token_threshold"]
         self.skip_cli_confirmations = config["skip_cli_confirmations"]
         self.hot_reload_enabled = config["hot_reload"]
@@ -292,6 +302,7 @@ class AgentCoder(Coder):
 
     async def _execute_mcp_tool(self, server, tool_name, params):
         """Helper to execute a single MCP tool call, created from legacy format."""
+        from cecli.tools.utils.responses import ToolResponse
 
         async def _exec_async():
             function_dict = {"name": tool_name, "arguments": json.dumps(params)}
@@ -331,9 +342,14 @@ class AgentCoder(Coder):
 
         result, interrupted = await interruptible(_exec_async(), self.interrupt_event)
 
+        response = ToolResponse(tool_name)
         if interrupted:
-            return "Tool execution interrupted by user."
-        return result
+            response.append_error("Tool execution interrupted by user.")
+        elif isinstance(result, str) and result.startswith("Error executing tool call"):
+            response.append_error(result)
+        else:
+            response.append_result(result)
+        return response
 
     def _calculate_context_block_tokens(self, force=False):
         """
@@ -364,6 +380,7 @@ class AgentCoder(Coder):
                 "servers",
                 "sub_agents",
                 "loaded_skills",
+                "orchestration",
             ]
             for block_type in block_types:
                 if block_type in self.allowed_context_blocks:
@@ -400,6 +417,8 @@ class AgentCoder(Coder):
             content = self.get_servers_context()
         elif block_name == "loaded_skills":
             content = self.get_skills_content()
+        elif block_name == "orchestration":
+            content = self.get_orchestration_context()
         elif block_name == "sub_agents" and (
             not self.parent_uuid or self.agent_config.get("allow_nested_delegation", False)
         ):
@@ -829,7 +848,7 @@ class AgentCoder(Coder):
             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.",
+                    "# Fix the linting errors below, and then continue with your task.",
                     1,
                 )
                 ConversationService.get_manager(self).add_message(
@@ -878,7 +897,7 @@ class AgentCoder(Coder):
                 {
                     "role": "tool",
                     "tool_call_id": tool_call.id,
-                    "content": result,
+                    "content": str(result),
                 }
             )
         return tool_responses
@@ -1582,6 +1601,23 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
             self.io.tool_error(f"Error generating servers context: {str(e)}")
             return None
 
+    def get_orchestration_context(self):
+        """
+        Generate a context block for the Orchestrate tool if allowed.
+
+        Only returns content if ``allow_orchestration`` is enabled in the agent config.
+        """
+        if not self.use_enhanced_context:
+            return None
+
+        try:
+            from cecli.helpers.orchestration import build_orchestration_context_block
+
+            return build_orchestration_context_block(self.agent_config)
+        except Exception as e:
+            self.io.tool_error(f"Error generating orchestration context: {str(e)}")
+            return None
+
     def get_sub_agents_context(self):
         """
         Generate a context block for registered sub-agents.

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/coders/base_coder.py

@@ -1733,7 +1733,27 @@ class Coder(metaclass=UsageMeta):
                 # Compacting is wasteful since /clear will clear everything
                 # and /exit will exit the application
                 stripped = user_message.strip()
-                if stripped not in ("/clear", "/reset", "/exit", "/quit"):
+                is_command = self.commands.is_command(stripped)
+                is_allowed_command = False
+
+                if is_command:
+                    res = self.commands.matching_commands(user_message)
+                    if res is not None:
+                        matching_commands, first_word, rest_inp = res
+                        if len(matching_commands) == 1:
+                            command = matching_commands[0]
+                            splits = (rest_inp or "").split()
+                            split_map = {
+                                "/agent": 1,
+                                "/architect": 1,
+                                "/ask": 1,
+                                "/code": 1,
+                                "/model": 2,
+                            }
+                            if command in split_map and len(splits) >= split_map.get(command, 0):
+                                is_allowed_command = True
+
+                if not is_command or is_allowed_command:
                     self.compact_context_completed = False
                     await self.compact_context_if_needed()
                     self.compact_context_completed = True
@@ -1977,27 +1997,34 @@ class Coder(metaclass=UsageMeta):
         done_messages = manager.get_messages_dict(MessageTag.DONE)
         cur_messages = manager.get_messages_dict(MessageTag.CUR)
         diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+        file_context_messages = manager.get_messages_dict(MessageTag.FILE_CONTEXTS)
         all_messages = manager.get_messages_dict()
 
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
         diff_tokens = self.summarizer.count_tokens(diff_messages)
+        file_context_tokens = self.summarizer.count_tokens(file_context_messages)
         all_tokens = self.summarizer.count_tokens(all_messages)
 
-        combined_tokens = done_tokens + cur_tokens + diff_tokens
+        message_tokens = done_tokens + cur_tokens
+        file_tokens = diff_tokens + file_context_tokens
+        combined_tokens = done_tokens + cur_tokens + diff_tokens + file_context_tokens
 
         self.context_compaction_current_ratio = all_tokens / self.context_compaction_max_tokens
 
         if force or (
             all_tokens >= self.context_compaction_max_tokens * 0.9
             and ConversationService.get_chunks(self).last_clear_count > 20
+            and file_tokens / max(message_tokens, 1) > 2
         ):
             manager.clear_tag(MessageTag.LINT, ratio=0.33)
             manager.clear_tag(MessageTag.DIFFS, ratio=0.33)
             manager.clear_tag(MessageTag.FILE_CONTEXTS, ratio=0.33)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
+            ConversationService.get_chunks(self).reset_clear_count()
+            ObservationService.get_instance(self).reset_index()
 
         if not force and combined_tokens < self.context_compaction_max_tokens:
             return
@@ -2031,9 +2058,9 @@ class Coder(metaclass=UsageMeta):
                 manager.clear_tag(tag)
 
                 if tag == MessageTag.DONE:
-                    manager.add_message({"role": "user", "content": text}, tag=tag)
-                    manager.add_message(
-                        {
+                    manager.queue_message(message_dict={"role": "user", "content": text}, tag=tag)
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": (
                                 "Ok, I will use this summary and the observations as context for"
@@ -2044,12 +2071,13 @@ class Coder(metaclass=UsageMeta):
                     )
                 else:
                     if self.last_user_message:
-                        manager.add_message(
-                            {"role": "user", "content": self.last_user_message}, tag=tag
+                        manager.queue_message(
+                            message_dict={"role": "user", "content": self.last_user_message},
+                            tag=tag,
                         )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": "Ok. I am awaiting your summary of our goals to proceed.",
                         },
@@ -2057,8 +2085,8 @@ class Coder(metaclass=UsageMeta):
                         force=True,
                     )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "user",
                             "content": (
                                 "Here is a summary of our current goals and historical"
@@ -2068,8 +2096,8 @@ class Coder(metaclass=UsageMeta):
                         tag=tag,
                     )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": (
                                 "Ok, I will use this summary and proceed with our task. I will"
@@ -2102,6 +2130,9 @@ class Coder(metaclass=UsageMeta):
             manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
+            ConversationService.get_chunks(self).reset_clear_count()
+            ObservationService.get_instance(self).reset_index()
+            self.format_chat_chunks()
 
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
@@ -4208,9 +4239,12 @@ class Coder(metaclass=UsageMeta):
         if tokens < warn_number_of_tokens:
             return
 
-        self.io.tool_warning("Warning: it's best to only add files that need changes to the chat.")
-        self.io.tool_warning(urls.edit_errors)
-        self.warning_given = True
+        if self.context_compaction_current_ratio > 0.5:
+            self.io.tool_warning(
+                "Warning: it's best to only add files that need changes to the chat."
+            )
+            self.io.tool_warning(urls.edit_errors)
+            self.warning_given = True
 
     async def prepare_to_edit(self, edits):
         res = []

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/commands/__init__.py

@@ -5,6 +5,8 @@ This package contains individual command implementations that follow the
 BaseCommand pattern for modular, testable command execution.
 """
 
+from cecli.signals import ReloadProgramSignal, SwitchCoderSignal
+
 from .add import AddCommand
 from .agent import AgentCommand
 from .agent_model import AgentModelCommand
@@ -20,7 +22,7 @@ from .context_blocks import ContextBlocksCommand
 from .context_management import ContextManagementCommand
 from .copy import CopyCommand
 from .copy_context import CopyContextCommand
-from .core import Commands, ReloadProgramSignal, SwitchCoderSignal
+from .core import Commands
 from .diff import DiffCommand
 from .drop import DropCommand
 from .editor import EditCommand, EditorCommand

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/commands/core.py

@@ -8,49 +8,7 @@ from cecli.commands.utils.registry import CommandRegistry
 from cecli.helpers import nested, plugin_manager
 from cecli.helpers.file_searcher import handle_core_files
 from cecli.helpers.threading import ThreadSafeEvent
-from cecli.repo import ANY_GIT_ERROR
-
-
-class SwitchCoderSignal(BaseException):
-    """
-     Signal to switch the current Coder instance to a new configuration.
-
-     This is NOT an error - it's a control flow signal used to propagate
-     coder switching requests up through the async call stack. It carries
-     the kwargs needed to create a new Coder instance.
-
-     Note: Inherits from BaseException (like KeyboardInterrupt and SystemExit)
-    to avoid being caught by generic `except Exception` handlers, making the
-     non-error nature of this signal explicit.
-
-     Attributes:
-         kwargs: Configuration dict passed to Coder.create() for the new instance
-         placeholder: Optional placeholder text for the input prompt
-    """
-
-    def __init__(self, placeholder=None, **kwargs):
-        self.kwargs = kwargs
-        self.placeholder = placeholder
-        super().__init__()
-
-
-class ReloadProgramSignal(BaseException):
-    """
-    Signal to reload the entire program configuration.
-
-    This is NOT an error - it's a control flow signal used to trigger
-    a full program reload, re-parsing config files and re-initializing
-    all components. Useful for hot-reloading when configuration files
-    change.
-
-    Note: Inherits from BaseException (like KeyboardInterrupt and SystemExit)
-    to avoid being caught by generic `except Exception` handlers.
-    """
-
-    def __init__(self, message="Reloading program configuration...", **kwargs):
-        self.kwargs = kwargs
-        self.message = message
-        super().__init__(self.message)
+from cecli.signals import SwitchCoderSignal
 
 
 class Commands:
@@ -215,6 +173,8 @@ class Commands:
         return sorted(commands)
 
     async def execute(self, cmd_name, args, coder=None, **kwargs):
+        from cecli.repo import ANY_GIT_ERROR
+
         active_coder = coder or self.coder
         command_class = CommandRegistry.get_command(cmd_name)
 

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/commands/hot_reload.py

@@ -1,7 +1,7 @@
 from typing import List
 
-from cecli.commands.core import ReloadProgramSignal
 from cecli.commands.utils.base_command import BaseCommand
+from cecli.signals import ReloadProgramSignal
 
 
 class HotReloadCommand(BaseCommand):

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/helpers/agents/service.py

@@ -228,7 +228,7 @@ class AgentService:
     @property
     def max_sub_agents(self) -> int:
         """Return the max number of sub-agents allowed for this coder."""
-        return getattr(self.coder, "max_sub_agents", 3)
+        return getattr(self.coder, "max_sub_agents", 30)
 
     # ------------------------------------------------------------------ #
     # Internal helpers
@@ -495,7 +495,7 @@ class AgentService:
             )
 
         new_coder = await Coder.create(**kwargs)
-        new_coder.max_sub_agents = getattr(self.coder, "max_sub_agents", 3)
+        new_coder.max_sub_agents = getattr(self.coder, "max_sub_agents", 30)
         # IOProxy wrapping is handled by base_coder.py's Coder.__init__
 
         # Re-acquire the lock to register — we must re-check max agents since

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/helpers/conversation/files.py

@@ -116,9 +116,7 @@ class ConversationFiles:
                 try:
                     content = coder.io.read_text(abs_fname, silent=True)
                     if coder.hashlines:
-                        content, json_str = hashline_formatted(
-                            content, file_name=abs_fname, partial=False, expanded=False
-                        )
+                        content, json_str = hashline_formatted(content, file_name=abs_fname)
                         self._file_json_contents[abs_fname] = json_str
                 except Exception:
                     content = ""  # Empty content for unreadable files
@@ -236,9 +234,7 @@ class ConversationFiles:
         try:
             current_content = coder.io.read_text(abs_fname, silent=True)
             if coder.hashlines:
-                current_content, _ = hashline_formatted(
-                    current_content, file_name=abs_fname, partial=False, expanded=False
-                )
+                current_content, _ = hashline_formatted(current_content, file_name=abs_fname)
         except Exception:
             return None
 
@@ -607,12 +603,30 @@ class ConversationFiles:
             ):
                 continue
 
-            _, json_str = hashline_formatted(
-                range_content,
+            # Hash the full content first so that adjacent-line hashes
+            # are computed with proper surrounding context from the complete
+            # file, then extract only the range's lines. This ensures content
+            # IDs are consistent with other tools (e.g., ReadFile) that hash
+            # the full file content.
+            full_prefixed, _ = hashline_formatted(
+                content,
                 file_name=abs_fname,
-                partial=True,
-                expanded=False,
-                start_line=start_line_adj,
+                total_lines=len(content_lines),
+                start_line=1,
+            )
+            prefixed_lines = full_prefixed.splitlines()
+            range_prefixed_lines = prefixed_lines[start_line_adj - 1 : end_line_adj]
+            range_prefixed_content = "\n".join(range_prefixed_lines)
+
+            json_str = json.dumps(
+                {
+                    "file_name": abs_fname,
+                    "start_line": start_line_adj,
+                    "end_line": end_line_adj,
+                    "total_lines": len(content_lines),
+                    "prefixed_contents": range_prefixed_content,
+                },
+                ensure_ascii=False,
             )
             results.append(json.loads(json_str))
 

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/helpers/conversation/integration.py

@@ -245,62 +245,7 @@ class ConversationChunks:
         if not coder:
             return
 
-        # Check diff message ratio and clear if too many diffs
-        diff_messages = ConversationService.get_manager(coder).get_messages_dict(MessageTag.DIFFS)
-        read_only_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.READONLY_FILES
-        )
-        chat_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.CHAT_FILES
-        )
-        edit_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.EDIT_FILES
-        )
-
-        # Calculate token counts for token-based ratio check
-        diff_tokens = coder.main_model.token_count(diff_messages) if diff_messages else 0
-
-        # Calculate tokens for readonly, chat, and edit tag messages
-        other_tokens = 0
-        if read_only_messages:
-            other_tokens += coder.main_model.token_count(read_only_messages)
-        if chat_messages:
-            other_tokens += coder.main_model.token_count(chat_messages)
-        if edit_messages:
-            other_tokens += coder.main_model.token_count(edit_messages)
-
-        # Calculate message counts for message-based ratio check
-        diff_count = len(diff_messages)
-        other_count = len(read_only_messages) + len(chat_messages) + len(edit_messages)
-
-        # Clear diff messages and file caches if EITHER:
-        # 1. Diff tokens > 33% of other message tokens (token-based check)
-        # 2. Diff message count ratio > 5:1 (message count-based check for periodic refresh)
-        should_clear = False
-
-        # Token-based check
-        if diff_tokens > 0 and other_tokens > 0 and diff_tokens / other_tokens > 0.5:
-            should_clear = True
-
-        # Message count-based check (for periodic refresh)
-        if diff_count > 0 and other_count > 0 and diff_count / other_count > 20:
-            should_clear = True
-
         self.last_clear_count += 1
-
-        if (
-            should_clear
-            and coder.context_compaction_current_ratio > 0.8
-            and self.last_clear_count >= 20
-            and diff_tokens + other_tokens > coder.context_compaction_max_tokens * 0.5
-        ):
-            self.last_clear_count = 0
-
-            # Clear all diff messages
-            ConversationService.get_manager(coder).clear_tag(MessageTag.DIFFS, 0.33)
-            # Clear ConversationFiles caches to force regeneration
-            ConversationService.get_files(coder).clear_file_cache(clear_contexts=False)
-
         # Get all tracked files (both regular and image files)
         tracked_files = ConversationService.get_files(coder).get_all_tracked_files()
 
@@ -483,7 +428,7 @@ class ConversationChunks:
         repo_messages = ConversationService.get_manager(coder).get_messages_dict(MessageTag.REPO)
         if len(repo_messages) >= 20:
             # Clear all REPO tagged messages
-            ConversationService.get_manager(coder).clear_tag(MessageTag.REPO)
+            ConversationService.get_manager(coder).clear_tag(MessageTag.REPO, ratio=0.33)
             # Clear the combined repomap dict to force fresh regeneration
             if (
                 hasattr(coder, "repo_map")
@@ -864,6 +809,10 @@ class ConversationChunks:
                 block = coder._generate_context_block("servers")
                 if block:
                     message_blocks["servers"] = block
+            if "orchestration" in coder.allowed_context_blocks:
+                block = coder._generate_context_block("orchestration")
+                if block:
+                    message_blocks["orchestration"] = block
 
         # Add static blocks to conversation manager with stable hash keys
         for block_type, block_content in message_blocks.items():
@@ -1017,6 +966,9 @@ class ConversationChunks:
     def flush_removals(self):
         self._deferred_removals.clear()
 
+    def reset_clear_count(self):
+        self.last_clear_count = 0
+
     def _cancel_post_message_injections(self, modulus=10):
         coder = self.get_coder()
         if not coder:

{cecli_dev-0.100.12rc5 → cecli_dev-1.0.0rc2}/cecli/helpers/grep_ast/grep_ast.py

@@ -214,17 +214,24 @@ class TreeContext:
             # reset
             output += "\033[0m\n"
 
-        dots = not (0 in self.show_lines)
+        # dots = not (0 in self.show_lines)
+        in_gap = False
+        gap_start = -1
         for i, line in enumerate(self.lines):
             if i not in self.show_lines:
-                if dots:
-                    if self.line_number:
-                        output += "...⋮...\n"
-                    else:
-                        output += "⋮\n"
-                    dots = False
+                if not in_gap:
+                    in_gap = True
+                    gap_start = i
                 continue
 
+            if in_gap:
+                omitted = i - gap_start
+                if self.line_number:
+                    output += f"...⋮... [{omitted} lines omitted (L{gap_start + 1}–L{i})]\n"
+                else:
+                    output += f"⋮ [{omitted} lines omitted]\n"
+                in_gap = False
+
             if i in self.lines_of_interest and self.mark_lois:
                 spacer = "█"
                 if self.color:
@@ -237,7 +244,7 @@ class TreeContext:
                 line_output = f"{i + 1: 3}" + line_output
             output += line_output + "\n"
 
-            dots = True
+            # dots = True
 
         return output