cecli-dev 0.100.1__tar.gz → 0.100.2__tar.gz

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.1
+Version: 0.100.2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -52,6 +52,7 @@ Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
 Requires-Dist: py-cymbal>=0.1.24
+Requires-Dist: cryptography>=42.0.0
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: importlib-metadata>=7.2.1

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/__init__.py

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

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.1'
-__version_tuple__ = version_tuple = (0, 100, 1)
+__version__ = version = '0.100.2'
+__version_tuple__ = version_tuple = (0, 100, 2)
 
-__commit_id__ = commit_id = 'g855931cff'
+__commit_id__ = commit_id = 'gb0fcce1f4'

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/args.py

@@ -370,6 +370,24 @@ def get_parser(default_config_files, git_root):
             " (default: False)"
         ),
     )
+    group.add_argument(
+        "--session-encrypt",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Encrypt saved sessions on disk (AES-256-GCM). Requires CECLI_SESSION_KEY or"
+            " --session-key-file (default: False)"
+        ),
+    )
+    group.add_argument(
+        "--session-key-file",
+        metavar="SESSION_KEY_FILE",
+        default=None,
+        help=(
+            "File containing a urlsafe-base64 32-byte session encryption key"
+            " (default: use CECLI_SESSION_KEY only)"
+        ),
+    ).complete = shtab.FILE
     group.add_argument(
         "--mcp-servers",
         metavar="MCP_CONFIG_JSON",
@@ -536,6 +554,16 @@ def get_parser(default_config_files, git_root):
             " False)"
         ),
     )
+    group.add_argument(
+        "--exempt-paths",
+        action="append",
+        default=[],
+        help=(
+            "Specify a regex pattern for paths that should be exempted from file creation. "
+            "When /add matches a path matching any exempt pattern, it will not offer to "
+            "create the file. Can be used multiple times."
+        ),
+    )
     ##########
     group = parser.add_argument_group("Output settings")
     group.add_argument(

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/coders/agent_coder.py

@@ -12,7 +12,6 @@ from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
 
-from cecli import utils
 from cecli.change_tracker import ChangeTracker
 from cecli.helpers import nested, responses
 from cecli.helpers.agents.service import AgentService
@@ -265,7 +264,8 @@ class AgentCoder(Coder):
 
     async def initialize_mcp_tools(self):
         if not self.mcp_manager:
-            self.mcp_manager = McpServerManager([], self.io, self.args.verbose)
+            verbose = getattr(self.args, "verbose", False) if self.args else False
+            self.mcp_manager = McpServerManager([], self.io, verbose)
 
         server_name = "Local"
         server = self.mcp_manager.get_server(server_name)
@@ -540,6 +540,10 @@ class AgentCoder(Coder):
 
         # Add post-message context blocks (priority 250 - between CUR and REMINDER)
         ConversationService.get_chunks(self).add_post_message_context_blocks()
+
+        # Add sub-agent states context block (same priority as post-message blocks)
+        ConversationService.get_chunks(self).add_sub_agent_states()
+
         ConversationService.get_chunks(self).add_randomized_cta()
 
         return ConversationService.get_manager(self).get_messages_dict()
@@ -727,25 +731,23 @@ class AgentCoder(Coder):
                     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
+                    parsed = responses.parse_tool_arguments(args_string)
+                    if isinstance(parsed, dict) and "@error" in parsed:
+                        self.io.tool_warning(
+                            f"Malformed JSON arguments in tool {tool_name}: {parsed['@error']}"
+                        )
+                        tool_responses.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": (
+                                    f"Malformed JSON arguments in tool {tool_name}: {parsed['@error']}"
+                                ),
+                            }
+                        )
+                        continue
+                    parsed_args_list = [parsed]
+
                 if not parsed_args_list and not args_string:
                     parsed_args_list.append({})
                 all_results_content = []
@@ -837,20 +839,22 @@ class AgentCoder(Coder):
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
-        responses = []
+        tool_responses = []
         for tool_call in tool_calls:
             # Use existing _execute_mcp_tool logic
             result = await self._execute_mcp_tool(
-                server, tool_call.function.name, json.loads(tool_call.function.arguments)
+                server,
+                tool_call.function.name,
+                responses.parse_tool_arguments(tool_call.function.arguments),
             )
-            responses.append(
+            tool_responses.append(
                 {
                     "role": "tool",
                     "tool_call_id": tool_call.id,
                     "content": result,
                 }
             )
-        return responses
+        return tool_responses
 
     def get_active_model(self):
         if self.main_model.agent_model:
@@ -871,6 +875,13 @@ class AgentCoder(Coder):
         content = self.partial_response_content
         tool_calls_found = bool(self.partial_response_tool_calls)
 
+        # Reap all finished sub-agents with auto_reap enabled
+        try:
+            service = AgentService.get_instance(self)
+            await service.reap_all_finished_agents(parent=service.get_parent(self))
+        except Exception:
+            logger.warning("Failed to reap finished sub-agents", exc_info=True)
+
         # 1. Handle Tool Execution Follow-up (Reflection)
         if self.agent_finished:
             self.tool_usage_history = []
@@ -878,6 +889,7 @@ class AgentCoder(Coder):
             self.reflected_message = None
             if self.files_edited_by_tools:
                 _ = await self.auto_commit(self.files_edited_by_tools)
+
             return False
 
         # 2. Check for unfinished and recently finished background commands
@@ -938,7 +950,7 @@ class AgentCoder(Coder):
         if self.tool_call_vectors:
             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."
+                    "Continue with your task. If you have completed it, call the `Yield` tool."
                 )
                 return True
 
@@ -1490,12 +1502,53 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
                 result += "\n"
 
             result += "Use the `Delegate` tool with the sub-agent name to delegate tasks.\n"
+            result += "Use the `Yield` tool to wait for responses for all active sub agents.\n"
             result += "</context>"
             return result
         except Exception as e:
             self.io.tool_error(f"Error generating sub-agents context: {str(e)}")
             return None
 
+    def get_child_agent_states(self):
+        """Get the state of all active child sub-agents.
+
+        Returns a formatted context block with each child sub-agent's name,
+        UUID, and current status, or None if no children exist.
+        This is used by ConversationChunks.add_sub_agent_states() to provide
+        the model with visibility into active sub-agent states.
+        """
+        if not self.use_enhanced_context:
+            return None
+
+        # Sub-agents should only see child states when nested delegation is enabled
+        if hasattr(self, "parent_uuid") and self.parent_uuid:
+            if not self.agent_config.get("allow_nested_delegation", False):
+                return None
+
+        try:
+            service = AgentService.get_instance(self)
+            children = service.get_children(self)
+
+            if not children:
+                return None
+
+            result = '<context name="sub_agent_states" from="agent">\n'
+            result += "## Active Sub-Agent States\n\n"
+            result += f"Found {len(children)} active child sub-agent(s):\n\n"
+
+            for info in children:
+                result += f"**{info.name}**:\n"
+                result += f"  - UUID: `{info.coder.uuid}`\n"
+                result += f"  - Status: {info.status.value}\n"
+                if info.error:
+                    result += f"  - Error: {info.error}\n"
+                result += "\n"
+            result += "</context>"
+            return result
+        except Exception as e:
+            self.io.tool_error(f"Error generating child agent states: {str(e)}")
+            return None
+
     def get_background_command_output(self):
         """
         Get background command output to append after the main message.

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/coders/base_coder.py

@@ -1597,7 +1597,7 @@ class Coder(metaclass=UsageMeta):
                     self.io.output_task = asyncio.create_task(self.generate(user_message, preproc))
 
                     # Start spinner for output task
-                    self.io.start_spinner("Processing...")
+                    self.io.start_spinner("Processing...", coder_uuid=getattr(self, "uuid", None))
                     await self.io.recreate_input()
 
                 # Monitor output task
@@ -1914,6 +1914,7 @@ class Coder(metaclass=UsageMeta):
                     messages,
                     compaction_prompt,
                     self.context_compaction_summary_tokens,
+                    coder=self,
                 )
                 if not text:
                     raise ValueError(f"Summarization of {tag} messages returned empty.")
@@ -2306,6 +2307,16 @@ class Coder(metaclass=UsageMeta):
     def get_active_model(self):
         return self.main_model
 
+    def empty_llm_tool_warning(self) -> str:
+        """Ollama-friendly copy for local models; cloud hint otherwise."""
+        name = str(getattr(getattr(self, "main_model", None), "name", "") or "")
+        if "ollama" in name.lower():
+            return (
+                "Empty response from the local model (Ollama). "
+                "The model may have timed out, unloaded, or hit context limits."
+            )
+        return "Empty response received from LLM. Check API keys, quota, or provider status."
+
     async def send_message(self, inp):
         # Notify IO that LLM processing is starting
         self.io.llm_started()
@@ -2365,7 +2376,7 @@ class Coder(metaclass=UsageMeta):
             if not self.tui:
                 spinner_text += f" • ${self.format_cost(self.total_cost)} session"
 
-            self.io.start_spinner(spinner_text)
+            self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
             if self.stream:
                 self.mdstream = True
             else:
@@ -2452,9 +2463,7 @@ class Coder(metaclass=UsageMeta):
             self.mdstream = None
 
             # Ensure any waiting spinner is stopped
-            self.io.start_spinner("Processing Answer...")
-
-            self.partial_response_content = self.get_multi_response_content_in_progress(True)
+            self.io.start_spinner("Processing Answer...", coder_uuid=getattr(self, "uuid", None))
             self.remove_reasoning_content()
             self.multi_response_content = ""
 
@@ -2645,6 +2654,13 @@ class Coder(metaclass=UsageMeta):
                 expanded_tool_calls.append(tool_call)
                 continue
 
+            merged = responses.merge_glued_json_objects(json_chunks)
+            if merged is not None:
+                new_tool_call = copy_tool_call(tool_call)
+                new_tool_call.function.arguments = json.dumps(merged)
+                expanded_tool_calls.append(new_tool_call)
+                continue
+
             # We have concatenated JSON, so expand it into multiple tool calls.
             for i, chunk in enumerate(json_chunks):
                 if not chunk.strip():
@@ -3255,7 +3271,6 @@ class Coder(metaclass=UsageMeta):
                 functions,
                 self.stream,
                 self.temperature,
-                # This could include any tools, but for now it is just MCP tools
                 tools=tools,
                 override_kwargs=self.model_kwargs.copy(),
                 interrupt_event=self.interrupt_event,
@@ -3363,7 +3378,7 @@ class Coder(metaclass=UsageMeta):
             and not len(self.partial_response_tool_calls)
             and not len(self.partial_response_reasoning_content)
         ):
-            self.io.tool_warning("Empty response received from LLM. Check your provider account?")
+            self.io.tool_warning(self.empty_llm_tool_warning())
 
         self.io.assistant_output(show_resp, pretty=self.show_pretty())
 
@@ -3520,7 +3535,7 @@ class Coder(metaclass=UsageMeta):
             return
 
         if not received_content and len(self.partial_response_tool_calls) == 0:
-            self.io.tool_warning("Empty response received from LLM. Check your provider account?")
+            self.io.tool_warning(self.empty_llm_tool_warning())
 
     def consolidate_chunks(self):
         if self.partial_response_consolidated:
@@ -3628,12 +3643,19 @@ class Coder(metaclass=UsageMeta):
             extracted_calls = responses.extract_tools_from_content_json(
                 self.partial_response_content
             )
+
             if not extracted_calls:
                 extracted_calls = responses.extract_tools_from_content_xml(
                     self.partial_response_content
                 )
 
+            if not extracted_calls:
+                extracted_calls = responses.extract_tools_from_pseudo_json(
+                    self.partial_response_content
+                )
+
             if extracted_calls:
+                self.tool_reflection = True
                 self.partial_response_tool_calls = extracted_calls
 
         self.partial_response_consolidated = (response, func_err, content_err)

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/__init__.py

@@ -33,7 +33,6 @@ from .help import HelpCommand
 from .history_search import HistorySearchCommand
 from .hooks import HooksCommand
 from .include_skill import IncludeSkillCommand
-from .invoke_agent import InvokeAgentCommand
 from .lint import LintCommand
 from .list_sessions import ListSessionsCommand
 from .list_skills import ListSkillsCommand
@@ -117,7 +116,6 @@ CommandRegistry.register(HashlineCommand)
 CommandRegistry.register(HelpCommand)
 CommandRegistry.register(HistorySearchCommand)
 CommandRegistry.register(HooksCommand)
-CommandRegistry.register(InvokeAgentCommand)
 CommandRegistry.register(ReapAgentCommand)
 CommandRegistry.register(SpawnAgentCommand)
 CommandRegistry.register(SwitchAgentCommand)
@@ -200,7 +198,6 @@ __all__ = [
     "HistorySearchCommand",
     "HooksCommand",
     "IncludeSkillCommand",
-    "InvokeAgentCommand",
     "ReapAgentCommand",
     "SpawnAgentCommand",
     "SwitchAgentCommand",

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/add.py

@@ -71,6 +71,20 @@ class AddCommand(BaseCommand):
             if len(confirm_fname) > 64:
                 confirm_fname = f".../{os.path.basename(confirm_fname)}"
 
+            # Check if the path matches any exempt-path regex patterns
+            exempt_paths = getattr(coder.args, "exempt_paths", None) or []
+            if exempt_paths:
+                try:
+                    rel_norm = os.path.relpath(fname, coder.root).replace("\\", "/")
+                except ValueError:
+                    rel_norm = str(fname).replace("\\", "/")
+                if any(re.search(p, rel_norm) for p in exempt_paths):
+                    io.tool_error(
+                        f"Path '{confirm_fname}' matches an exempt-path pattern. "
+                        "Skipping file creation."
+                    )
+                    continue
+
             if await io.confirm_ask(
                 f"No files matched '{confirm_fname}'. Do you want to create this file?"
             ):

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/exclude_skill.py

@@ -19,7 +19,7 @@ class ExcludeSkillCommand(BaseCommand):
         skill_names = args.strip().split()
 
         # Check if we're in agent mode
-        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+        if not hasattr(coder, "edit_format") or coder.edit_format not in ("agent", "subagent"):
             io.tool_output("Skill exclusion is only available in agent mode.")
             return format_command_result(
                 io, "exclude-skill", "Skill exclusion is only available in agent mode"

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/include_skill.py

@@ -19,7 +19,7 @@ class IncludeSkillCommand(BaseCommand):
         skill_names = args.strip().split()
 
         # Check if we're in agent mode
-        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+        if not hasattr(coder, "edit_format") or coder.edit_format not in ("agent", "subagent"):
             io.tool_output("Skill inclusion is only available in agent mode.")
             return format_command_result(
                 io, "include-skill", "Skill inclusion is only available in agent mode"

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/load_skill.py

@@ -19,7 +19,8 @@ class LoadSkillCommand(BaseCommand):
         skill_names = args.strip().split()
 
         # Check if we're in agent mode
-        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+        io.tool_output(coder.edit_format)
+        if not hasattr(coder, "edit_format") or coder.edit_format not in ("agent", "subagent"):
             io.tool_output("Skill loading is only available in agent mode.")
             return format_command_result(
                 io, "load-skill", "Skill loading is only available in agent mode"

cecli_dev-0.100.2/cecli/commands/reap_agent.py

@@ -0,0 +1,160 @@
+"""Reap-agent command - force destroys the active sub-agent."""
+
+import weakref
+from typing import List
+
+from cecli.helpers.agents.service import AgentService
+
+from .utils.base_command import BaseCommand
+
+
+class ReapAgentCommand(BaseCommand):
+    NORM_NAME = "reap-agent"
+    DESCRIPTION = "Force destroy the active sub-agent"
+    show_completion_notification = False
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Destroy a sub-agent and clean up its resources.
+
+        If an agent identifier is provided, looks up the sub-agent by
+        name or UUID prefix (matching switch-agent semantics).  Without
+        an argument the currently-active sub-agent (from the TUI) is
+        reaped.
+        """
+        agent_identifier = args.strip() if args else ""
+
+        # --- Resolve the target UUID -------------------------------- #
+        agent_uuid = None
+        target_name = None
+
+        if agent_identifier:
+            # Lookup logic mirroring switch-agent
+            agent_service = AgentService.get_instance(coder)
+
+            # Try parsing "name (uuid_prefix)" format
+            if agent_identifier.endswith(")") and " (" in agent_identifier:
+                try:
+                    uuid_prefix = agent_identifier.rsplit(" (", 1)[1][:-1]
+                    for uuid, info in agent_service.sub_agents.items():
+                        if uuid.startswith(uuid_prefix):
+                            agent_uuid = uuid
+                            target_name = info.name
+                            break
+                except IndexError:
+                    pass
+
+            # Try matching by name directly
+            if agent_uuid is None:
+                for uuid, info in agent_service.sub_agents.items():
+                    if info.name == agent_identifier:
+                        agent_uuid = uuid
+                        target_name = info.name
+                        break
+
+            # Try matching by UUID prefix directly
+            if agent_uuid is None:
+                for uuid, info in agent_service.sub_agents.items():
+                    if uuid.startswith(agent_identifier):
+                        agent_uuid = uuid
+                        target_name = info.name
+                        break
+
+            if agent_uuid is None:
+                io.tool_error(f"Error: Agent '{agent_identifier}' not found.")
+                return
+
+            # Prevent reaping the primary coder
+            if agent_uuid == str(coder.uuid):
+                io.tool_error("Cannot reap the primary coder.")
+                return
+
+        else:
+            # Original behaviour: reap the active sub-agent from the TUI
+            active_uuid = None
+
+            # Use _get_tui logic (same as AgentService._get_tui) to safely
+            # dereference the TUI weakref. The TUI stores itself on coders
+            # as a weakref.ref, so we must call it to get the live object.
+            tui_ref = getattr(coder, "tui", None)
+            if tui_ref is not None:
+                if isinstance(tui_ref, weakref.ref):
+                    tui_instance = tui_ref()
+                else:
+                    tui_instance = tui_ref
+                if tui_instance is not None:
+                    active_uuid = tui_instance._get_visible_coder().uuid
+
+            if not active_uuid:
+                io.tool_error("No active sub-agent to reap.")
+                return
+
+            # Find the sub-agent info by UUID
+            agent_service = AgentService.get_instance(coder)
+            for name, info in list(agent_service.sub_agents.items()):
+                if info.coder.uuid == active_uuid:
+                    agent_uuid = active_uuid
+                    target_name = name
+                    break
+            else:
+                io.tool_error("Could not find sub-agent for the active container.")
+                return
+
+        # --- Cleanup ------------------------------------------------ #
+        try:
+            # Cleanup conversation resources
+            from cecli.helpers.conversation.service import ConversationService
+
+            ConversationService.destroy_instances(agent_uuid)
+
+            # Remove from tracking and clean up
+            agent_service._cleanup_sub_agent(agent_uuid)
+
+            io.tool_output(f"Sub-agent '{target_name}' reaped.")
+        except (KeyError, AttributeError, RuntimeError) as e:
+            io.tool_error(f"Error reaping sub-agent: {e}")
+        except Exception as e:
+            io.tool_error(f"Unexpected error reaping sub-agent: {e}")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for reap-agent command."""
+        try:
+            agent_service = AgentService.get_instance(coder)
+            names: List[str] = []
+
+            # Add sub-agent names
+            if agent_service and agent_service.sub_agents:
+                # First pass: count name occurrences
+                name_counts = {}
+                for uuid, sub_agent_info in agent_service.sub_agents.items():
+                    name_counts[sub_agent_info.name] = name_counts.get(sub_agent_info.name, 0) + 1
+
+                # Second pass: only show UUID prefix when name appears multiple times
+                for uuid, sub_agent_info in agent_service.sub_agents.items():
+                    name = sub_agent_info.name
+                    if name_counts[name] > 1:
+                        names.append(f"{name} ({uuid[:3]})")
+                    else:
+                        names.append(name)
+
+            current_arg = args.strip().lower()
+            if current_arg:
+                return [name for name in names if name.lower().startswith(current_arg)]
+            else:
+                return names
+        except Exception:
+            return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        help_text = "Force destroy the active sub-agent (/reap-agent)"
+        help_text += "\n\nUsage:\n"
+        help_text += "  /reap-agent              # Reap the currently active sub-agent\n"
+        help_text += "  /reap-agent <name>       # Reap a sub-agent by name\n"
+        help_text += "  /reap-agent <uuid>       # Reap a sub-agent by UUID prefix\n"
+        help_text += "  /reap-agent <name> (<prefix>)  # Reap by name with UUID disambiguation\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /reap-agent reviewer\n"
+        help_text += "  /reap-agent abc\n"
+        return help_text

{cecli_dev-0.100.1 → cecli_dev-0.100.2}/cecli/commands/remove_skill.py

@@ -19,7 +19,7 @@ class RemoveSkillCommand(BaseCommand):
         skill_names = args.strip().split()
 
         # Check if we're in agent mode
-        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+        if not hasattr(coder, "edit_format") or coder.edit_format not in ("agent", "subagent"):
             io.tool_output("Skill removal is only available in agent mode.")
             return format_command_result(
                 io, "remove-skill", "Skill removal is only available in agent mode"