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

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

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

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

{cecli_dev-1.4.0 → cecli_dev-1.4.1rc1}/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.1rc1/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.1rc1/cecli/helpers/model_config/api.py

@@ -0,0 +1,110 @@
+"""Derive the ``api`` override block for a model.
+
+The api block holds request-level parameters. :mod:`cecli.models` merges each
+of these keys into ``extra_params`` the same way the ``api`` section of a
+``model-overrides`` entry is applied.
+
+The default reasoning effort and thinking budget are read from the config
+registry (per model) so they can be set explicitly or by the pipeline; a
+missing registry value falls back to the built-in defaults.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .identifiers import is_anthropic, is_claude_5_plus, is_gemini_2_5, is_glm, is_kimi
+from .registry import get_default
+from .utils import supports_reasoning
+
+_THINKING_BUDGET_TOKENS = 2048
+#: Default thinking budget for Gemini 2.5 models (Gemini 2.5 Pro's default).
+_GEMINI_THINKING_BUDGET_TOKENS = 8192
+#: Default reasoning effort for reasoning-capable models.
+_DEFAULT_REASONING_EFFORT = "medium"
+#: Default reasoning effort for some newer models, which use ``low``/``high``/
+#: ``max`` levels instead of the ``low``/``medium``/``high`` ladder.
+_DEFAULT_HIGH_REASONING_EFFORT = "high"
+
+
+def derive_api_config(
+    provider: Optional[str], route: str, record: Optional[Dict], model_name: Optional[str] = None
+) -> Dict:
+    """Return the ``api`` config block for a model.
+
+    Args:
+        provider: Provider portion of the model name (may be ``None``).
+        route: Model route (name after the provider prefix).
+        record: The matched model metadata record, or ``None`` for unknown models.
+        model_name: Fully qualified model name used to look up the config
+            registry; when ``None`` the built-in defaults are used.
+
+    Returns:
+        A dict of request-level params (reasoning format, thinking, tool calls).
+    """
+    reasoning = supports_reasoning(record)
+    record = record or {}
+    gemini_2_5 = is_gemini_2_5(provider, route, record)
+    api: Dict = {}
+    defaults = get_default(model_name) if model_name else {}
+
+    if reasoning and not gemini_2_5:
+        default_effort = _DEFAULT_REASONING_EFFORT
+
+        if is_glm(provider, route, record) or is_kimi(provider, route, record):
+            default_effort = _DEFAULT_HIGH_REASONING_EFFORT
+
+        effort = _resolve_reasoning_effort(defaults.get("reasoning"), default_effort)
+
+        if effort:
+            api["reasoning_effort"] = effort
+
+    if is_anthropic(provider, route, record) and not is_claude_5_plus(provider, route, record):
+        # Claude 5+ uses adaptive thinking via ``reasoning_effort`` instead of
+        # the ``thinking.type.enabled`` budget block.
+        budget = _resolve_thinking_budget(defaults.get("thinking"), _THINKING_BUDGET_TOKENS)
+
+        if budget:
+            api["thinking"] = {"type": "enabled", "budget_tokens": budget}
+    elif gemini_2_5:
+        # Gemini 2.5 configures thinking via a token budget; litellm maps the
+        # generic ``thinking`` param onto ``thinkingBudget`` + ``includeThoughts``.
+        budget = _resolve_thinking_budget(defaults.get("thinking"), _GEMINI_THINKING_BUDGET_TOKENS)
+
+        if budget:
+            api["thinking"] = {"type": "enabled", "budget_tokens": budget}
+
+    if record.get("supports_parallel_function_calling", True):
+        api["parallel_tool_calls"] = True
+
+    return api
+
+
+def _resolve_reasoning_effort(registered, default=_DEFAULT_REASONING_EFFORT):
+    """Return the default reasoning effort for a model.
+
+    ``"none"`` opts out (no default), a missing/empty registered value keeps
+    ``default``, and any other value is used verbatim.
+    """
+    if registered is None or registered == "":
+        return default
+
+    if registered == "none":
+        return None
+
+    return registered
+
+
+def _resolve_thinking_budget(registered, default):
+    """Return the default thinking budget for a model.
+
+    ``0`` opts out of a thinking level, a missing/empty registered value keeps
+    ``default``, and any other value is used verbatim.
+    """
+    if registered is None or registered == "":
+        return default
+
+    if registered == 0 or registered == "0":
+        return None
+
+    return registered

{cecli_dev-1.4.0 → cecli_dev-1.4.1rc1}/cecli/helpers/model_config/identifiers.py

@@ -64,6 +64,16 @@ def is_meta(provider, route, record):
     return provider == "meta" or record_provider == "meta"
 
 
+def is_glm(provider, route, record):
+    """True when the model is a GLM-series model (Zhipu AI / Z.ai)."""
+    return "glm" in _haystack(provider, route, record)
+
+
+def is_kimi(provider, route, record):
+    """True when the model is a Kimi-series model (Moonshot AI)."""
+    return "kimi" in _haystack(provider, route, record)
+
+
 def gpt_version(route):
     """Return the leading ``gpt-`` model version, or 0 when not a gpt model.
 

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

@@ -133,7 +133,7 @@ def _build_config(context):
     route = context["route"]
     record = context["record"]
     llm = derive_llm_config(provider, route, record)
-    api = derive_api_config(provider, route, record)
+    api = derive_api_config(provider, route, record, context["model_name"])
     agent = derive_agent_config(provider, route, record)
 
     if llm.get("mode") == "responses":

cecli_dev-1.4.1rc1/cecli/helpers/model_config/registry.py

@@ -0,0 +1,43 @@
+"""Process-wide registry of per-model reasoning/thinking defaults.
+
+The model config pipeline writes a ``{reasoning, thinking}`` entry per model
+name so :func:`derive_api_config` and :mod:`cecli.models` agree on the default
+effort/budget, even after a user overrides it with ``set_reasoning_effort`` /
+``set_thinking_tokens``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+#: Sentinel for "leave this key unchanged" so an explicit ``None`` can be stored.
+_UNSET = object()
+
+#: Singleton registry: ``{model_name: {"reasoning": ..., "thinking": ...}}``.
+default_registry: Dict[str, Dict[str, Any]] = {}
+
+
+def register_default(model_name: str, reasoning: Any = _UNSET, thinking: Any = _UNSET) -> None:
+    """Record the default reasoning/thinking config for ``model_name``.
+
+    Omitting ``reasoning`` or ``thinking`` leaves that key unchanged; passing an
+    explicit ``None`` stores ``None`` so the api derivation falls back to its
+    built-in default (``"medium"`` / the provider default budget).
+    """
+    entry = default_registry.setdefault(model_name, {})
+
+    if reasoning is not _UNSET:
+        entry["reasoning"] = reasoning
+
+    if thinking is not _UNSET:
+        entry["thinking"] = thinking
+
+
+def get_default(model_name: str) -> Dict[str, Any]:
+    """Return the registered ``{reasoning, thinking}`` defaults for ``model_name``."""
+    return default_registry.get(model_name, {})
+
+
+def clear_default_registry() -> None:
+    """Reset the registry (mainly for tests)."""
+    default_registry.clear()

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

@@ -1120,36 +1120,21 @@ async def main_async(
             "Model setting 'remove_reasoning' is deprecated, please use 'reasoning_tag' instead."
         )
     if args.reasoning_effort is not None:
-        if (
-            not args.check_model_accepts_settings
-            or main_model.accepts_settings
-            and "reasoning_effort" in main_model.accepts_settings
-        ):
-            main_model.set_reasoning_effort(args.reasoning_effort)
+        main_model.set_reasoning_effort(args.reasoning_effort)
+        if agent_model_obj:
+            agent_model_obj.set_reasoning_effort(args.reasoning_effort)
+        if weak_model_obj:
+            weak_model_obj.set_reasoning_effort(args.reasoning_effort)
+        if editor_model_obj:
+            editor_model_obj.set_reasoning_effort(args.reasoning_effort)
     if args.thinking_tokens is not None:
-        if (
-            not args.check_model_accepts_settings
-            or main_model.accepts_settings
-            and "thinking_tokens" in main_model.accepts_settings
-        ):
-            main_model.set_thinking_tokens(args.thinking_tokens)
-    if args.check_model_accepts_settings:
-        settings_to_check = [
-            {"arg": args.reasoning_effort, "name": "reasoning_effort"},
-            {"arg": args.thinking_tokens, "name": "thinking_tokens"},
-        ]
-        for setting in settings_to_check:
-            if setting["arg"] is not None and (
-                not main_model.accepts_settings
-                or setting["name"] not in main_model.accepts_settings
-            ):
-                io.tool_warning(
-                    f"Warning: {main_model.name} does not support '{setting['name']}', ignoring."
-                )
-                io.tool_output(
-                    f"Use --no-check-model-accepts-settings to force the '{setting['name']}'"
-                    " setting."
-                )
+        main_model.set_thinking_tokens(args.thinking_tokens)
+        if agent_model_obj:
+            agent_model_obj.set_thinking_tokens(args.thinking_tokens)
+        if weak_model_obj:
+            weak_model_obj.set_thinking_tokens(args.thinking_tokens)
+        if editor_model_obj:
+            editor_model_obj.set_thinking_tokens(args.thinking_tokens)
     if args.copy_paste and args.edit_format is None:
         if main_model.edit_format in ("diff", "whole", "diff-fenced"):
             main_model.edit_format = "editor-" + main_model.edit_format
@@ -1374,8 +1359,7 @@ async def main_async(
     if args.copy_paste:
         ClipboardWatcher(coder.io, verbose=args.verbose)
     if args.show_prompts:
-        coder.cur_messages += [dict(role="user", content="Hello!")]
-        messages = coder.format_messages().all_messages()
+        messages = coder.format_messages()
         utils.show_messages(messages)
         return await graceful_exit(coder)
     if args.lint:

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

@@ -22,6 +22,7 @@ from cecli.helpers.file_searcher import (
     handle_core_files,
 )
 from cecli.helpers.model_config import get_default_config
+from cecli.helpers.model_config.registry import register_default
 from cecli.helpers.model_config.utils import get_entry_from_raw
 from cecli.helpers.model_providers import ModelProviderManager
 from cecli.helpers.nested import deep_merge
@@ -980,15 +981,23 @@ class Model(ModelSettings):
     def _apply_reasoning_defaults(self):
         """Apply the default thinking/reasoning configuration at init time.
 
-        The model config pipeline's ``api`` block decides which mechanism a
-        model uses: anthropic-family models configure ``thinking`` tokens while
-        everything else uses a reasoning effort.  ``override_kwargs`` applied
-        later in ``_apply_structured_kwargs`` win over these defaults.
+        The model config pipeline's ``api`` block carries the reasoning effort
+        and/or thinking budget the model uses; the config registry records the
+        defaults so they initialize from the api block or an explicit user
+        override.  ``override_kwargs`` applied later in
+        ``_apply_structured_kwargs`` win over these defaults.
         """
+        register_default(
+            self.name,
+            reasoning=self._default_reasoning_effort,
+            thinking=self._default_thinking_budget,
+        )
+
+        if self._default_reasoning_effort is not None:
+            self.set_reasoning_effort(self._default_reasoning_effort)
+
         if self._default_thinking_budget is not None:
             self.set_thinking_tokens(self._default_thinking_budget)
-        elif self._default_reasoning_effort is not None:
-            self.set_reasoning_effort(self._default_reasoning_effort)
 
     def tokenizer(self, text):
         return litellm.encode(model=self.name, text=text)
@@ -1140,6 +1149,8 @@ class Model(ModelSettings):
         the effort onto the provider's own field (e.g. Gemini's
         ``thinking_level``).
         """
+        register_default(self.name, reasoning=effort)
+
         if not self.extra_params:
             self.extra_params = {}
 
@@ -1221,6 +1232,7 @@ class Model(ModelSettings):
         """
         if value is not None:
             num_tokens = self.parse_token_value(value)
+            register_default(self.name, thinking=num_tokens)
             self.use_temperature = False
             if not self.extra_params:
                 self.extra_params = {}

{cecli_dev-1.4.0 → cecli_dev-1.4.1rc1}/cecli/prompts/agent.yml

@@ -28,7 +28,7 @@ main_system: |
   ## FILE FORMAT
   File contents are presented with virtual prefix identifiers to help you target edits accurately. These are generated on-the-fly when reading the file.
 
-  - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line, excluding the prefix.
+  - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line.
   - **Duplicate Lines (e.g., `—“0车加—`):** Lines that appear multiple times are prefixed with an opaque identifier. You MUST include this exact identifier when targeting these lines to disambiguate which specific instance you want to edit.
 
   **Example File**

{cecli_dev-1.4.0 → cecli_dev-1.4.1rc1}/cecli/prompts/subagent.yml

@@ -13,7 +13,7 @@ main_system: |
   ## FILE FORMAT
   File contents are presented with virtual prefix identifiers to help you target edits accurately. These are generated on-the-fly when reading the file.
 
-  - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line, excluding the prefix.
+  - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line.
   - **Duplicate Lines (e.g., `—“0车加—`):** Lines that appear multiple times are prefixed with an opaque identifier. You MUST include this exact identifier when targeting these lines to disambiguate which specific instance you want to edit.
 
   **Example File**