cecli-dev 1.4.0rc1__tar.gz → 1.4.1__tar.gz

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/.flake8

@@ -1,3 +1,4 @@
 [flake8]
 ignore = E203,W503
 max-line-length = 120
+exclude = *.md,*.markdown

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/PKG-INFO

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

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

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

@@ -463,7 +463,6 @@ class AgentCoder(Coder):
                 "skills",
                 "servers",
                 "sub_agents",
-                "loaded_skills",
                 "orchestration",
             ]
             for block_type in block_types:
@@ -499,8 +498,6 @@ class AgentCoder(Coder):
             content = self.get_skills_context()
         elif block_name == "servers":
             content = self.get_servers_context()
-        elif block_name == "loaded_skills":
-            content = self.get_skills_content()
         elif block_name == "orchestration":
             content = self.get_orchestration_context()
         elif block_name == "sub_agents" and (
@@ -643,6 +640,10 @@ class AgentCoder(Coder):
         # Add pre-message context blocks (priority 125 - between REPO and READONLY_FILES)
         ConversationService.get_chunks(self).add_pre_message_context_blocks()
 
+        ConversationService.get_chunks(self).add_active_skills_messages(
+            getattr(self, "skills_manager", None)
+        )
+
         ConversationService.get_chunks(self).add_readonly_files_messages()
         ConversationService.get_chunks(self).add_chat_files_messages()
 

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

@@ -474,14 +474,14 @@ class Coder(metaclass=UsageMeta):
             self._inherited_tools = True
 
         self.interrupt_event = ThreadSafeEvent()
-        self.uuid = str(generate_unique_id())
+        self.uuid = str(generate_unique_id()).split("-")[0]
         self.reflected_message = None
 
         if uuid:
-            self.uuid = str(uuid)
+            self.uuid = str(uuid).split("-")[0]
 
         if parent_uuid:
-            self.parent_uuid = str(parent_uuid)
+            self.parent_uuid = str(parent_uuid).split("-")[0]
 
         self.map_cache_dir = map_cache_dir
 
@@ -2919,6 +2919,17 @@ class Coder(metaclass=UsageMeta):
 
         edited = await self.apply_updates()
 
+        # Run tests before committing so failing tests abort the commit and
+        # reflect the errors back for the model to fix first.
+        if edited and self.auto_test and self.test_cmd:
+            test_errors = await self.commands.execute("test", self.test_cmd)
+            self.test_outcome = not test_errors
+            if test_errors:
+                ok = await self.io.confirm_ask("Attempt to fix test errors?")
+                if ok:
+                    self.reflected_message = test_errors
+                    return
+
         if edited:
             self.coder_edited_files.update(edited)
             saved_message = await self.auto_commit(edited)
@@ -2991,15 +3002,6 @@ class Coder(metaclass=UsageMeta):
                 mark_for_demotion=1,
             )
 
-        if edited and self.auto_test and self.test_cmd:
-            test_errors = await self.commands.execute("test", self.test_cmd)
-            self.test_outcome = not test_errors
-            if test_errors:
-                ok = await self.io.confirm_ask("Attempt to fix test errors?")
-                if ok:
-                    self.reflected_message = test_errors
-                    return
-
         # Turn complete: drop the per-turn LLM stream buffers.  They are reset at
         # the start of the next send(), so holding on to them while idle only
         # wastes memory (chunks can be large for long streaming responses).
@@ -4962,13 +4964,44 @@ class Coder(metaclass=UsageMeta):
         return edits
 
     def local_agent_folder(self, path):
+        primary_uuid = self._resolve_primary_agent_uuid()
+        primary_root = os.path.abspath(self.primary_root)
+
+        stripped = path.lstrip("/")
+
+        if self.uuid == primary_uuid:
+            rel_dir = f"{primary_root}/.cecli/agents/{GLOBAL_DATE}/{primary_uuid}"
+        else:
+            rel_dir = f"{primary_root}/.cecli/agents/{GLOBAL_DATE}/{primary_uuid}/s/{self.uuid}"
+
         os.makedirs(
-            self.abs_root_path(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}"),
+            self.abs_root_path(rel_dir),
             exist_ok=True,
         )
 
-        stripped = path.lstrip("/")
-        return f".cecli/agents/{GLOBAL_DATE}/{self.uuid}/{stripped}"
+        return f"{rel_dir}/{stripped}"
+
+    def _resolve_primary_agent_uuid(self):
+        """Return the primary coder's uuid for this session (memoized).
+
+        All agents spawned under a primary coder share the same base folder,
+        so sub-agent files nest under one location regardless of delegation
+        depth. Falls back to this coder's own uuid when the service is
+        unavailable (e.g. in unit tests).
+        """
+        if getattr(self, "_primary_agent_uuid", None):
+            return self._primary_agent_uuid
+
+        primary_uuid = self.uuid
+        try:
+            from cecli.helpers.agents.service import AgentService
+
+            primary_uuid = AgentService.get_primary_uuid() or self.uuid
+        except Exception:
+            pass
+
+        self._primary_agent_uuid = primary_uuid
+        return primary_uuid
 
     async def auto_save_session(self, force=False):
         """Automatically save the current session to {auto-save-session-name}.json."""

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

@@ -55,7 +55,6 @@ 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
@@ -152,7 +151,6 @@ CommandRegistry.register(MergeCommand)
 CommandRegistry.register(ModelCommand)
 CommandRegistry.register(ModelsCommand)
 CommandRegistry.register(MultilineModeCommand)
-CommandRegistry.register(OpenCommand)
 CommandRegistry.register(PasteCommand)
 CommandRegistry.register(QueueCommand)
 CommandRegistry.register(QuitCommand)
@@ -242,7 +240,6 @@ __all__ = [
     "ModelCommand",
     "ModelsCommand",
     "MultilineModeCommand",
-    "OpenCommand",
     "parse_quoted_filenames",
     "PasteCommand",
     "quote_filename",

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/cecli/commands/load_mcp.py

@@ -119,6 +119,7 @@ class LoadMcpCommand(BaseCommand):
                 server.name
                 for server in coder.mcp_manager
                 if server not in coder.mcp_manager.connected_servers
+                and server.name != "unnamed-server"
             ]
             return server_names
         except Exception:

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/cecli/commands/run.py

@@ -85,7 +85,7 @@ class RunCommand(BaseCommand):
                 io.placeholder = "What's wrong? Fix"
 
         if add_on_nonzero_exit and not exit_status:
-            return ""  # No test failures
+            return "Test command ran by user. All tests passed."  # No test failures
 
         # Return None if output wasn't added or command succeeded
         return format_command_result(io, "run", "Command executed successfully")

cecli_dev-1.4.1/cecli/commands/workspace.py

@@ -0,0 +1,238 @@
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class WorkspaceCommand(BaseCommand):
+    NORM_NAME = "workspace"
+    DESCRIPTION = "List, open or register workspace sub-agents"
+    show_completion_notification = True
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """List active workspace sub-agents, or open / register one.
+
+        Syntax:
+            /workspace                 — List active workspace sub-agents
+            /workspace <ws:name>       — Open an already-registered ``ws:name`` sub-agent (like /spawn-agent)
+            /workspace <name> <path>   — Register and open a ``ws:{name}`` sub-agent rooted at ``<path>``
+        """
+        parts = args.strip().split(maxsplit=1)
+
+        if not parts:
+            cls._list_workspace_subagents(io)
+            return
+
+        name = parts[0]
+        path_arg = parts[1].strip() if len(parts) > 1 else None
+
+        if path_arg is None:
+            await cls._open_existing(io, coder, name)
+            return
+
+        await cls._register_and_open(io, coder, name, path_arg)
+
+    @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"
+        help_text += "  /workspace <ws:name>    # Open an already-registered ws: sub-agent (like /spawn-agent)\n"
+        help_text += "  /workspace <name> <path>  # Register and open a ws:{name} sub-agent rooted at <path>\n"
+        return help_text
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> list[str]:
+        """Return tab-completions for the workspace command.
+
+        - The first argument (the ``ws:{name}`` sub-agent name) is completed from
+          the active workspace sub-agent names, including the ``ws:`` prefix.
+        - The second argument (the project path) is completed by browsing the
+          folders at the typed path, independent of the coder's file completion
+          index. The folder list is ranked with rapidfuzz + ngram so prefix
+          matches surface first.
+        """
+        from cecli.helpers.agents.service import AgentService
+
+        partial = (args or "").strip()
+
+        if not partial or partial.startswith("ws:"):
+            return [name for name in AgentService.get_registry() if name.startswith("ws:")]
+
+        return cls._get_path_completions(partial)
+
+    @classmethod
+    def _list_workspace_subagents(cls, io) -> None:
+        """Print 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
+    async def _open_existing(cls, io, coder, name) -> None:
+        """Open an already-registered workspace sub-agent, mirroring /spawn-agent."""
+        from cecli.helpers.agents.service import AgentService
+
+        if not name.startswith("ws:"):
+            io.tool_error(f"Error: '{name}' is not a registered workspace sub-agent.")
+            return
+
+        if name not in AgentService.get_registry():
+            io.tool_error(f"Error: workspace sub-agent '{name}' is not registered.")
+            return
+
+        try:
+            agent_service = AgentService.get_instance(coder)
+            new_coder, info = await agent_service.spawn(
+                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"Sub-agent '{name}' spawned and active. 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 '{name}'.")
+        except ValueError as e:
+            io.tool_error(f"Error: {e}")
+        except RuntimeError as e:
+            io.tool_error(f"Error: {e}")
+        except Exception as e:
+            io.tool_error(f"Error spawning sub-agent '{name}': {e}")
+
+    @classmethod
+    async def _register_and_open(cls, io, coder, name, path_arg) -> None:
+        """Register a ``ws:{name}`` sub-agent rooted at ``<path>`` and open it."""
+        from pathlib import Path
+
+        from cecli.helpers.agents.service import AgentService
+        from cecli.helpers.workspaces.subagents import register_workspace_subagents
+
+        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_path_completions(cls, partial: str) -> list[str]:
+        """Browse the filesystem for folders matching the typed path prefix."""
+        from pathlib import Path
+
+        path = Path(partial)
+        if partial.endswith("/"):
+            search_dir = path
+            name_prefix = ""
+        else:
+            search_dir = path.parent
+            name_prefix = path.name
+
+        if not search_dir.is_dir():
+            return []
+
+        if search_dir == Path("."):
+            path_prefix = ""
+        else:
+            path_prefix = str(search_dir).rstrip("/") + "/"
+
+        folders: list[str] = []
+        try:
+            for entry in search_dir.iterdir():
+                if entry.is_dir():
+                    folders.append(path_prefix + entry.name + "/")
+        except (PermissionError, OSError):
+            return []
+
+        if name_prefix:
+            prefix_lower = name_prefix.lower()
+            folders = [f for f in folders if Path(f).name.lower().startswith(prefix_lower)]
+
+        return cls._rank_paths(partial, folders)
+
+    @staticmethod
+    def _rank_paths(query: str, candidates: list[str]) -> list[str]:
+        """Order path candidates with rapidfuzz + ngram so prefix matches surface first."""
+        if not candidates:
+            return []
+
+        query_lower = query.lower()
+
+        try:
+            from ngram import NGram
+            from rapidfuzz import fuzz, process
+        except ImportError:
+            return sorted(
+                candidates,
+                key=lambda c: (not c.lower().startswith(query_lower), c.lower()),
+            )
+
+        lower_candidates = [c.lower() for c in candidates]
+        results = process.extract(
+            query_lower,
+            lower_candidates,
+            scorer=fuzz.partial_ratio,
+            limit=min(len(candidates), 20),
+            score_cutoff=0,
+        )
+
+        matched = [candidates[idx] for _, _, idx in results]
+
+        if len(matched) < 100:
+            ng = NGram([c.lower() for c in matched], N=3)
+            reranked = ng.search(query_lower, threshold=0.0)
+            original_by_lower = {c.lower(): c for c in matched}
+            matched = [original_by_lower.get(item.lower(), item) for item, _ in reranked]
+
+        return matched

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/cecli/helpers/agents/service.py

@@ -137,6 +137,15 @@ class AgentService:
         """Return the global sub-agent registry (name -> config)."""
         return cls._global_registry
 
+    @classmethod
+    def get_primary_uuid(cls) -> Optional[str]:
+        """Return the primary coder's uuid for the current session (memoized).
+
+        Fixed on the first :meth:`get_instance` call, so every agent spawned
+        in a session resolves to the same shared base uuid.
+        """
+        return cls._primary_agent_uuid
+
     @classmethod
     def get_all_agents(cls) -> List[Any]:
         """Return all live coder instances tracked in the global uuid map.
@@ -576,7 +585,7 @@ class AgentService:
 
         async with self._get_lock(self._spawn_locks, parent_coder.uuid):
             self._check_max_sub_agents()
-            new_uuid = str(uuid4())
+            new_uuid = str(uuid4()).split("-")[0]
 
         from cecli.coders import Coder
 

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1}/cecli/helpers/conversation/files.py

@@ -39,6 +39,9 @@ class ConversationFiles:
         self._image_files: Dict[str, bool] = {}
         self._numbered_contexts: Dict[str, List[Tuple[int, int]]] = {}
         self._last_merged_ranges: Dict[str, List[Tuple[int, int]]] = {}
+        self._emitted_contexts: Dict[str, List[Tuple[int, int]]] = (
+            {}
+        )  # intervals already delivered as FILE_CONTEXTS
         self._initialized = True
 
     @classmethod
@@ -388,6 +391,7 @@ class ConversationFiles:
             self._file_stub_contents.clear()
             self._file_json_contents.clear()
             self._file_to_message_id.clear()
+            self._emitted_contexts.clear()
             if clear_contexts:
                 self._numbered_contexts.clear()
         else:
@@ -402,6 +406,7 @@ class ConversationFiles:
             self._file_json_contents.pop(abs_fname, None)
             self._file_to_message_id.pop(abs_fname, None)
             self._image_files.pop(abs_fname, None)
+            self._emitted_contexts.pop(abs_fname, None)
             if clear_contexts:
                 self._numbered_contexts.pop(abs_fname, None)
 
@@ -463,7 +468,9 @@ class ConversationFiles:
 
         if diff_version != context_version:
             self._file_context_versions[abs_fname] = diff_version
-        # auto clear on edit
+            # Content changed: force re-emission of context (stale blocks won't
+            # refresh otherwise).
+            self._emitted_contexts.pop(abs_fname, None)
         # existing_ranges = []
 
         # Add new range
@@ -642,6 +649,73 @@ class ConversationFiles:
 
         return None
 
+    def get_new_file_context(self, file_path: str) -> str:
+        """Return hashline content for ranges NOT yet emitted as FILE_CONTEXTS.
+
+        Append-only delta: only genuinely-new line ranges are emitted against
+        the previously-emitted intervals, so overlapping reads don't re-send
+        content already in the conversation. Nothing is removed, so the
+        conversation stays an append-only log.
+        """
+        abs_fname = os.path.abspath(file_path)
+        current = sorted(self._numbered_contexts.get(abs_fname, []))
+        if not current:
+            return ""
+        emitted = sorted(self._emitted_contexts.get(abs_fname, []))
+        delta = _subtract_intervals(current, emitted)
+        if not delta:
+            return ""
+        rendered = self._render_context_ranges(abs_fname, delta)
+        if not rendered:
+            return ""
+        # Mark everything currently requested as emitted so future reads only
+        # emit the overlap-free remainder.
+        self._emitted_contexts[abs_fname] = current
+        return rendered
+
+    def _render_context_ranges(self, abs_fname: str, ranges: List[Tuple[int, int]]) -> str:
+        """Render hashline content for the given 1-based line ranges. Returns JSON or ''."""
+        coder = self.get_coder()
+        if not coder:
+            return ""
+        try:
+            content = coder.io.read_text(abs_fname, silent=True)
+            if not content:
+                return ""
+        except Exception:
+            return ""
+        content_lines = content.splitlines()
+        results = []
+        for start_line, end_line in ranges:
+            start_line_adj = max(1, start_line)
+            end_line_adj = min(len(content_lines), end_line)
+            if start_line_adj > end_line_adj:
+                continue
+            # Hash the full file so adjacent-line hashes are consistent with ReadFile.
+            full_prefixed, _ = hashline_formatted(
+                content,
+                file_name=abs_fname,
+                total_lines=len(content_lines),
+                start_line=1,
+            )
+            prefixed_lines = full_prefixed.splitlines()
+            range_prefixed_lines = prefixed_lines[start_line_adj - 1 : end_line_adj]
+            range_prefixed_content = "\n".join(range_prefixed_lines)
+            json_str = json.dumps(
+                {
+                    "file_name": abs_fname,
+                    "start_line": start_line_adj,
+                    "end_line": end_line_adj,
+                    "total_lines": len(content_lines),
+                    "prefixed_contents": range_prefixed_content,
+                },
+                ensure_ascii=False,
+            )
+            results.append(json.loads(json_str))
+        if results:
+            return json.dumps({"file_path": abs_fname, "results": results}, ensure_ascii=False)
+        return ""
+
     def remove_file_context(self, file_path: str) -> None:
         """
         Remove all cached context for a file.
@@ -738,3 +812,30 @@ class ConversationFiles:
             "diff_count": len(self._file_diffs),
             "message_mappings": len(self._file_to_message_id),
         }
+
+
+def _subtract_intervals(
+    base: List[Tuple[int, int]], remove: List[Tuple[int, int]]
+) -> List[Tuple[int, int]]:
+    """Return the portions of ``base`` not covered by ``remove``.
+
+    Both inputs are lists of inclusive, disjoint, 1-based ``(start, end)``
+    intervals already sorted by start line. Used to compute the append-only
+    FILE_CONTEXTS delta (only genuinely-new ranges are emitted).
+    """
+    remaining = []
+    for a, b in base:
+        parts = [(a, b)]
+        for r0, r1 in remove:
+            new_parts = []
+            for s, e in parts:
+                if e < r0 or s > r1:
+                    new_parts.append((s, e))
+                else:
+                    if s < r0:
+                        new_parts.append((s, r0 - 1))
+                    if e > r1:
+                        new_parts.append((r1 + 1, e))
+            parts = new_parts
+        remaining.extend(parts)
+    return remaining