cecli-dev 0.100.1rc1__tar.gz → 0.100.3__tar.gz

{cecli_dev-0.100.1rc1 → cecli_dev-0.100.3}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.1rc1'
-__version_tuple__ = version_tuple = (0, 100, 1, 'rc1')
+__version__ = version = '0.100.3'
+__version_tuple__ = version_tuple = (0, 100, 3)
 
-__commit_id__ = commit_id = 'gf29b57571'
+__commit_id__ = commit_id = 'ge53c2cd27'

{cecli_dev-0.100.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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?"
             ):
@@ -84,12 +98,9 @@ class AddCommand(BaseCommand):
         for matched_file in sorted(all_matched_files):
             abs_file_path = coder.abs_root_path(matched_file)
 
-            if (
-                coder.repo
-                and coder.repo.git_ignored_file(matched_file)
-                and not coder.add_gitignore_files
-            ):
-                io.tool_error(f"Can't add {matched_file} which is in gitignore")
+            blocked = cls._add_blocked_message(coder, matched_file)
+            if blocked:
+                io.tool_error(blocked)
                 continue
 
             if abs_file_path in coder.abs_fnames:
@@ -240,3 +251,79 @@ class AddCommand(BaseCommand):
         help_text += "Files can be moved from read-only to editable status.\n"
         help_text += "Image files can be added if the model supports vision.\n"
         return help_text
+
+    @staticmethod
+    def _display_add_path(matched_file: str) -> str:
+        try:
+            label = os.path.relpath(matched_file)
+        except ValueError:
+            label = matched_file
+        if len(label) > 64:
+            label = f".../{os.path.basename(label)}"
+        return label
+
+    @staticmethod
+    def _git_repo_for_add_check(coder, matched_file: str):
+        """Resolve the GitRepo used for ignore checks (RepoSet-aware)."""
+        repo = coder.repo
+        if not repo:
+            return None, matched_file
+        if hasattr(repo, "repo_for_rel_path"):
+            git_repo = repo.repo_for_rel_path(matched_file)
+            try:
+                rel = repo.path_relative_to_repo(matched_file, git_repo)
+            except (ValueError, OSError):
+                rel = matched_file
+            return git_repo, rel
+        return repo, matched_file
+
+    @classmethod
+    def _add_blocked_message(cls, coder, matched_file: str) -> str | None:
+        """
+        Explain why /add refused a path. Distinguishes .gitignore vs .cecli.ignore when possible.
+        """
+        if not coder.repo or coder.add_gitignore_files:
+            return None
+        if not coder.repo.git_ignored_file(matched_file):
+            return None
+
+        display = cls._display_add_path(matched_file)
+        git_repo, rel = cls._git_repo_for_add_check(coder, matched_file)
+        if not git_repo:
+            return (
+                f"Can't add {display}: excluded by ignore rules for this session. "
+                "Confirm Settings \u2192 project folder is the git root for this file."
+            )
+
+        gitignore_hit = False
+        cecli_hit = False
+        if hasattr(git_repo, "_is_gitignored_by_pathspec"):
+            try:
+                gitignore_hit = bool(git_repo._is_gitignored_by_pathspec(rel))
+            except (ValueError, OSError):
+                gitignore_hit = False
+
+        ignore_file = getattr(git_repo, "cecli_ignore_file", None) or getattr(
+            git_repo, "aider_ignore_file", None
+        )
+        if ignore_file and Path(ignore_file).is_file() and hasattr(git_repo, "ignored_file_raw"):
+            try:
+                cecli_hit = bool(git_repo.ignored_file_raw(rel))
+            except (ValueError, OSError):
+                cecli_hit = False
+
+        if cecli_hit and not gitignore_hit:
+            return (
+                f"Can't add {display}: blocked by {Path(ignore_file).name} "
+                "(cecli ignore rules), not .gitignore."
+            )
+        if gitignore_hit:
+            return (
+                f"Can't add {display}: matched .gitignore under the session workspace. "
+                "If this is normal tracked source, check the project folder in Settings."
+            )
+        return (
+            f"Can't add {display}: excluded by ignore rules for this session "
+            "(.gitignore and/or cecli ignore). "
+            "Confirm the project folder is the git root that contains this file."
+        )

{cecli_dev-0.100.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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.1rc1 → cecli_dev-0.100.3}/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"