cecli-dev 0.100.0rc5__tar.gz → 0.100.0rc8__tar.gz

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.0rc5'
-__version_tuple__ = version_tuple = (0, 100, 0, 'rc5')
+__version__ = version = '0.100.0rc8'
+__version_tuple__ = version_tuple = (0, 100, 0, 'rc8')
 
-__commit_id__ = commit_id = 'g5e5d5ba3d'
+__commit_id__ = commit_id = 'g4af9ad954'

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/coders/agent_coder.py

@@ -154,6 +154,7 @@ class AgentCoder(Coder):
         )
         config["command_timeout"] = nested.getter(config, "command_timeout", 30)
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
+        config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
 
         config["tools_paths"] = nested.getter(config, ["tools_paths", "tool_paths"], [])
         config["tools_includelist"] = nested.getter(
@@ -350,6 +351,7 @@ class AgentCoder(Coder):
                 "git_status",
                 "symbol_outline",
                 "skills",
+                "sub_agents",
                 "loaded_skills",
             ]
             for block_type in block_types:
@@ -385,7 +387,9 @@ class AgentCoder(Coder):
             content = self.get_skills_context()
         elif block_name == "loaded_skills":
             content = self.get_skills_content()
-        elif block_name == "sub_agents":
+        elif block_name == "sub_agents" and (
+            not self.parent_uuid or self.agent_config.get("allow_nested_delegation", False)
+        ):
             content = self.get_sub_agents_context()
         if content is not None:
             self.context_blocks_cache[block_name] = content
@@ -795,7 +799,13 @@ class AgentCoder(Coder):
 
         if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
-            lint_errors = self.lint_edited(edited, show_output=False)
+            lint_coro = self.lint_edited(edited, show_output=False)
+            lint_errors, interrupted = await self.coroutines.interruptible(
+                lint_coro, self.interrupt_event
+            )
+            if interrupted:
+                raise KeyboardInterrupt("Interrupted during linting")
+
             self.lint_outcome = not lint_errors
 
             if lint_errors:
@@ -898,7 +908,12 @@ class AgentCoder(Coder):
                 " its outputs are no longer necessary"
             )
             self.io.tool_output(waiting_msg)
-            await asyncio.sleep(command_timeout / 2)
+            sleep_coro = asyncio.sleep(command_timeout / 2)
+            _res, interrupted = await self.coroutines.interruptible(
+                sleep_coro, self.interrupt_event
+            )
+            if interrupted:
+                raise KeyboardInterrupt("Interrupted while waiting for background commands")
             return True
 
         # Check for recently finished commands that need reflection

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/coders/base_coder.py

@@ -61,7 +61,7 @@ from cecli.reasoning_tags import (
 from cecli.repo import ANY_GIT_ERROR, GitRepo
 from cecli.repomap import RepoMap
 from cecli.report import update_error_prefix
-from cecli.run_cmd import run_cmd
+from cecli.run_cmd import run_cmd_async
 from cecli.sessions import SessionManager
 from cecli.tools.utils.output import print_tool_response
 from cecli.tools.utils.registry import ToolRegistry
@@ -105,7 +105,83 @@ all_fences = [
 ]
 
 
-class Coder:
+class UsageMeta(type):
+    """Metaclass that provides shared accumulator properties across all Coder subclasses.
+    Every instance shares the same unified total token and cost amounts."""
+
+    _total_cost = 0
+    _total_tokens_sent = 0
+    _total_tokens_received = 0
+    _total_cached_tokens = 0
+
+    @property
+    def total_cost(cls):
+        return UsageMeta._total_cost
+
+    @total_cost.setter
+    def total_cost(cls, value):
+        UsageMeta._total_cost = value
+
+    @property
+    def total_tokens_sent(cls):
+        return UsageMeta._total_tokens_sent
+
+    @total_tokens_sent.setter
+    def total_tokens_sent(cls, value):
+        UsageMeta._total_tokens_sent = value
+
+    @property
+    def total_tokens_received(cls):
+        return UsageMeta._total_tokens_received
+
+    @total_tokens_received.setter
+    def total_tokens_received(cls, value):
+        UsageMeta._total_tokens_received = value
+
+    @property
+    def total_cached_tokens(cls):
+        return UsageMeta._total_cached_tokens
+
+    @total_cached_tokens.setter
+    def total_cached_tokens(cls, value):
+        UsageMeta._total_cached_tokens = value
+
+
+class Coder(metaclass=UsageMeta):
+
+    # Instance-level properties that delegate to the shared metaclass storage
+    @property
+    def total_cost(self):
+        return type(self).total_cost
+
+    @total_cost.setter
+    def total_cost(self, value):
+        type(self).total_cost = value
+
+    @property
+    def total_tokens_sent(self):
+        return type(self).total_tokens_sent
+
+    @total_tokens_sent.setter
+    def total_tokens_sent(self, value):
+        type(self).total_tokens_sent = value
+
+    @property
+    def total_tokens_received(self):
+        return type(self).total_tokens_received
+
+    @total_tokens_received.setter
+    def total_tokens_received(self, value):
+        type(self).total_tokens_received = value
+
+    @property
+    def total_cached_tokens(self):
+        return type(self).total_cached_tokens
+
+    @total_cached_tokens.setter
+    def total_cached_tokens(self, value):
+        type(self).total_cached_tokens = value
+
     abs_fnames = None
     abs_read_only_fnames = None
     abs_read_only_stubs_fnames = None
@@ -141,9 +217,6 @@ class Coder:
     partial_response_consolidated = None
     commit_before_message = []
     message_cost = 0.0
-    total_tokens_sent = 0
-    total_tokens_received = 0
-    total_cached_tokens = 0
     message_tokens_sent = 0
     message_tokens_received = 0
     message_cached_tokens = 0
@@ -205,8 +278,8 @@ class Coder:
                 main_model = models.Model(models.DEFAULT_MODEL_NAME, io=io)
 
         if edit_format == "code":
-            edit_format = None
-        if edit_format is None:
+            edit_format = main_model.edit_format
+        elif edit_format is None:
             if from_coder:
                 edit_format = from_coder.edit_format
             else:
@@ -232,11 +305,7 @@ class Coder:
                 cur_messages=[],
                 coder_commit_hashes=from_coder.coder_commit_hashes,
                 commands=from_coder.commands.clone(),
-                total_cost=from_coder.total_cost,
                 ignore_mentions=from_coder.ignore_mentions,
-                total_tokens_sent=from_coder.total_tokens_sent,
-                total_tokens_received=from_coder.total_tokens_received,
-                total_cached_tokens=from_coder.total_cached_tokens,
                 file_watcher=from_coder.file_watcher,
                 mcp_manager=from_coder.mcp_manager,
                 uuid=from_coder.uuid,
@@ -263,12 +332,18 @@ class Coder:
 
         if res is not None:
             if from_coder:
-                if from_coder.mcp_manager:
-                    res.mcp_manager = from_coder.mcp_manager
-
-                # Transfer TUI app weak reference
-                res.tui = from_coder.tui
-                res.context_management_enabled = from_coder.context_management_enabled
+                # Preserve TUI ref in all child coders
+                if from_coder.tui:
+                    res.tui = from_coder.tui
+
+                if res.mcp_manager:
+                    # When switching to a non-agent coder, disconnect the "Local" MCP server
+                    # (which provides agent-only tools like tool calling and file editing)
+                    # so it's not available in non-agent modes.
+                    if not isinstance(res, coders.AgentCoder):
+                        local_server = res.mcp_manager.get_server("Local")
+                        if local_server and local_server.is_connected:
+                            await res.mcp_manager.disconnect_server("Local")
 
             await res.initialize_mcp_tools()
 
@@ -316,7 +391,6 @@ class Coder:
         map_max_line_length=100,
         commands=None,
         summarizer=None,
-        total_cost=0.0,
         map_refresh="auto",
         cache_prompts=False,
         num_cache_warming_pings=0,
@@ -325,9 +399,6 @@ class Coder:
         commit_language=None,
         detect_urls=True,
         ignore_mentions=None,
-        total_tokens_sent=0,
-        total_tokens_received=0,
-        total_cached_tokens=0,
         file_watcher=None,
         auto_copy_context=False,
         auto_accept_architect=True,
@@ -407,10 +478,6 @@ class Coder:
         self.chat_completion_response_hashes = []
         self.need_commit_before_edits = set()
 
-        self.total_cost = total_cost
-        self.total_tokens_sent = total_tokens_sent
-        self.total_tokens_received = total_tokens_received
-        self.total_cached_tokens = total_cached_tokens
         self.message_tokens_sent = 0
         self.message_tokens_received = 0
         self.message_cached_tokens = 0
@@ -600,7 +667,9 @@ class Coder:
         self.files_edited_by_tools = set()
 
         # Linting and testing
-        self.linter = Linter(root=self.root, encoding=io.encoding)
+        self.linter = Linter(
+            root=self.root, encoding=io.encoding, interrupt_event=self.interrupt_event
+        )
         self.auto_lint = auto_lint
         self.setup_lint_cmds(lint_cmds)
         self.lint_cmds = lint_cmds
@@ -2224,6 +2293,10 @@ class Coder:
 
         ConversationService.get_manager(self).flush_queue()
 
+        # Clear any stale interrupt state before starting formatting
+        # to avoid immediately re-catching a previous interrupt
+        self.interrupt_event.clear()
+
         if inp:
             # Make sure current coder actually has control of conversation system
             ConversationService.get_chunks(self).initialize_conversation_system()
@@ -2242,7 +2315,22 @@ class Coder:
         import asyncio
 
         loop = asyncio.get_running_loop()
-        result = await loop.run_in_executor(None, self.format_messages)
+
+        async def format_in_executor():
+            return await loop.run_in_executor(None, self.format_messages)
+
+        result, interrupted = await self.coroutines.interruptible(
+            format_in_executor(), self.interrupt_event
+        )
+
+        if interrupted:
+            # Use CancelledError instead of KeyboardInterrupt to avoid
+            # propagating through the asyncio event loop during cleanup.
+            # KeyboardInterrupt is re-raised by Task.__step and bypasses
+            # asyncio.gather(return_exceptions=True), causing crashes
+            # when tasks are gathered during _cleanup_loop.
+            raise asyncio.CancelledError("Interrupted during message formatting")
+
         messages = result
 
         if not await self.check_tokens(messages):
@@ -2451,7 +2539,10 @@ class Coder:
             return
 
         if edited and self.auto_lint:
-            lint_errors = self.lint_edited(edited)
+            lint_errors = await self.lint_edited(edited)
+            if lint_errors is None:  # Interrupted
+                return
+
             await self.auto_commit(edited, context="Ran the linter")
             self.lint_outcome = not lint_errors
             if lint_errors:
@@ -2952,12 +3043,16 @@ class Coder:
         self.io.tool_error(res)
         await self.io.offer_url(urls.token_limits)
 
-    def lint_edited(self, fnames, show_output=True):
+    async def lint_edited(self, fnames, show_output=True):
         res = ""
         for fname in fnames:
             if not fname:
                 continue
-            errors = self.linter.lint(self.abs_root_path(fname))
+            try:
+                errors = await self.linter.lint(self.abs_root_path(fname))
+            except asyncio.CancelledError:
+                self.io.tool_warning("Linting interrupted.")
+                return None
 
             if errors:
                 res += "\n"
@@ -3276,122 +3371,127 @@ class Coder:
         received_content = False
         chunk_index = 0
 
-        async for chunk in completion:
-            if self.args.debug:
-                with open(".cecli/logs/chunks.log", "a") as f:
-                    print(chunk, file=f)
+        try:
+            async for chunk in coroutines.interruptible_async_generator(
+                completion, self.interrupt_event
+            ):
+                if self.args.debug:
+                    with open(".cecli/logs/chunks.log", "a") as f:
+                        print(chunk, file=f)
 
-            # Check if confirmation is in progress and wait if needed
-            if not self.io.confirmation_in_progress_event.is_set():
-                await self.io.confirmation_in_progress_event.wait()
+                # Check if confirmation is in progress and wait if needed
+                if not self.io.confirmation_in_progress_event.is_set():
+                    await self.io.confirmation_in_progress_event.wait()
 
-            if isinstance(chunk, str):
-                self.io.tool_error(chunk)
-                continue
-            else:
-                if len(chunk.choices) == 0:
+                if isinstance(chunk, str):
+                    self.io.tool_error(chunk)
                     continue
+                else:
+                    if len(chunk.choices) == 0:
+                        continue
 
-                if (
-                    hasattr(chunk.choices[0], "finish_reason")
-                    and chunk.choices[0].finish_reason == "length"
-                ):
-                    raise FinishReasonLength()
+                    if (
+                        hasattr(chunk.choices[0], "finish_reason")
+                        and chunk.choices[0].finish_reason == "length"
+                    ):
+                        raise FinishReasonLength()
 
-                try:
-                    if chunk.choices[0].delta.tool_calls:
-                        received_content = True
-                        self.token_profiler.on_token()
-                        for tool_call_chunk in chunk.choices[0].delta.tool_calls:
-                            self.tool_reflection = True
+                    try:
+                        if chunk.choices[0].delta.tool_calls:
+                            received_content = True
+                            self.token_profiler.on_token()
+                            for tool_call_chunk in chunk.choices[0].delta.tool_calls:
+                                self.tool_reflection = True
 
-                            if tool_call_chunk.type:
-                                self.io.update_spinner_suffix(tool_call_chunk.type)
+                                if tool_call_chunk.type:
+                                    self.io.update_spinner_suffix(tool_call_chunk.type)
 
-                            if tool_call_chunk.function:
-                                if tool_call_chunk.function.name:
-                                    self.io.update_spinner_suffix(tool_call_chunk.function.name)
+                                if tool_call_chunk.function:
+                                    if tool_call_chunk.function.name:
+                                        self.io.update_spinner_suffix(tool_call_chunk.function.name)
 
-                                if tool_call_chunk.function.arguments:
-                                    self.io.update_spinner_suffix(
-                                        tool_call_chunk.function.arguments
-                                    )
+                                    if tool_call_chunk.function.arguments:
+                                        self.io.update_spinner_suffix(
+                                            tool_call_chunk.function.arguments
+                                        )
 
-                except (AttributeError, IndexError):
-                    # Handle cases where the response structure doesn't match expectations
-                    pass
+                    except (AttributeError, IndexError):
+                        # Handle cases where the response structure doesn't match expectations
+                        pass
 
-                try:
-                    func = chunk.choices[0].delta.function_call
-                    # dump(func)
-                    if func:
-                        for k, v in func.items():
-                            self.tool_reflection = True
-                            self.io.update_spinner_suffix(v)
-
-                        received_content = True
-                        self.token_profiler.on_token()
-                except AttributeError:
-                    pass
-
-                text = ""
-
-                try:
-                    reasoning_content = chunk.choices[0].delta.reasoning_content
-                except AttributeError:
                     try:
-                        reasoning_content = chunk.choices[0].delta.reasoning
+                        func = chunk.choices[0].delta.function_call
+                        # dump(func)
+                        if func:
+                            for k, v in func.items():
+                                self.tool_reflection = True
+                                self.io.update_spinner_suffix(v)
+
+                            received_content = True
+                            self.token_profiler.on_token()
                     except AttributeError:
-                        reasoning_content = None
+                        pass
 
-                if reasoning_content:
-                    if nested.getter(self.args, "show_thinking"):
-                        if not self.got_reasoning_content:
-                            text += f"<{REASONING_TAG}>\n\n"
-                        text += reasoning_content
-                        self.got_reasoning_content = True
-                        received_content = True
-                    self.token_profiler.on_token()
-                    self.io.update_spinner_suffix(reasoning_content)
-                    self.partial_response_reasoning_content += reasoning_content
+                    text = ""
 
-                try:
-                    content = chunk.choices[0].delta.content
-                    if content:
-                        if self.got_reasoning_content and not self.ended_reasoning_content:
-                            text += f"\n\n</{self.reasoning_tag_name}>\n\n"
-                            self.ended_reasoning_content = True
-
-                        text += content
-                        received_content = True
+                    try:
+                        reasoning_content = chunk.choices[0].delta.reasoning_content
+                    except AttributeError:
+                        try:
+                            reasoning_content = chunk.choices[0].delta.reasoning
+                        except AttributeError:
+                            reasoning_content = None
+
+                    if reasoning_content:
+                        if nested.getter(self.args, "show_thinking"):
+                            if not self.got_reasoning_content:
+                                text += f"<{REASONING_TAG}>\n\n"
+                            text += reasoning_content
+                            self.got_reasoning_content = True
+                            received_content = True
                         self.token_profiler.on_token()
-                        self.io.update_spinner_suffix(content)
-                except AttributeError:
-                    pass
+                        self.io.update_spinner_suffix(reasoning_content)
+                        self.partial_response_reasoning_content += reasoning_content
 
-            self.partial_response_content += text
+                    try:
+                        content = chunk.choices[0].delta.content
+                        if content:
+                            if self.got_reasoning_content and not self.ended_reasoning_content:
+                                text += f"\n\n</{self.reasoning_tag_name}>\n\n"
+                                self.ended_reasoning_content = True
+
+                            text += content
+                            received_content = True
+                            self.token_profiler.on_token()
+                            self.io.update_spinner_suffix(content)
+                    except AttributeError:
+                        pass
 
-            chunk_index += 1
-            chunk._hidden_params["created_at"] = chunk_index
-            self.partial_response_chunks.append(chunk)
+                self.partial_response_content += text
 
-            if self.show_pretty():
-                # Use simplified streaming - just call the method with full content
-                content_to_show = self.live_incremental_response(False)
-                self.stream_wrapper(content_to_show, final=False)
-            elif text:
-                # Apply reasoning tag formatting for non-pretty output
-                if nested.getter(self.args, "show_thinking"):
-                    text = replace_reasoning_tags(text, self.reasoning_tag_name)
-                try:
-                    self.stream_wrapper(text, final=False)
-                except UnicodeEncodeError:
-                    # Safely encode and decode the text
-                    safe_text = text.encode(sys.stdout.encoding, errors="backslashreplace").decode(
-                        sys.stdout.encoding
-                    )
-                    self.stream_wrapper(safe_text, final=False)
-                yield text
+                chunk_index += 1
+                chunk._hidden_params["created_at"] = chunk_index
+                self.partial_response_chunks.append(chunk)
+
+                if self.show_pretty():
+                    # Use simplified streaming - just call the method with full content
+                    content_to_show = self.live_incremental_response(False)
+                    self.stream_wrapper(content_to_show, final=False)
+                elif text:
+                    # Apply reasoning tag formatting for non-pretty output
+                    if nested.getter(self.args, "show_thinking"):
+                        text = replace_reasoning_tags(text, self.reasoning_tag_name)
+                    try:
+                        self.stream_wrapper(text, final=False)
+                    except UnicodeEncodeError:
+                        # Safely encode and decode the text
+                        safe_text = text.encode(
+                            sys.stdout.encoding, errors="backslashreplace"
+                        ).decode(sys.stdout.encoding)
+                        self.stream_wrapper(safe_text, final=False)
+                    yield text
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            raise KeyboardInterrupt
 
         # The Part Doing the Heavy Lifting Now
         self.consolidate_chunks()
@@ -3650,7 +3750,7 @@ class Coder:
         total_stats += " ↑↓"
 
         if not self.get_active_model().info.get("input_cost_per_token"):
-            self.usage_report = tokens_report + "\n" + total_stats
+            self.usage_report = tokens_report + " " + total_stats
             return
 
         try:
@@ -3673,7 +3773,7 @@ class Coder:
         )
 
         if cache_hit_tokens and cache_write_tokens:
-            sep = "\n"
+            sep = " "
         else:
             sep = " "
 
@@ -4226,8 +4326,10 @@ class Coder:
             self.io.tool_output(f"Running {command}")
             # Add the command to input history
             # self.io.add_to_input_history(f"/run {command.strip()}")
-            exit_status, output = await asyncio.to_thread(
-                run_cmd, command, error_print=self.io.tool_error, cwd=self.root
+            exit_status, output = await run_cmd_async(
+                command,
+                self.interrupt_event,
+                cwd=self.root,
             )
 
             if output:

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/coders/sub_agent_coder.py

@@ -19,4 +19,5 @@ class SubAgentCoder(AgentCoder):
 
     def post_init(self):
         super().post_init()
-        self.registered_tools["excluded"].add("delegate")
+        if not self.agent_config.get("allow_nested_delegation", False):
+            self.registered_tools["excluded"].add("delegate")

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/commands/lint.py

@@ -43,7 +43,7 @@ class LintCommand(BaseCommand):
         lint_coder = None
         for fname in fnames:
             try:
-                errors = coder.linter.lint(fname)
+                errors = await coder.linter.lint(fname)
             except FileNotFoundError as err:
                 io.tool_error(f"Unable to lint {fname}")
                 io.tool_output(str(err))

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/commands/run.py

@@ -1,11 +1,10 @@
-import asyncio
 from typing import List
 
 import cecli.prompts.utils.system as prompts
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
 from cecli.helpers.conversation import ConversationService, MessageTag
-from cecli.run_cmd import run_cmd
+from cecli.run_cmd import run_cmd_async
 
 
 class RunCommand(BaseCommand):
@@ -22,11 +21,10 @@ class RunCommand(BaseCommand):
         if coder.args.tui:
             should_print = False
 
-        exit_status, combined_output = await asyncio.to_thread(
-            run_cmd,
+        exit_status, combined_output = await run_cmd_async(
             args,
+            coder.interrupt_event,
             verbose=coder.args.verbose if hasattr(coder.args, "verbose") else False,
-            error_print=io.tool_error,
             cwd=coder.root,
             should_print=should_print,
         )

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/commands/spawn_agent.py

@@ -20,7 +20,9 @@ class SpawnAgentCommand(BaseCommand):
         try:
             agent_service = AgentService.get_instance(coder)
             await agent_service.spawn(name)
-            io.tool_output(f"Sub-agent '{name}' spawned. " "Switch to it with Ctrl+Alt+Right.")
+            if coder.tui and coder.tui():
+                switch_key = coder.tui().get_keys_for("next_agent")
+                io.tool_output(f"Sub-agent '{name}' spawned. " f"Switch to it with {switch_key}")
         except ValueError as e:
             io.tool_error(f"Error: {e}")
         except RuntimeError as e:

{cecli_dev-0.100.0rc5 → cecli_dev-0.100.0rc8}/cecli/helpers/conversation/integration.py

@@ -891,7 +891,7 @@ class ConversationChunks:
                 block = coder.get_cached_context_block("directory_structure")
                 if block:
                     message_blocks["directory_structure"] = block
-            if "sub_agents" in coder.allowed_context_blocks and not coder.parent_uuid:
+            if "sub_agents" in coder.allowed_context_blocks:
                 block = coder._generate_context_block("sub_agents")
                 if block:
                     message_blocks["sub_agents"] = block