cecli-dev 1.3.2rc2__tar.gz → 1.4.0rc1__tar.gz

{cecli_dev-1.3.2rc2 → cecli_dev-1.4.0rc1}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.2rc2'
-__version_tuple__ = version_tuple = (1, 3, 2, 'rc2')
+__version__ = version = '1.4.0rc1'
+__version_tuple__ = version_tuple = (1, 4, 0, 'rc1')
 
-__commit_id__ = commit_id = 'gb52f1a0f8'
+__commit_id__ = commit_id = 'ge2f9c56b1'

{cecli_dev-1.3.2rc2 → cecli_dev-1.4.0rc1}/cecli/coders/agent_coder.py

@@ -105,8 +105,27 @@ class AgentCoder(Coder):
         self.sub_agent_paths = self.agent_config.get("subagent_paths", [])
         self._setup_agent()
 
-        AgentService.build_registry(self.sub_agent_paths)
-        ToolRegistry.build_registry(agent_config=self.agent_config)
+        # primary_root is needed early so the skills and tool registries can
+        # resolve relative paths against the primary workspace root rather than
+        # this coder's (possibly overridden) local root. base_coder re-affirms
+        # and keeps this value in super().__init__().
+        self.primary_root = kwargs.get("primary_root") or getattr(self, "primary_root", None)
+
+        # Allow a sub-agent to target a different working root (multi-project workspace).
+        if not kwargs.get("root"):
+            configured_root = self.agent_config.get("root")
+            if configured_root:
+                kwargs["root"] = configured_root
+
+        self._initialize_skills_manager(
+            self.agent_config, root=kwargs.get("root", self.primary_root)
+        )
+        AgentService.build_registry(
+            self.sub_agent_paths, root=kwargs.get("root", self.primary_root)
+        )
+        ToolRegistry.build_registry(
+            agent_config=self.agent_config, root=kwargs.get("root", self.primary_root)
+        )
 
         self.loaded_custom_tools = ToolRegistry.loaded_custom_tools
         super().__init__(*args, **kwargs)
@@ -292,21 +311,19 @@ class AgentCoder(Coder):
             config["tools_excludelist"].append("loadskill")
             config["tools_excludelist"].append("removeskill")
 
-        self._initialize_skills_manager(config)
         return config
 
-    def _initialize_skills_manager(self, config):
+    def _initialize_skills_manager(self, config, root=None):
         """
         Initialize the skills manager with the configured directory paths and filters.
         """
         try:
-            git_root = str(self.repo.root) if self.repo else None
             self.skills_manager = SkillsManager(
                 directory_paths=config.get("skills_paths", []),
                 include_list=config.get("skills_includelist", []),
                 exclude_list=config.get("skills_excludelist", []),
                 initialize_list=config.get("skills_init", []),
-                git_root=git_root,
+                root=root or self.root or self.primary_root,
                 coder=self,
             )
         except Exception as e:
@@ -733,7 +750,8 @@ class AgentCoder(Coder):
     def get_environment_info(self):
         """
         Generate an environment information context block with key system details.
-        Returns formatted string with working directory, platform, date, and other relevant environment details.
+        Returns formatted string with working directory, platform, date, and other relevant environment details,
+        including the agent's own identity and the primary agent's UUID.
         """
         if not self.use_enhanced_context:
             return None
@@ -747,6 +765,17 @@ class AgentCoder(Coder):
             result += f"- Current date: {current_date}\n"
             result += f"- Platform: {platform_info}\n"
             result += f"- Language preference: {language}\n"
+
+            # Agent identity so the model can recognise itself and the primary
+            # agent. Kept here (a static context block) rather than in the
+            # sub-agent states block to avoid re-injecting an agent's own
+            # identity whenever sub-agent state changes mid-conversation.
+            service = AgentService.get_instance(self)
+            self_uuid = str(self.uuid)
+            primary_uuid = str(service.coder.uuid)
+            self_name = service.get_agent_name(self) or "primary"
+            result += f"- Agent: {self_name} ({self_uuid}) [self]\n"
+            result += f"- Primary agent: primary ({primary_uuid})\n"
             if self.repo:
                 try:
                     rel_repo_dir = self.repo.get_rel_repo_dir()
@@ -1699,7 +1728,7 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
 
             result = '<context name="sub_agents" from="agent">\n'
             result += "## Available Sub-Agents\n\n"
-            result += f"Found {len(registry)} registered sub-agent(s):\n\n"
+            result += f"Found {len(registry)} registered sub-agent(s) types:\n\n"
 
             for name, config in sorted(registry.items()):
                 result += f"**{name}**:\n"
@@ -1708,57 +1737,107 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
                     result += f"{desc}\n"
                 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 += "Use the `Delegate` tool with the sub-agent type to delegate tasks.\n"
+            result += "Use the `Yield` tool to wait for responses for all child 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.
+    def get_sub_agent_states(self):
+        """Get the state of all active sub-agents.
+
+        Returns a formatted context block listing each active sub-agent as
+        ``{name} ({uuid}, {status})`` bullets, for both dependent children and
+        independent sub-agents. The independent ones are those reachable via
+        the ``Broadcast`` tool.
+
+        Finished/errored sub-agents are excluded. Returns None if there are no
+        active sub-agents, if enhanced context is disabled, or if the caller is
+        a sub-agent without nested delegation enabled.
+
+        The primary agent and calling agent's own identity are deliberately not
+        included here — they live in ``get_environment_info()`` (a static block)
+        so they don't re-inject and churn the conversation when sub-agent state
+        changes.
 
-        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
+        # Sub-agents should only see sub-agent 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)
+
+            from cecli.helpers.agents.service import SubAgentStatus
+
+            originator_uuid = str(self.uuid)
+
+            # Dependent children are the coder's direct children.
             children = service.get_children(self)
-            if not children:
-                return None
+            dependent_children = [
+                info
+                for info in children
+                if not info.independent
+                and info.status not in (SubAgentStatus.FINISHED, SubAgentStatus.ERROR)
+            ]
 
-            # Filter to non-independent children only
-            dependent_children = [info for info in children if not info.independent]
+            # Independent agents aren't all direct children, so iterate over
+            # every active sub-agent reachable via the Broadcast tool and dedupe
+            # against the dependent children already captured above.
+            dependent_uuids = {info.coder.uuid for info in dependent_children}
+            independent_agents = []
+            seen = set()
+            for info in service.sub_agents.values():
+                if (
+                    info.independent
+                    and str(info.coder.uuid) != originator_uuid
+                    and info.status not in (SubAgentStatus.ERROR,)
+                    and info.coder.uuid not in dependent_uuids
+                    and info.coder.uuid not in seen
+                ):
+                    seen.add(info.coder.uuid)
+                    independent_agents.append(info)
 
-            if not dependent_children:
+            if not dependent_children and not independent_agents:
                 return None
 
             result = '<context name="sub_agent_states" from="agent">\n'
-            result += "## Active Sub-Agent States\n\n"
-            result += f"Found {len(dependent_children)} active child sub-agent(s):\n\n"
-
-            for info in dependent_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 += "## Active Sub-Agent Instances\n\n"
+            result += f"Found {len(dependent_children) + len(independent_agents)} active sub-agent(s):\n\n"
+
+            if dependent_children:
+                for info in dependent_children:
+                    line = f"- {info.name} ({info.coder.uuid}, {info.status.value})"
+                    if info.error:
+                        line += f" - Error: {info.error}"
+                    result += line + "\n"
+
+            if independent_agents:
+                result += "## Independent Sub-Agent Instances\n"
+                result += (
+                    "Communicate bi-directionally with these sub-agents using the "
+                    "`Broadcast` tool:\n\n"
+                )
+
+                for info in independent_agents:
+                    line = f"- {info.name} ({info.coder.uuid}, {info.status.value})"
+                    if info.error:
+                        line += f" - Error: {info.error}"
+                    result += line + "\n"
+
             result += "</context>"
             return result
+
         except Exception as e:
-            self.io.tool_error(f"Error generating child agent states: {str(e)}")
+            self.io.tool_error(f"Error generating sub-agent states: {str(e)}")
             return None
 
     def get_background_command_output(self):

{cecli_dev-1.3.2rc2 → cecli_dev-1.4.0rc1}/cecli/coders/base_coder.py

@@ -60,7 +60,7 @@ from cecli.reasoning_tags import (
     remove_reasoning_content,
     replace_reasoning_tags,
 )
-from cecli.repo import ANY_GIT_ERROR, GitRepo, GitRepoProxy
+from cecli.repo import ANY_GIT_ERROR, GitRepoProxy
 from cecli.repomap import RepoMap
 from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd_async
@@ -193,6 +193,8 @@ class Coder(metaclass=UsageMeta):
     abs_read_only_stubs_fnames = None
     abs_rules_fnames = None
     repo = None
+    root = "."
+    primary_root = None
     last_coder_commit_hash = None
     coder_edited_files = None
     last_asked_for_commit_time = 0
@@ -327,6 +329,7 @@ class Coder(metaclass=UsageMeta):
                 uuid=from_coder.uuid,
                 parent_uuid=from_coder.parent_uuid,
                 repo=from_coder.repo,
+                primary_root=from_coder.primary_root,
                 summarizer=from_coder.summarizer,
             )
             use_kwargs.update(update)  # override to complete the switch
@@ -451,6 +454,8 @@ class Coder(metaclass=UsageMeta):
         registered_servers=None,
         uuid: str = "",
         parent_uuid: str = "",
+        root=None,
+        primary_root=None,
         init_metadata={},
     ):
         from cecli.helpers.agents.service import AgentService
@@ -622,13 +627,12 @@ class Coder(metaclass=UsageMeta):
         self.repo = repo
         if use_git and self.repo is None:
             try:
-                self.repo = GitRepoProxy(
-                    GitRepo(
-                        self.io,
-                        fnames,
-                        None,
-                        models=main_model.commit_message_models(),
-                    )
+                self.repo = GitRepoProxy.for_root(
+                    None,
+                    self.io,
+                    fnames=fnames,
+                    git_dname=None,
+                    models=main_model.commit_message_models(),
                 )
             except FileNotFoundError:
                 pass
@@ -665,12 +669,47 @@ class Coder(metaclass=UsageMeta):
         if not self.repo:
             self.root = utils.find_common_root(self.abs_fnames)
 
-        # Initialize the FileSystemService singleton for all agents
-        FileSystemService.get_instance(
+        # Allow sub-agent classes to override the working root (multi-project workspaces).
+        if root is not None:
+            self.root = os.path.normpath(os.path.abspath(root))
+
+        # A sub-agent may operate on a different base path than its parent. In
+        # that case its repo must be scoped to *this* root (per-base-path),
+        # rather than inheriting the parent's repo, so the coder's repo/fs match
+        # its own root.
+        if use_git and self.repo is not None and os.path.normpath(self.repo.root) != self.root:
+            try:
+                self.repo = GitRepoProxy.for_root(
+                    self.root,
+                    self.io,
+                    fnames=[self.root],
+                    git_dname=None,
+                    models=main_model.commit_message_models(),
+                )
+            except FileNotFoundError:
+                self.repo = None
+
+        # Store the root of the primary coder so skills files, custom tools, and
+        # sub-agent paths can be resolved relative to the primary workspace even
+        # when this coder operates on a different base path.
+        self.primary_root = (
+            primary_root
+            if primary_root is not None
+            else getattr(self, "primary_root", None) or self.root
+        )
+
+        # Initialize the per-base-path FileSystemService for this coder
+        self.fs = FileSystemService.for_root(
             root=self.root if hasattr(self, "root") else ".",
             repo=self.repo if hasattr(self, "repo") else None,
         )
 
+        # Auto-return the per-root service (and its git repo) when the last
+        # coder sharing this base path is destroyed.
+        _fs_key = FileSystemService._normalize_root(self.root if hasattr(self, "root") else ".")
+        FileSystemService._inc_ref(_fs_key)
+        weakref.finalize(self, FileSystemService._release, _fs_key)
+
         if read_only_fnames:
             self.abs_read_only_fnames = set()
             for fname in read_only_fnames:
@@ -711,11 +750,7 @@ class Coder(metaclass=UsageMeta):
         has_map_prompt = nested.getter(self, "gpt_prompts.repo_content_prefix")
 
         if use_repo_map and self.repo and has_map_prompt:
-            repo_root = (
-                self.repo.workspace_path
-                if (self.repo and getattr(self.repo, "workspace_path", None))
-                else self.root
-            )
+            repo_root = self.root
             self.repo_map = RepoMap(
                 map_tokens,
                 self.map_cache_dir,
@@ -1049,6 +1084,25 @@ class Coder(metaclass=UsageMeta):
     fences = all_fences
     fence = fences[0]
 
+    def resolve_relative_to_primary_root(self, path: str) -> str:
+        """Resolve a path relative to the primary coder's root (falling back to self.root).
+
+        Used for skills files, custom tools, and sub-agent paths that are defined
+        relative to the primary workspace even when this coder operates on a
+        different base path.
+        """
+        if not path:
+            return path
+        if path.startswith("/"):
+            # POSIX-style absolute path (e.g. "/tmp/foo"). os.path.isabs()
+            # returns False for "/"-rooted paths on Windows, so guard here
+            # to avoid re-anchoring them onto the primary root.
+            return path
+        if os.path.isabs(path):
+            return os.path.normpath(path)
+        base = self.primary_root or self.root
+        return os.path.normpath(os.path.join(base, path))
+
     def show_pretty(self):
         if not self.pretty:
             return False
@@ -4568,8 +4622,8 @@ class Coder(metaclass=UsageMeta):
             return
 
     def get_all_relative_files(self):
-        """Get all files known to the file service singleton."""
-        fs = FileSystemService.get_instance()
+        """Get all files known to the file service for this coder's base path."""
+        fs = getattr(self, "fs", None) or FileSystemService.get_instance()
         if fs.trie:
             # Auto-rebuild if the repository state has changed
             # (e.g., new commits, staged files, or HEAD change)

{cecli_dev-1.3.2rc2 → cecli_dev-1.4.0rc1}/cecli/commands/__init__.py

@@ -55,6 +55,7 @@ from .merge import MergeCommand
 from .model import ModelCommand
 from .models import ModelsCommand
 from .multiline_mode import MultilineModeCommand
+from .open import OpenCommand
 from .paste import PasteCommand
 from .queue import QueueCommand
 from .quit import QuitCommand
@@ -151,6 +152,7 @@ CommandRegistry.register(MergeCommand)
 CommandRegistry.register(ModelCommand)
 CommandRegistry.register(ModelsCommand)
 CommandRegistry.register(MultilineModeCommand)
+CommandRegistry.register(OpenCommand)
 CommandRegistry.register(PasteCommand)
 CommandRegistry.register(QueueCommand)
 CommandRegistry.register(QuitCommand)
@@ -240,6 +242,7 @@ __all__ = [
     "ModelCommand",
     "ModelsCommand",
     "MultilineModeCommand",
+    "OpenCommand",
     "parse_quoted_filenames",
     "PasteCommand",
     "quote_filename",

cecli_dev-1.4.0rc1/cecli/commands/open.py

@@ -0,0 +1,76 @@
+"""Open command - register and open a workspace sub-agent rooted at a path."""
+
+from pathlib import Path
+
+from cecli.helpers.agents.service import AgentService
+from cecli.helpers.workspaces.subagents import register_workspace_subagents
+
+from .utils.base_command import BaseCommand
+
+
+class OpenCommand(BaseCommand):
+    NORM_NAME = "open"
+    DESCRIPTION = "Open a workspace sub-agent rooted at a given path"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Open a workspace sub-agent rooted at the given path.
+
+        Syntax:
+            /open <name> <path>  — register and open a ``ws:{name}`` sub-agent rooted at ``<path>``
+        """
+        parts = args.strip().split(maxsplit=1)
+        if len(parts) < 2:
+            io.tool_error("Usage: /open <name> <path>")
+            return
+
+        name = parts[0]
+        path_arg = parts[1].strip()
+
+        project_name = name[3:] if name.startswith("ws:") else name
+        agent_name = f"ws:{project_name}"
+        path = Path(path_arg).expanduser()
+
+        config = {
+            "name": project_name,
+            "projects": [{"name": project_name, "path": str(path)}],
+        }
+        registered = register_workspace_subagents(config)
+        if agent_name not in registered:
+            io.tool_error(f"Error: '{path}' is not a valid git repository or does not exist.")
+            return
+
+        root = AgentService.get_registry()[agent_name].metadata.get("root")
+
+        try:
+            agent_service = AgentService.get_instance(coder)
+            new_coder, info = await agent_service.spawn(
+                agent_name, prompt=None, parent=coder, auto_reap=False, independent=True
+            )
+
+            agent_service.foreground_uuid = info.coder.uuid
+
+            if coder.tui and coder.tui():
+                tui = coder.tui()
+                switch_key = tui.get_keys_for("next_agent")
+                io.tool_output(
+                    f"Opened workspace sub-agent '{agent_name}' rooted at {root}. Switch with {switch_key}"
+                )
+
+                try:
+                    tui.call_from_thread(tui._switch_to_container, info.coder.uuid)
+                except Exception:
+                    pass
+            else:
+                io.tool_output(f"Opened workspace sub-agent '{agent_name}' rooted at {root}.")
+        except Exception as e:
+            io.tool_error(f"Error opening workspace sub-agent '{agent_name}': {e}")
+
+    @classmethod
+    def get_help(cls) -> str:
+        return "Open a workspace sub-agent rooted at a path (/open <name> <path>)"
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> list[str]:
+        """Return registered workspace sub-agent names for tab-completion."""
+        return [name for name in AgentService.get_registry().keys() if name.startswith("ws:")]

{cecli_dev-1.3.2rc2 → cecli_dev-1.4.0rc1}/cecli/commands/utils/helpers.py

@@ -159,7 +159,7 @@ def get_file_completions(
     root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
 
     # Try using FileSystemService for efficient lookups
-    fs = FileSystemService.get_instance()
+    fs = getattr(coder, "fs", None) or FileSystemService.get_instance()
     fs_available = fs.trie is not None or fs.ngram is not None
 
     if completion_type == "glob":

cecli_dev-1.4.0rc1/cecli/commands/workspace.py

@@ -0,0 +1,35 @@
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class WorkspaceCommand(BaseCommand):
+    NORM_NAME = "workspace"
+    DESCRIPTION = "Print information about the active workspace sub-agents"
+    show_completion_notification = True
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Show the registered ws:{name} workspace sub-agents and their roots."""
+        from cecli.helpers.agents.service import AgentService
+
+        registry = AgentService.get_registry()
+        ws_agents = sorted((name, cfg) for name, cfg in registry.items() if name.startswith("ws:"))
+
+        if not ws_agents:
+            io.tool_output("No workspace sub-agents are active.")
+            return
+
+        io.print("Workspace Sub-Agents:")
+        for name, cfg in ws_agents:
+            metadata = getattr(cfg, "metadata", {}) or {}
+            io.print(f"  - {name}")
+            io.print(f"    Root:   {metadata.get('root')}")
+            io.print(f"    Layout: {metadata.get('layout')}")
+            io.print("")
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the workspace command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /workspace  # List active workspace sub-agents\n"
+        return help_text