cecli-dev 1.1.0rc2__tar.gz → 1.2.0rc1__tar.gz

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.1.0rc2
+Version: 1.2.0rc1
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -27,7 +27,7 @@ Requires-Dist: watchfiles>=1.1.0
 Requires-Dist: charset-normalizer>=3.4.7
 Requires-Dist: GitPython>=3.1.45
 Requires-Dist: pathspec>=0.12.1
-Requires-Dist: litellm!=1.82.7,!=1.82.8,>=1.80.11
+Requires-Dist: requests>=2.32.0
 Requires-Dist: mcp>=1.24.0
 Requires-Dist: socksio>=1.0.0
 Requires-Dist: truststore
@@ -56,7 +56,6 @@ Requires-Dist: marisa-trie>=1.0
 Requires-Dist: ngram>=4.0.3
 Requires-Dist: rapidfuzz>=3.0
 Requires-Dist: rustworkx>=0.15.0
-Requires-Dist: scipy>=1.15.3
 Requires-Dist: orjson>=3.11.6
 Requires-Dist: py-cymbal>=0.2.1
 Requires-Dist: importlib-metadata>=7.2.1
@@ -95,9 +94,12 @@ Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"
 Dynamic: license-file
 
-## Why `cecli`?
+<p align="center">
+  <img src="cecli/website/assets/cecli-temp-logo-dark.svg" alt="cecli logo" width="300" height="96">
+</p>
 
-`cecli` (probably pronounced like "Cecily") is yet another cli agent crafted for extensibility and customization. Originally a fork of the [Aider](https://cecli.dev/) AI pair programming tool, we aim to make agentic coding as maximally effective as it can be based on the incredible capabilities of large language models.
+
+`cecli` is yet another cli agent crafted for extensibility and customization. For folks who like seeing under the hood, welcome to the fold. Made for nerds, geeks, and the extremely curious.
 
 
 ### Links

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/README.md

@@ -1,6 +1,9 @@
-## Why `cecli`?
+<p align="center">
+  <img src="cecli/website/assets/cecli-temp-logo-dark.svg" alt="cecli logo" width="300" height="96">
+</p>
 
-`cecli` (probably pronounced like "Cecily") is yet another cli agent crafted for extensibility and customization. Originally a fork of the [Aider](https://cecli.dev/) AI pair programming tool, we aim to make agentic coding as maximally effective as it can be based on the incredible capabilities of large language models.
+
+`cecli` is yet another cli agent crafted for extensibility and customization. For folks who like seeing under the hood, welcome to the fold. Made for nerds, geeks, and the extremely curious.
 
 
 ### Links

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "1.0.5.dev"
+__version__ = "1.2.0.dev"
 safe_version = __version__
 
 try:

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.0rc2'
-__version_tuple__ = version_tuple = (1, 1, 0, 'rc2')
+__version__ = version = '1.2.0rc1'
+__version_tuple__ = version_tuple = (1, 2, 0, 'rc1')
 
-__commit_id__ = commit_id = 'g08300992a'
+__commit_id__ = commit_id = 'g040092f96'

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/coders/agent_coder.py

@@ -27,7 +27,6 @@ from cecli.helpers.similarity import (
 )
 from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
-from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
 from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
@@ -364,16 +363,12 @@ class AgentCoder(Coder):
             }
             try:
                 session = await server.connect()
-                call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                    session=session, openai_tool=tool_call_dict
-                )
+                call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
             except Exception as e:
                 if server.is_session_expired_error(e):
                     try:
                         session = await server.reconnect()
-                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                            session=session, openai_tool=tool_call_dict
-                        )
+                        call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
                     except Exception as retry_exc:
                         self.io.tool_warning(
                             f"Executing {tool_name} on {server.name} failed after reconnect:\n"

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/coders/base_coder.py

@@ -851,12 +851,12 @@ class Coder(metaclass=UsageMeta):
         settings_items.append(f"{self.edit_format} (edit format)")
 
         # Thinking tokens
-        thinking_tokens = main_model.get_thinking_tokens()
+        thinking_tokens = self.get_active_model().get_thinking_tokens()
         if thinking_tokens:
             settings_items.append(f"{thinking_tokens} think tokens")
 
         # Reasoning effort
-        reasoning_effort = main_model.get_reasoning_effort()
+        reasoning_effort = self.get_active_model().get_reasoning_effort()
         if reasoning_effort:
             settings_items.append(f"reasoning {reasoning_effort}")
 
@@ -3060,7 +3060,7 @@ class Coder(metaclass=UsageMeta):
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
-        import httpx
+        from cecli.http import httpx
 
         tool_responses = []
         try:
@@ -3110,19 +3110,14 @@ class Coder(metaclass=UsageMeta):
 
                         async def do_tool_call():
                             nonlocal session
-                            from litellm import experimental_mcp_client
 
                             try:
-                                return await experimental_mcp_client.call_openai_tool(
-                                    session=session,
-                                    openai_tool=new_tool_call,
-                                )
+                                return await self.call_mcp_tool_from_session(session, new_tool_call)
                             except Exception as e:
                                 if server.is_session_expired_error(e):
                                     session = await server.reconnect()
-                                    return await experimental_mcp_client.call_openai_tool(
-                                        session=session,
-                                        openai_tool=new_tool_call,
+                                    return await self.call_mcp_tool_from_session(
+                                        session, new_tool_call
                                     )
                                 raise
 
@@ -3209,6 +3204,34 @@ class Coder(metaclass=UsageMeta):
 
         return tool_responses
 
+    async def call_mcp_tool_from_session(self, session, tool_call):
+        """Call an MCP tool from an OpenAI-style tool call using the native SDK.
+
+        Accepts either a dict (``{"function": {"name": ..., "arguments": ...}}``)
+        or a tool-call object (e.g. litellm's ChatCompletionMessageToolCall) and
+        invokes the MCP session directly, avoiding litellm's lazily-imported
+        ``experimental_mcp_client`` submodule.
+        """
+        if isinstance(tool_call, dict):
+            function = tool_call.get("function", {})
+            name = function.get("name")
+            arguments = function.get("arguments", {})
+        else:
+            function = getattr(tool_call, "function", None)
+            name = getattr(function, "name", None)
+            arguments = getattr(function, "arguments", {})
+
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError:
+                arguments = {}
+
+        if not isinstance(arguments, dict):
+            arguments = {}
+
+        return await session.call_tool(name=name, arguments=arguments)
+
     async def process_tool_calls(self, tool_call_response):
         """Simplified main entry point."""
         # Check if max tool calls exceeded
@@ -3468,9 +3491,9 @@ class Coder(metaclass=UsageMeta):
         msg = response_dict["choices"][0]["message"]
 
         if self.partial_response_tool_calls:
-            msg["tool_calls"] = self.partial_response_tool_calls
+            msg["tool_calls"] = [_tool_call_to_dict(tc) for tc in self.partial_response_tool_calls]
         elif self.partial_response_function_call:
-            msg["function_call"] = self.partial_response_function_call
+            msg["function_call"] = _function_call_to_dict(self.partial_response_function_call)
 
         if "reasoning_content" not in msg:
             msg["reasoning_content"] = self.partial_response_reasoning_content
@@ -3588,7 +3611,7 @@ class Coder(metaclass=UsageMeta):
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         self.interrupt_event.clear()
         self.got_reasoning_content = False
@@ -3722,7 +3745,7 @@ class Coder(metaclass=UsageMeta):
                     self.io.ai_output(json.dumps(args, indent=4))
 
     async def show_send_output(self, completion):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         if self.verbose:
             print(completion)
@@ -3985,6 +4008,15 @@ class Coder(metaclass=UsageMeta):
                         for key, value in psf.items():
                             if isinstance(value, list):
                                 message_provider_specific_fields.setdefault(key, []).extend(value)
+                            elif (
+                                key in message_provider_specific_fields
+                                and isinstance(message_provider_specific_fields[key], dict)
+                                and isinstance(value, dict)
+                            ):
+                                # Merge dict-valued metadata (e.g. gemini per-call
+                                # function_call_signatures) so parallel tool calls
+                                # each keep their own signature across chunks.
+                                message_provider_specific_fields[key].update(value)
                             elif value is not None:
                                 message_provider_specific_fields[key] = value
             except (AttributeError, IndexError):
@@ -4078,7 +4110,8 @@ class Coder(metaclass=UsageMeta):
         parallel call is preserved, correctly ordered, and keeps its
         provider-specific fields (e.g. thought signatures) attached.
         """
-        from litellm.types.utils import ChatCompletionMessageToolCall, Function
+        ChatCompletionMessageToolCall = litellm.types.utils.ChatCompletionMessageToolCall
+        Function = litellm.types.utils.Function
 
         tool_calls_dict = {}
 
@@ -4248,15 +4281,12 @@ class Coder(metaclass=UsageMeta):
 
         self.message_tokens_received += completion_tokens
 
-        # Build the new streamlined format
-        tokens_parts = [format_tokens(prompt_tokens)]
-
-        if cache_hit_tokens:
-            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
-        if cache_write_tokens:
-            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
-
-        tokens_str = "/".join(tokens_parts)
+        # Build tokens string as "{prompt} CH {hit_rate:.1f}% ↑ {completion} ↓"
+        if prompt_tokens > 0:
+            hit_rate = round(cache_hit_tokens / prompt_tokens * 100, 1) if cache_hit_tokens else 0.0
+        else:
+            hit_rate = 0.0
+        tokens_str = f"{format_tokens(prompt_tokens)} ◇ {hit_rate:.1f}%"
 
         tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
 
@@ -4271,12 +4301,17 @@ class Coder(metaclass=UsageMeta):
             + self.message_tokens_received
         )
         total_combined_cached = self.total_cached_tokens + self.message_cached_tokens
+        total_input_tokens = self.total_tokens_sent + self.message_tokens_sent
+        if total_input_tokens > 0:
+            total_hit_rate = (
+                round(total_combined_cached / total_input_tokens * 100, 1)
+                if total_combined_cached
+                else 0.0
+            )
+        else:
+            total_hit_rate = 0.0
 
-        total_stats = f"{format_tokens(total_combined_tokens)}"
-        if total_combined_cached:
-            total_stats += f"/{format_tokens(total_combined_cached)}"
-
-        total_stats += " ↑↓"
+        total_stats = f"{format_tokens(total_combined_tokens)} ◇ {total_hit_rate:.1f}% ↑↓"
 
         if not self.get_active_model().info.get("input_cost_per_token"):
             self.usage_report = tokens_report + " " + total_stats
@@ -4607,7 +4642,12 @@ class Coder(metaclass=UsageMeta):
     def parse_partial_args(self):
         # dump(self.partial_response_function_call)
 
-        data = self.partial_response_function_call.get("arguments")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            data = function_call.get("arguments")
+        else:
+            data = getattr(function_call, "arguments", None)
+
         if not data:
             return
 
@@ -4885,3 +4925,25 @@ class Coder(metaclass=UsageMeta):
         else:
             # Append the command to the prefix with a space
             return f"{command_prefix} {command}"
+
+
+def _tool_call_to_dict(tc):
+    """Normalize a tool call (dict or litellm-shaped object) to a wire-format dict."""
+    if isinstance(tc, dict):
+        return tc
+
+    if hasattr(tc, "to_dict"):
+        return tc.to_dict()
+
+    return tc
+
+
+def _function_call_to_dict(function_call):
+    """Normalize a function call (dict or litellm-shaped Function) to a dict."""
+    if isinstance(function_call, dict):
+        return function_call
+
+    if hasattr(function_call, "to_dict"):
+        return function_call.to_dict()
+
+    return function_call

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/coders/copypaste_coder.py

@@ -259,11 +259,11 @@ def get_copy_paste_coder_class(edit_format, main_model):
             ],
             created=int(time.time()),
             model=model.name,
-            usage={
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": total_tokens,
-            },
+            usage=litellm.Usage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens,
+            ),
         )
 
         kwargs = dict(model=model.name, messages=messages, stream=False)

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/coders/editblock_func_coder.py

@@ -92,7 +92,11 @@ class EditBlockFunctionCoder(Coder):
         return res
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
 
         if name and name != "replace_lines":
             raise ValueError(f'Unknown function_call name="{name}", use name="replace_lines"')

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/coders/wholefile_func_coder.py

@@ -113,7 +113,11 @@ class WholeFileFunctionCoder(Coder):
         return "\n".join(show_diff)
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
         if name and name != "write_file":
             raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
 

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/commands/add.py

@@ -132,7 +132,24 @@ class AddCommand(BaseCommand):
                         f" {active_model.name} does not support images."
                     )
                     continue
-                content = io.read_text(abs_file_path)
+                try:
+                    content = io.read_text(abs_file_path)
+                except (ValueError, UnicodeError, UnicodeDecodeError, OSError) as exc:
+                    # Binary or undecodable files (e.g. .git/objects/pack/*.rev)
+                    # raise ValueError("Could not determine text encoding ...")
+                    # from decoding.safe_open. Skip them gracefully instead of
+                    # crashing the session.
+                    msg = str(exc)
+                    if "Could not determine text encoding" in msg or isinstance(
+                        exc, (UnicodeError, UnicodeDecodeError)
+                    ):
+                        io.tool_warning(
+                            f"Skipping {matched_file}: not decodable as text "
+                            "(binary or unknown encoding)"
+                        )
+                    else:
+                        io.tool_error(f"Skipping {matched_file}: {exc}")
+                    continue
                 if content is None:
                     io.tool_error(f"Unable to read {matched_file}")
                 else:

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/exceptions.py

@@ -62,7 +62,7 @@ class LiteLLMExceptions:
         self._load()
 
     def _load(self, strict=False):
-        import litellm
+        from cecli.llm import litellm
 
         for var in dir(litellm):
             if var.endswith("Error"):
@@ -83,7 +83,7 @@ class LiteLLMExceptions:
 
     def get_ex_info(self, ex):
         """Return the ExInfo for a given exception instance"""
-        import litellm
+        from cecli.llm import litellm
 
         if ex.__class__ is litellm.APIConnectionError:
             if "google.auth" in str(ex):

{cecli_dev-1.1.0rc2 → cecli_dev-1.2.0rc1}/cecli/helpers/leak_detect.py

@@ -275,61 +275,81 @@ class MemorySnapshot:
 
     # ── Report ──
 
-    def print_report(self) -> None:
-        """Print a human-readable memory report to stdout."""
-        print("=" * 70)
-        print("MemorySnapshot Report")
-        print(f"  Objects scanned : {len(self._all_objects):,}")
+    def print_report(self, out: Optional[Any] = None) -> None:
+        """Print a human-readable memory report to *out* (defaults to sys.stdout).
+
+        Passing a file-like object (e.g. ``io.StringIO``) allows callers to
+        capture the report as text instead of writing to the terminal.
+        """
+        if out is None:
+            out = sys.stdout
+
+        print("=" * 70, file=out)
+        print("MemorySnapshot Report", file=out)
+        print(f"  Objects scanned : {len(self._all_objects):,}", file=out)
         print(
-            f"  Deep sizes      : {'yes (pympler)' if self._has_pympler else 'no (sys.getsizeof)'}"
+            f"  Deep sizes      : {'yes (pympler)' if self._has_pympler else 'no (sys.getsizeof)'}",
+            file=out,
         )
-        print(f"  Guppy available  : {'yes' if self._has_guppy else 'no'}")
-        print("=" * 70)
+        print(f"  Guppy available  : {'yes' if self._has_guppy else 'no'}", file=out)
+        print("=" * 70, file=out)
 
         # 1. Largest objects
-        print("\n>> TOP 15 LARGEST OBJECTS (any type)")
-        print("  " + "-" * 60)
+        print("\n>> TOP 15 LARGEST OBJECTS (any type)", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_objects(15):
-            print(f"  {item.size_kb:>10.1f} KB  {item.type_name:<15s}  {item.repr_str}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  {item.type_name:<15s}  {item.repr_str}",
+                file=out,
+            )
 
         # 2. Largest dicts
-        print("\n>> LARGEST DICTS")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST DICTS", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_dicts(5):
             d = item.obj
             keys_preview = list(d.keys())[:5] if isinstance(d, dict) else []
-            print(f"  {item.size_kb:>10.1f} KB  dict[{len(d)} keys]  keys={keys_preview!r}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  dict[{len(d)} keys]  keys={keys_preview!r}",
+                file=out,
+            )
 
         # 3. Largest lists
-        print("\n>> LARGEST LISTS")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST LISTS", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_lists(5):
             lst = item.obj
             first = lst[0] if lst else "empty"
-            print(f"  {item.size_kb:>10.1f} KB  list[{len(lst)} items]  first={first!r}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  list[{len(lst)} items]  first={first!r}",
+                file=out,
+            )
 
         # 4. Largest class instances
-        print("\n>> LARGEST CLASS INSTANCES (custom)")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST CLASS INSTANCES (custom)", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_class_instances(n=10):
-            print(f"  {item.size_kb:>10.1f} KB  {item.type_name}")
+            print(f"  {item.size_kb:>10.1f} KB  {item.type_name}", file=out)
 
         # 5. Type summary
-        print("\n>> TYPE SUMMARY (total size per type)")
-        print("  " + "-" * 60)
+        print("\n>> TYPE SUMMARY (total size per type)", file=out)
+        print("  " + "-" * 60, file=out)
         for ts in self.type_summary(12):
-            print(f"  {ts.total_size_kb:>10.1f} KB  ({ts.count:>7,} objs)  {ts.type_name}")
+            print(
+                f"  {ts.total_size_kb:>10.1f} KB  ({ts.count:>7,} objs)  {ts.type_name}",
+                file=out,
+            )
 
         # 6. Guppy summary if available
         if self._has_guppy:
-            print("\n>> GUPPY HEAP SUMMARY")
-            print("  " + "-" * 60)
+            print("\n>> GUPPY HEAP SUMMARY", file=out)
+            print("  " + "-" * 60, file=out)
             summary = self.guppy_summary()
             if summary:
                 for line in summary.split("\n"):
-                    print(f"  {line}")
+                    print(f"  {line}", file=out)
 
-        print()
+        print(file=out)
 
     # ── Internal helpers ──
 

cecli_dev-1.2.0rc1/cecli/helpers/llms/__init__.py

@@ -0,0 +1,35 @@
+"""LiteLLM-free LLM communication stack for cecli.
+
+The ``cecli.helpers.llms`` package replaces the litellm-backed call path with a
+small, lazy-loading dispatcher that mirrors the structure of
+``cecli/helpers/model_config/``:
+
+- :mod:`cecli.helpers.llms.config` - provider defaults + model config resolution
+- :mod:`cecli.helpers.llms.domains` - one module per API family (chat,
+  responses, messages, gemini)
+- :mod:`cecli.helpers.llms.providers` - per-provider custom logic (auth,
+  headers, response repair) with an extensible :class:`ProviderAdapter` base
+- :mod:`cecli.helpers.llms.formatters` - sectional per-domain formatters
+  (reasoning, thinking)
+- :mod:`cecli.helpers.llms.pipeline` - the ``acompletion()`` dispatcher
+
+Public API: :func:`acompletion`, :func:`resolve_model_config`,
+:func:`get_api_key`.
+"""
+
+from __future__ import annotations
+
+from .config import get_api_key, resolve_model_config
+from .pipeline import acompletion
+from .runtime import set_verify_ssl
+from .types import CompletionChunk, CompletionResponse, ToolCall
+
+__all__ = [
+    "acompletion",
+    "resolve_model_config",
+    "get_api_key",
+    "CompletionResponse",
+    "CompletionChunk",
+    "ToolCall",
+    "set_verify_ssl",
+]