cecli-dev 1.8.1rc3__tar.gz → 1.10.0rc1__tar.gz

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.1rc3
+Version: 1.10.0rc1
 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-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/__init__.py

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

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.1rc3'
-__version_tuple__ = version_tuple = (1, 8, 1, 'rc3')
+__version__ = version = '1.10.0rc1'
+__version_tuple__ = version_tuple = (1, 10, 0, 'rc1')
 
-__commit_id__ = commit_id = 'gb07a9f6ad'
+__commit_id__ = commit_id = 'gd9504b4c3'

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/args.py

@@ -31,6 +31,7 @@ DEEP_MERGE_LIST_FIELDS: frozenset[str] = frozenset(
         "file",
         "read",
         "mcp_servers_files",
+        "acp_models",
         "set_env",
         "api_key",
         "alias",
@@ -252,7 +253,7 @@ def get_parser(default_config_files, git_root):
         metavar="EDIT_FORMAT",
         choices=edit_format_choices,
         default=None,
-        help="Specify what edit format the LLM should use (default depends on model)",
+        help="Specify what edit format the LLM should use (default: agent)",
     )
     group.add_argument(
         "--ask",
@@ -1313,6 +1314,24 @@ def get_parser(default_config_files, git_root):
         help="Specify server configuration (WebSocket and headless) as a JSON/YAML string",
         default=None,
     )
+    group.add_argument(
+        "--acp",
+        action="store_true",
+        default=False,
+        help=(
+            "Run as an Agent Client Protocol (ACP) agent over stdio, for editors such as Zed"
+            " (stdout carries the protocol)"
+        ),
+    )
+    group.add_argument(
+        "--acp-models",
+        action="append",
+        metavar="PATTERN",
+        help=(
+            "Limit the ACP model picker's provider lists to models matching this pattern,"
+            " matched like /models (can be used multiple times)"
+        ),
+    )
 
     ##########
     group = parser.add_argument_group("Deprecated model settings")

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/coders/agent_coder.py

@@ -842,6 +842,7 @@ class AgentCoder(Coder):
         for tool_call in tool_calls_list:
             tool_name = tool_call.function.name
             result_message = ""
+            self.io.tool_call_event(tool_call.id, "in_progress")
             try:
                 if responses.unprefix_tool_name(tool_name)[1].lower() in self.write_tools:
                     used_write_tool = True

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/coders/base_coder.py

@@ -291,8 +291,8 @@ class Coder(metaclass=UsageMeta):
     commit_language = None
     file_watcher = None
     mcp_manager = None
-    run_one_completed = True
     compact_context_completed = True
+    _drain_queue_after_command = False
     suppress_announcements_for_next_prompt = False
     tool_reflection = False
     last_user_message = ""
@@ -684,6 +684,8 @@ class Coder(metaclass=UsageMeta):
         self._queue_counter = 0
         self._queue_lock = threading.Lock()
         self._processing_queue = False
+        self._active_queue_prompt = None
+        self._drain_queue_after_command = False
 
         self.data_cache = {
             "repo": {"last_key": "", "read_only_count": None},
@@ -996,12 +998,12 @@ class Coder(metaclass=UsageMeta):
             settings_items.append(f"reasoning {reasoning_effort}")
 
         # Prompt cache
-        if self.add_cache_headers or main_model.caches_by_default:
-            settings_items.append("prompt cache")
+        # if self.add_cache_headers or main_model.caches_by_default:
+        #   settings_items.append("prompt cache")
 
         # Infinite output
-        if main_model.info.get("supports_assistant_prefill") and self.verbose:
-            settings_items.append("infinite output")
+        # if main_model.info.get("supports_assistant_prefill") and self.verbose:
+        #    settings_items.append("infinite output")
 
         # Copy/paste mode
         if self.copy_paste_mode:
@@ -1031,10 +1033,6 @@ class Coder(metaclass=UsageMeta):
                 refresh = self.repo_map.refresh
                 env_items.append(f"map ({map_tokens} tokens, {refresh} refresh)")
                 repo_map_tokens = map_tokens
-            else:
-                env_items.append("repo-map disabled")
-        else:
-            env_items.append("repo-map disabled")
 
         sections["Environment"] = {"items": env_items}
         # --- CAPABILITIES ---
@@ -1074,7 +1072,7 @@ class Coder(metaclass=UsageMeta):
             if mcp_servers:
                 capabilities["Servers"] = mcp_servers
 
-        if capabilities:
+        if capabilities and not getattr(self.args, "tui", False):
             # sections["Extensions"] = {"subsections": capabilities}
             sections["Environment"]["subsections"] = capabilities
 
@@ -1627,6 +1625,10 @@ class Coder(metaclass=UsageMeta):
         async for chunk in self.send_message(user_message):
             yield chunk
 
+        # Stream-driven interfaces bypass run_one(), so drain the queue here
+        # to keep queued prompts processing after the request completes.
+        await self.process_prompt_queue()
+
     def init_before_message(self):
         self.coder_edited_files = set()
         self.reflected_message = None
@@ -1946,14 +1948,12 @@ class Coder(metaclass=UsageMeta):
                     await self.compact_context_if_needed()
                     self.compact_context_completed = True
 
-            self.run_one_completed = False
             await self.run_one(user_message, preproc)
             self.show_undo_hint()
         except asyncio.CancelledError:
             # Don't show undo hint if cancelled
             raise
         finally:
-            self.run_one_completed = True
             self.compact_context_completed = True
             self.io.stop_spinner()
             # Trim memory in the background so it doesn't stall the event loop
@@ -2013,9 +2013,6 @@ class Coder(metaclass=UsageMeta):
             try:
                 return await self.commands.run(inp, coder=self, **run_kwargs)
             finally:
-                # Dispatch can return early (unknown/ambiguous command) or
-                # raise without ever running a command; the gate must still be
-                # reopened or the input/output loops park forever.
                 self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
@@ -2026,6 +2023,67 @@ class Coder(metaclass=UsageMeta):
     def wrap_user_input(self, inp):
         return inp
 
+    async def process_prompt_queue(self, preproc=True):
+        """Drain the coder's prompt queue in FIFO order.
+
+        Re-entrant calls return immediately. Each item is activated before it
+        runs so an interrupt can put it back at the front of the queue, and
+        failures are isolated so one prompt does not abort the rest.
+        """
+        if self._processing_queue:
+            return
+
+        def warn_paused():
+            remaining = command_queue.get_queue_length(self)
+            self.io.tool_warning(
+                f"Queue processing interrupted. {remaining} prompt(s) remain"
+                " queued; use /run-queue to resume."
+            )
+
+        from cecli.helpers.agents.service import AgentService
+
+        self._processing_queue = True
+        try:
+            while True:
+                item = command_queue.dequeue_for_processing(self)
+                if item is None:
+                    break
+
+                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
+                try:
+                    await self.generate(item["text"], preproc)
+                    interrupt_event = getattr(self, "interrupt_event", None)
+                    if interrupt_event is not None and interrupt_event.is_set() is True:
+                        command_queue.requeue_active_prompt(self)
+                        warn_paused()
+                        break
+                except (asyncio.CancelledError, KeyboardInterrupt):
+                    command_queue.requeue_active_prompt(self)
+                    warn_paused()
+                    raise
+                except SwitchCoderSignal as switch:
+                    if not getattr(self, "parent_uuid", ""):
+                        raise
+
+                    service = AgentService.get_instance(self)
+                    info = service.sub_agents.get(self.uuid)
+                    if info is None:
+                        raise
+
+                    await service.switch_sub_agent_coder(info, switch, preproc)
+                    return
+                except SystemExit:
+                    raise
+                except Exception as e:
+                    command_queue.clear_active_prompt(self)
+                    self.io.tool_error(f"Error processing queued prompt (id: {item['id']}): {e}")
+                    continue
+
+                command_queue.clear_active_prompt(self)
+        finally:
+            self._drain_queue_after_command = False
+            command_queue.finish_processing(self)
+
     async def run_one(self, user_message, preproc):
         self.init_before_message()
 
@@ -2041,6 +2099,9 @@ class Coder(metaclass=UsageMeta):
         if self.commands.is_command(user_message) and not self.commands.is_test_command(
             user_message
         ):
+            if self._processing_queue or self._drain_queue_after_command:
+                self._drain_queue_after_command = False
+                await self.process_prompt_queue(preproc)
             return
 
         if not self.commands.is_command(user_message):
@@ -2112,19 +2173,10 @@ class Coder(metaclass=UsageMeta):
 
             await self.auto_save_session(force=True)
 
-        # Move to the next queued prompt (CLI-33) only after the current message
-        # has fully completed, so the queue drains within run_one() instead of
+        # Drain any queued prompts (CLI-33) only after the current message has
+        # fully completed, so the queue is processed within run_one() instead of
         # being watched by the generation loops.
-        if self.prompt_queue and not self._processing_queue:
-            self._processing_queue = True
-            try:
-                item = command_queue.dequeue_prompt(self)
-            finally:
-                self._processing_queue = False
-
-            if item is not None:
-                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
-                await self.run_one(item["text"], preproc)
+        await self.process_prompt_queue(preproc)
 
         if not await HookIntegration.call_end_hooks(self):
             self.io.tool_warning("Execution stopped by end hook")
@@ -3284,6 +3336,7 @@ class Coder(metaclass=UsageMeta):
                     continue
 
                 tool_id_set.add(tool_call.id)
+                self.io.tool_call_event(tool_call.id, "in_progress")
 
                 try:
                     # Arguments can be a stream of JSON objects.
@@ -3490,6 +3543,11 @@ class Coder(metaclass=UsageMeta):
         for server, server_responses in tool_responses_by_server.items():
             for tool_response in server_responses:
                 tool_responses.append(tool_response)
+                self.io.tool_call_event(
+                    tool_response["tool_call_id"],
+                    "completed",
+                    result=tool_response.get("content"),
+                )
 
                 ConversationService.get_manager(self).add_message(
                     message_dict=tool_response,
@@ -3507,6 +3565,12 @@ class Coder(metaclass=UsageMeta):
 
         for server, tool_calls in server_tool_calls.items():
             for tool_call in tool_calls:
+                self.io.tool_call_event(
+                    tool_call.id,
+                    "pending",
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                )
                 try:
                     if ToolRegistry.get_tool(tool_call.function.name.lower()):
                         ToolRegistry.get_tool(tool_call.function.name.lower()).format_output(
@@ -4828,7 +4892,7 @@ class Coder(metaclass=UsageMeta):
         if self.tui and self.tui():
             self.tui().update_cost(self.usage_report.replace("\n", " "))
         else:
-            self.io.tool_output(self.usage_report)
+            self.io.tool_output(self.usage_report, type="usage-report")
             self.io.rule()
 
         self.message_cost = 0.0

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/__init__.py

@@ -73,6 +73,7 @@ from .report import ReportCommand
 from .reset import ResetCommand
 from .rules import RulesCommand
 from .run import RunCommand
+from .run_queue import RunQueueCommand
 from .save import SaveCommand
 from .save_session import SaveSessionCommand
 from .search_memory import SearchMemoryCommand
@@ -169,6 +170,7 @@ CommandRegistry.register(ReportCommand)
 CommandRegistry.register(ResetCommand)
 CommandRegistry.register(RulesCommand)
 CommandRegistry.register(RunCommand)
+CommandRegistry.register(RunQueueCommand)
 CommandRegistry.register(SaveCommand)
 CommandRegistry.register(SaveSessionCommand)
 CommandRegistry.register(SearchMemoryCommand)
@@ -265,6 +267,7 @@ __all__ = [
     "ResetCommand",
     "RulesCommand",
     "RunCommand",
+    "RunQueueCommand",
     "SaveCommand",
     "SaveSessionCommand",
     "SearchMemoryCommand",

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/core.py

@@ -14,6 +14,9 @@ from cecli.signals import SwitchCoderSignal
 class Commands:
     scraper = None
 
+    # Commands that receive their full argument text for nested completion.
+    FULL_ARGS_COMPLETION_COMMANDS = ("/queue", "/insert-queue")
+
     def _get_coder(self):
         """Return coder via weak reference, or None if collected."""
         if self._coder_ref is not None:
@@ -90,7 +93,7 @@ class Commands:
         self.last_command_show_notification = True
 
         # Commands that should NOT trigger auto-processing of the queue
-        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue"}
+        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue", "run-queue"}
 
     def _load_custom_commands(self, custom_commands):
         """

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/insert_queue.py

@@ -60,6 +60,7 @@ class InsertQueueCommand(BaseCommand):
         try:
             item = command_queue.insert_prompt(coder, prompt_text, index)
             io.tool_output(f"Prompt inserted at position {index + 1} (id: {item['id']})")
+
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:
             return format_command_result(io, cls.NORM_NAME, "", error=str(e))
@@ -68,8 +69,20 @@ class InsertQueueCommand(BaseCommand):
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
-        """Get completion options for insert-queue command."""
-        return []
+        """Get completion options for insert-queue command.
+
+        Args are "<index> <prompt text>"; once the index token and a space
+        are present, mirror the nested prompt's completions (e.g. a nested
+        slash command delegates to the original command's completions).
+        """
+        text = args or ""
+        first_space = text.find(" ")
+        if first_space == -1:
+            # Still typing the index; suggest valid positions.
+            if not coder.commands:
+                return []
+            return [str(i) for i in range(1, command_queue.get_queue_length(coder) + 2)]
+        return command_queue.nested_command_completions(coder, text[first_space + 1 :])
 
     @classmethod
     def get_help(cls) -> str:
@@ -83,5 +96,5 @@ class InsertQueueCommand(BaseCommand):
         help_text += "\nExamples:\n"
         help_text += "  /insert-queue 1 Review the changes in src/main.py\n"
         help_text += "  /insert-queue 3 Write unit tests for the new feature\n"
-        help_text += "\nSee also: /queue, /list-queue, /remove-queue\n"
+        help_text += "\nSee also: /queue, /list-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/list_queue.py

@@ -66,5 +66,5 @@ class ListQueueCommand(BaseCommand):
         help_text += "  and the time it was queued.\n"
         help_text += "\nExamples:\n"
         help_text += "  /list-queue  # Shows all queued prompts\n"
-        help_text += "\nSee also: /queue, /remove-queue\n"
+        help_text += "\nSee also: /queue, /insert-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/queue.py

@@ -59,6 +59,7 @@ class QueueCommand(BaseCommand):
             item = command_queue.enqueue_prompt(coder, prompt_text)
             position = command_queue.get_queue_length(coder)
             io.tool_output(f"Prompt queued at position {position} (id: {item['id']})")
+
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:
             return format_command_result(io, cls.NORM_NAME, "", error=str(e))
@@ -67,8 +68,12 @@ class QueueCommand(BaseCommand):
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
-        """Get completion options for queue command."""
-        return []
+        """Get completion options for queue command.
+
+        When the queued prompt starts with a slash command, mirror the
+        original command's completions (e.g. /queue /add <tab> offers files).
+        """
+        return command_queue.nested_command_completions(coder, args)
 
     @classmethod
     def get_help(cls) -> str:
@@ -86,5 +91,5 @@ class QueueCommand(BaseCommand):
         help_text += "\nExamples:\n"
         help_text += "  /queue Review the changes in src/main.py\n"
         help_text += "  /queue Write unit tests for the new feature\n"
-        help_text += "\nSee also: /list-queue, /remove-queue\n"
+        help_text += "\nSee also: /insert-queue, /list-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0rc1}/cecli/commands/remove_queue.py

@@ -115,5 +115,5 @@ class RemoveQueueCommand(BaseCommand):
         help_text += "  /remove-queue 1   # Remove the first queued prompt\n"
         help_text += "  /remove-queue *   # Clear the entire queue\n"
         help_text += "  /remove-queue     # Interactive mode\n"
-        help_text += "\nSee also: /queue, /list-queue\n"
+        help_text += "\nSee also: /queue, /insert-queue, /list-queue, /run-queue\n"
         return help_text

cecli_dev-1.10.0rc1/cecli/commands/run_queue.py

@@ -0,0 +1,79 @@
+"""Run-queue command for CLI-33: processes queued prompts on demand.
+
+Primary use: after cancelling an in-flight response (Ctrl+C), the in-flight
+prompt is re-queued at the front. /run-queue resumes processing the queue.
+"""
+
+import asyncio
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
+from cecli.signals import SwitchCoderSignal
+
+
+class RunQueueCommand(BaseCommand):
+    NORM_NAME = "run-queue"
+    DESCRIPTION = "Process queued prompts in order"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the run-queue command with given parameters.
+
+        Args:
+            io: InputOutput instance
+            coder: Coder instance (may be None for some commands)
+            args: Command arguments (unused for run-queue)
+            **kwargs: Additional context
+
+        Returns:
+            Formatted result string
+        """
+        # Sad path: coder.commands is None
+        if not coder.commands:
+            return format_command_result(
+                io, cls.NORM_NAME, "", error="Command system not available. Cannot run queue."
+            )
+
+        # Resolve the target coder (sub-agent aware: use the foreground agent's queue)
+        target = command_queue.get_active_coder(coder)
+
+        # Sad path: empty queue
+        if command_queue.get_queue_length(target) == 0:
+            io.tool_output("Queue is empty. Use /queue <prompt> to add prompts first.")
+            return f"Successfully executed {cls.NORM_NAME}."
+
+        # Happy path: drain the queue
+        try:
+            await target.process_prompt_queue()
+            return f"Successfully executed {cls.NORM_NAME}."
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            # The interrupted item was re-queued; let the user know the queue paused.
+            io.tool_output("Queue processing paused. Use /run-queue to resume.")
+            return f"Successfully executed {cls.NORM_NAME}."
+        except (SwitchCoderSignal, SystemExit):
+            raise
+        except Exception as e:
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for run-queue command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the run-queue command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /run-queue  # Process all queued prompts in FIFO order\n"
+        help_text += "\nDescription:\n"
+        help_text += "  Processes every prompt currently in the queue, in order.\n"
+        help_text += "  Queued prompts normally run automatically after the current\n"
+        help_text += "  response finishes. Use /run-queue to resume a queue that was\n"
+        help_text += "  paused (e.g. after cancelling an in-flight response with Ctrl+C).\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /run-queue  # Drains the queue, processing each prompt in order\n"
+        help_text += "\nSee also: /queue, /insert-queue, /list-queue, /remove-queue\n"
+        return help_text