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

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1rc2}/.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.1rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.4.0rc1
+Version: 1.4.1rc2
 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.1rc2}/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.1rc2'
+__version_tuple__ = version_tuple = (1, 4, 1, 'rc2')
 
-__commit_id__ = commit_id = 'ge2f9c56b1'
+__commit_id__ = commit_id = 'g7e601aafa'

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1rc2}/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
 
@@ -4962,13 +4962,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.1rc2}/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.1rc2}/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.1rc2/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.1rc2}/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.1rc2}/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

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

@@ -762,8 +762,8 @@ class ConversationChunks:
             if not ranges:
                 continue
 
-            # Generate context content
-            context_content = ConversationService.get_files(coder).get_file_context(file_path)
+            # Generate context content (append-only delta: only new ranges are emitted)
+            context_content = ConversationService.get_files(coder).get_new_file_context(file_path)
             if not context_content:
                 continue
 
@@ -775,6 +775,9 @@ class ConversationChunks:
                 "content": f"ID-Prefixed Context For:\n{rel_fname}\n\n{context_content}",
             }
 
+            # Append-only: new FILE_CONTEXTS blocks are added, never removed, so
+            # the conversation message stream stays a log (no prefix rewrite).
+
             # Add to conversation manager
             content_hash = xxhash.xxh3_128_hexdigest(context_content.encode("utf-8"))
             ConversationService.get_manager(coder).queue_message(

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1rc2}/cecli/helpers/llms/config.py

@@ -159,6 +159,7 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         "extra_headers": extra_headers,
         "extra_body": extra_body,
         "extra_query": dict(pcfg.get("extra_query") or {}),
+        "session_header": mpm.get_provider_session_header(provider),
         "api_block": api_block,
         "llm_block": llm_block,
         "agent_block": agent_block,

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1rc2}/cecli/helpers/llms/litellm_compat.py

@@ -395,6 +395,8 @@ class _FacadeException(Exception):
     ) -> None:
         super().__init__(message or "")
         self.status_code = status_code
+        for k, v in kwargs.items():
+            setattr(self, k, v)
 
 
 class APIConnectionError(_FacadeException):
@@ -508,21 +510,23 @@ def _translate_http_error(err: httpx.HTTPStatusError) -> _FacadeException:
     if status == 400 and any(
         token in body for token in ("context", "context_length", "maximum context")
     ):
-        return ContextWindowExceededError(message=message, status_code=status)
+        return ContextWindowExceededError(
+            message=message, status_code=status, response=err.response
+        )
 
     if status in (401, 403):
-        return AuthenticationError(message=message, status_code=status)
+        return AuthenticationError(message=message, status_code=status, response=err.response)
 
     if status == 404:
-        return NotFoundError(message=message, status_code=status)
+        return NotFoundError(message=message, status_code=status, response=err.response)
 
     if status == 429:
-        return RateLimitError(message=message, status_code=status)
+        return RateLimitError(message=message, status_code=status, response=err.response)
 
     if status >= 500:
-        return InternalServerError(message=message, status_code=status)
+        return InternalServerError(message=message, status_code=status, response=err.response)
 
-    return APIError(message=message, status_code=status)
+    return APIError(message=message, status_code=status, response=err.response)
 
 
 # ---------------------------------------------------------------------------

{cecli_dev-1.4.0rc1 → cecli_dev-1.4.1rc2}/cecli/helpers/llms/pipeline.py

@@ -58,6 +58,17 @@ async def acompletion(
 
     headers = dict(resolved.get("extra_headers") or {})
     headers.update(extra_headers or {})
+
+    # Some providers expose a ``session_header`` that carries the per-session
+    # prompt cache key (unique per agent session).
+    session_header = resolved.get("session_header")
+
+    if session_header:
+        prompt_cache_key = kwargs.get("prompt_cache_key")
+
+        if prompt_cache_key:
+            headers[session_header] = prompt_cache_key
+
     headers = provider.build_headers(resolved, key, family, headers)
 
     if stream: