cecli-dev 0.100.10rc2__tar.gz → 0.100.11__tar.gz

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.10rc2
+Version: 0.100.11
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -51,7 +51,7 @@ Requires-Dist: textual>=6.0.0
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
-Requires-Dist: py-cymbal>=0.1.24
+Requires-Dist: py-cymbal>=0.2.1
 Requires-Dist: cryptography>=42.0.0
 Requires-Dist: json-repair>=0.60.1
 Requires-Dist: marisa-trie>=1.0

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/__init__.py

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

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.10rc2'
-__version_tuple__ = version_tuple = (0, 100, 10, 'rc2')
+__version__ = version = '0.100.11'
+__version_tuple__ = version_tuple = (0, 100, 11)
 
-__commit_id__ = commit_id = 'g0bbb611c7'
+__commit_id__ = commit_id = 'g5eefbfaeb'

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/args.py

@@ -43,15 +43,10 @@ def get_parser(default_config_files, git_root):
     # List of valid edit formats for argparse validation & shtab completion.
     # Dynamically gather them from the registered coder classes so the list
     # stays in sync if new formats are added.
-    from cecli import coders as _cecli_coders
+    from cecli.coders import EDIT_FORMAT_MAP
+
+    edit_format_choices = sorted(EDIT_FORMAT_MAP.keys())
 
-    edit_format_choices = sorted(
-        {
-            c.edit_format
-            for c in _cecli_coders.__all__
-            if hasattr(c, "edit_format") and c.edit_format is not None
-        }
-    )
     group = parser.add_argument_group("Main model")
     group.add_argument(
         "files", metavar="FILE", nargs="*", help="files to edit with an LLM (optional)"
@@ -1115,6 +1110,16 @@ def get_parser(default_config_files, git_root):
             " specified, a default command for your OS may be used."
         ),
     )
+    group.add_argument(
+        "--notification-bell",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Allow notification commands to produce an audible bell. When enabled, command"
+            " output is not suppressed so terminal bell escape sequences can ring through"
+            " (default: True)"
+        ),
+    )
     group.add_argument(
         "--command-prefix",
         default=None,

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/coders/__init__.py

@@ -44,6 +44,26 @@ _MODULE_MAP = {
 }
 
 
+EDIT_FORMAT_MAP = {
+    "help": "HelpCoder",
+    "ask": "AskCoder",
+    "diff": "EditBlockCoder",
+    "diff-fenced": "EditBlockFencedCoder",
+    "whole": "WholeFileCoder",
+    "patch": "PatchCoder",
+    "udiff": "UnifiedDiffCoder",
+    "udiff-simple": "UnifiedDiffSimpleCoder",
+    "architect": "ArchitectCoder",
+    "editor-diff": "EditorEditBlockCoder",
+    "editor-whole": "EditorWholeFileCoder",
+    "editor-diff-fenced": "EditorDiffFencedCoder",
+    "context": "ContextCoder",
+    "agent": "AgentCoder",
+    "hashline": "HashLineCoder",
+    "subagent": "SubAgentCoder",
+}
+
+
 def __getattr__(name):
     if name in _MODULE_MAP:
         import importlib

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/coders/agent_coder.py

@@ -157,9 +157,11 @@ class AgentCoder(Coder):
         config["large_file_token_threshold"] = nested.getter(
             config, "large_file_token_threshold", 8192
         )
+        config["show_lint_errors"] = nested.getter(config, "show_lint_errors", False)
         config["skip_cli_confirmations"] = nested.getter(
             config, "skip_cli_confirmations", nested.getter(config, "yolo", [])
         )
+
         config["command_timeout"] = nested.getter(config, "command_timeout", 30)
         config["allowed_commands"] = nested.getter(config, "allowed_commands", [])
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
@@ -816,6 +818,11 @@ class AgentCoder(Coder):
             if interrupted:
                 raise KeyboardInterrupt("Interrupted during linting")
 
+            has_errors = False
+
+            if self.lint_outcome is False:
+                has_errors = True
+
             self.lint_outcome = not lint_errors
 
             if lint_errors:
@@ -824,21 +831,35 @@ class AgentCoder(Coder):
                     "# Fix any linting errors below, if possible and then continue with your task.",
                     1,
                 )
-                ConversationService.get_manager(self).remove_message_by_hash_key(
-                    ("lint_errors", "agent")
-                )
                 ConversationService.get_manager(self).add_message(
                     message_dict=dict(role="user", content=lint_errors),
-                    tag=MessageTag.CUR,
-                    hash_key=("lint_errors", "agent"),
+                    tag=MessageTag.LINT,
+                    hash_key=("lint_errors", "agent", lint_errors),
+                )
+                ConversationService.get_manager(self).add_message(
+                    message_dict=dict(
+                        role="user", content="Please address the latest linting errors."
+                    ),
+                    tag=MessageTag.LINT,
+                    hash_key=("lint_errors", "agent", lint_errors, "cta"),
                     promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
                     mark_for_demotion=1,
-                    force=True,
+                    mark_for_delete=0,
                 )
             else:
-                ConversationService.get_manager(self).remove_message_by_hash_key(
-                    ("lint_errors", "agent")
-                )
+                if has_errors:
+                    ConversationService.get_manager(self).add_message(
+                        message_dict=dict(
+                            role="user",
+                            content=(
+                                '<context name="linting_confirmation" from="agent">'
+                                "All linting errors resolved."
+                                "</context>"
+                            ),
+                        ),
+                        tag=MessageTag.LINT,
+                        hash_key=("lint_errors", "agent", str(time.monotonic_ns())),
+                    )
 
         return tool_responses
 

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/coders/base_coder.py

@@ -105,28 +105,6 @@ all_fences = [
     wrap_fence("sourcecode"),
 ]
 
-# Map of edit_format values to coder class names.
-# Used by Coder.create() to find the right coder class by edit_format
-# without importing all coder modules.
-EDIT_FORMAT_MAP = {
-    "help": "HelpCoder",
-    "ask": "AskCoder",
-    "diff": "EditBlockCoder",
-    "diff-fenced": "EditBlockFencedCoder",
-    "whole": "WholeFileCoder",
-    "patch": "PatchCoder",
-    "udiff": "UnifiedDiffCoder",
-    "udiff-simple": "UnifiedDiffSimpleCoder",
-    "architect": "ArchitectCoder",
-    "editor-diff": "EditorEditBlockCoder",
-    "editor-whole": "EditorWholeFileCoder",
-    "editor-diff-fenced": "EditorDiffFencedCoder",
-    "context": "ContextCoder",
-    "agent": "AgentCoder",
-    "hashline": "HashLineCoder",
-    "subagent": "SubAgentCoder",
-}
-
 
 class UsageMeta(type):
     """Metaclass that provides shared accumulator properties across all Coder subclasses.
@@ -336,6 +314,7 @@ class Coder(metaclass=UsageMeta):
                 uuid=from_coder.uuid,
                 parent_uuid=from_coder.parent_uuid,
                 repo=from_coder.repo,
+                summarizer=from_coder.summarizer,
             )
             use_kwargs.update(update)  # override to complete the switch
             use_kwargs.update(kwargs)  # override passed kwargs
@@ -351,7 +330,7 @@ class Coder(metaclass=UsageMeta):
             res = coders.CopyPasteCoder(main_model, io, args=args, **kwargs)
 
         if not res:
-            coder_name = EDIT_FORMAT_MAP.get(edit_format)
+            coder_name = coders.EDIT_FORMAT_MAP.get(edit_format)
             if coder_name:
                 coder_cls = getattr(coders, coder_name)
                 res = coder_cls(main_model, io, args=args, **kwargs)
@@ -373,10 +352,14 @@ class Coder(metaclass=UsageMeta):
 
             await res.initialize_mcp_tools()
 
-            res.original_kwargs = dict(kwargs)
+            # Store only small/primitive kwargs to avoid retaining large object references.
+            # Large objects (repo, mcp_manager, commands, summarizer, file_watcher, etc.)
+            # are either overridden during clone() or accessible from instance attributes.
+            _LARGE_KWARGS = {"repo", "mcp_manager", "commands", "summarizer", "file_watcher"}
+            res.original_kwargs = {k: v for k, v in kwargs.items() if k not in _LARGE_KWARGS}
             return res
 
-        valid_formats = list(EDIT_FORMAT_MAP.keys())
+        valid_formats = list(coders.EDIT_FORMAT_MAP.keys())
         raise UnknownEditFormat(edit_format, valid_formats)
 
     async def clone(self, **kwargs):
@@ -491,6 +474,7 @@ class Coder(metaclass=UsageMeta):
         self.mcp_manager = mcp_manager
         self.enable_context_compaction = enable_context_compaction
 
+        self.context_compaction_current_ratio = 0
         self.context_compaction_max_tokens = context_compaction_max_tokens
         self.context_compaction_summary_tokens = context_compaction_summary_tokens
         self.max_reflections = nested.getter(self.args, "max_reflections", 3)
@@ -1439,7 +1423,10 @@ class Coder(metaclass=UsageMeta):
             if mime_type.startswith("image/") and supports_images:
                 content = [
                     {"type": "text", "text": f"Image file: {rel_fname}"},
-                    {"type": "image_url", "image_url": {"url": image_url, "detail": "high"}},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": image_url, "detail": "high", "format": mime_type},
+                    },
                 ]
             elif mime_type == "application/pdf" and supports_pdfs:
                 content = [
@@ -2000,12 +1987,15 @@ class Coder(metaclass=UsageMeta):
 
         combined_tokens = done_tokens + cur_tokens + diff_tokens
 
+        self.context_compaction_current_ratio = all_tokens / self.context_compaction_max_tokens
+
         if force or (
             all_tokens >= self.context_compaction_max_tokens * 0.9
-            and ConversationService.get_chunks(self).last_clear_count > 10
+            and ConversationService.get_chunks(self).last_clear_count > 20
         ):
-            manager.clear_tag(MessageTag.DIFFS)
-            manager.clear_tag(MessageTag.FILE_CONTEXTS)
+            manager.clear_tag(MessageTag.LINT, ratio=0.33)
+            manager.clear_tag(MessageTag.DIFFS, ratio=0.33)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS, ratio=0.33)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
 
@@ -3248,6 +3238,12 @@ class Coder(metaclass=UsageMeta):
                 res += errors
                 res += "\n"
 
+        if self.edit_format in ("agent", "subagent"):
+            if self.agent_config.get("show_lint_errors"):
+                show_output = True
+            else:
+                show_output = False
+
         if res and show_output:
             self.io.tool_warning(res)
 
@@ -4023,7 +4019,9 @@ class Coder(metaclass=UsageMeta):
         input_cost_per_token = self.get_active_model().info.get("input_cost_per_token") or 0
         output_cost_per_token = self.get_active_model().info.get("output_cost_per_token") or 0
         input_cost_per_token_cache_hit = (
-            self.get_active_model().info.get("input_cost_per_token_cache_hit") or 0
+            self.get_active_model().info.get("input_cost_per_token_cache_hit")
+            or self.get_active_model().info.get("cache_read_input_token_cost")
+            or 0
         )
 
         # deepseek
@@ -4035,14 +4033,13 @@ class Coder(metaclass=UsageMeta):
         #    == total tokens that were
 
         if input_cost_per_token_cache_hit:
-            # must be deepseek
-            cost += input_cost_per_token_cache_hit * cache_hit_tokens
-            cost += (prompt_tokens - input_cost_per_token_cache_hit) * input_cost_per_token
+            cost += cache_hit_tokens * input_cost_per_token_cache_hit
+            cost += (prompt_tokens - cache_hit_tokens) * input_cost_per_token
         else:
             # hard code the anthropic adjustments, no-ops for other models since cache_x_tokens==0
             cost += cache_write_tokens * input_cost_per_token * 1.25
             cost += cache_hit_tokens * input_cost_per_token * 0.10
-            cost += prompt_tokens * input_cost_per_token
+            cost += (prompt_tokens - cache_hit_tokens) * input_cost_per_token
 
         cost += completion_tokens * output_cost_per_token
         return cost

cecli_dev-0.100.11/cecli/coders/copypaste_coder.py

@@ -0,0 +1,276 @@
+import hashlib
+import json
+import math
+import time
+import uuid
+
+from cecli.exceptions import LiteLLMExceptions
+from cecli.llm import litellm
+
+from .base_coder import Coder, EmptyResponseError
+
+
+class CopyPasteCoder(Coder):
+    """Fixed marker class for isinstance checks and backward compatibility.
+
+    When ``copy_paste_mode`` is active, instantiating this class automatically
+    returns an instance of a dynamic subclass that inherits from **both** this
+    class and the coder matching the selected ``edit_format`` (e.g.
+    ``AgentCoder``, ``EditBlockCoder``, ``AskCoder``, …).  The dynamic subclass
+    overrides ``send()`` with the clipboard-transport logic while inheriting
+    all other behaviour from the target coder.
+
+    This fixed class exists only so that ``isinstance(coder, CopyPasteCoder)``
+    works and the name remains importable from ``cecli.coders``.
+    """
+
+    # CopyPasteCoder doesn't have its own prompt format.
+    prompt_format = None
+
+    def __new__(cls, *args, **kwargs):
+        """Intercept instantiation to return a dynamic subclass instance.
+
+        When ``CopyPasteCoder()`` is called, this creates a dynamic subclass
+        that inherits from **both** ``CopyPasteCoder`` (for isinstance checks)
+        and the coder class matching the selected ``edit_format``.
+
+        Python will automatically call ``__init__`` on the returned instance
+        because ``isinstance(result, CopyPasteCoder)`` is ``True``.
+        """
+        # If already instantiating a dynamic subclass, create normally
+        if cls is not CopyPasteCoder:
+            return super().__new__(cls)
+
+        # --- resolve the effective edit format -------------------------------
+        main_model = args[0] if args else None
+        args_obj = kwargs.get("args")
+        edit_format = None
+        if args_obj is not None:
+            edit_format = getattr(args_obj, "edit_format", None)
+        if not edit_format or edit_format == "code":
+            edit_format = getattr(main_model, "edit_format", None)
+
+        # --- delegate to the factory function --------------------------------
+        dynamic_cls = get_copy_paste_coder_class(edit_format, main_model)
+        return object.__new__(dynamic_cls)
+
+    prompt_format = None
+
+
+def get_copy_paste_coder_class(edit_format, main_model):
+    """Dynamically create a CopyPasteCoder class that inherits from the
+    coder class matching the selected ``edit_format``.
+
+    ``CopyPasteCoder`` is a transport-layer wrapper: it swaps the API
+    transport for clipboard transport while inheriting all behavioural
+    traits (editing, prompting, announcements, …) from the target coder
+    class (e.g. ``AgentCoder``, ``EditBlockCoder``, ``AskCoder``, …).
+    """
+    import cecli.coders as coders
+
+    # --- resolve the effective edit format -----------------------------------
+    effective_format = edit_format
+    if not effective_format or effective_format == "code":
+        effective_format = getattr(main_model, "edit_format", None)
+
+    # --- find the target base class ------------------------------------------
+    if effective_format:
+        coder_name = coders.EDIT_FORMAT_MAP.get(effective_format)
+        base_class = getattr(coders, coder_name, Coder) if coder_name else Coder
+    else:
+        base_class = Coder
+
+    # ---- create the dynamic class first so methods can reference it -----
+    # Use a different local variable name to avoid shadowing the
+    # module-level CopyPasteCoder (needed for the bases tuple).
+    DynamicCopyPasteCoder = type(
+        "CopyPasteCoder",
+        (CopyPasteCoder, base_class),
+        {
+            "__module__": __name__,
+            "prompt_format": getattr(base_class, "prompt_format", None),
+        },
+    )
+
+    # ---- clipboard-specific transport method --------------------------------
+    async def send(self, messages, model=None, functions=None, tools=None):
+        model = model or self.main_model
+
+        if getattr(model, "copy_paste_transport", "api") == "api":
+            # Fall through to the base coder's normal send()
+            async for chunk in base_class.send(
+                self, messages, model=model, functions=functions, tools=tools
+            ):
+                yield chunk
+            return
+
+        self.interrupt_event.clear()
+        self.got_reasoning_content = False
+        self.ended_reasoning_content = False
+        self.empty_response = False
+
+        self._streaming_buffer_length = 0
+        self.io.reset_streaming_response()
+
+        # Base Coder methods (eg show_send_output/preprocess_response) expect these
+        # streaming attributes to always exist, even when we bypass the normal API
+        # streaming path.
+        self.partial_response_content = ""
+        self.partial_response_reasoning_content = ""
+        self.partial_response_chunks = []
+        self.partial_response_tool_calls = []
+        self.partial_response_function_call = dict()
+        # preprocess_response() does len(self.partial_response_tool_calls),
+        # so it must not be None.
+        self.partial_response_consolidated = None
+
+        try:
+            hash_object, completion = self.copy_paste_completion(messages, model)
+            self.chat_completion_call_hashes.append(hash_object.hexdigest())
+            await self.show_send_output(completion)
+
+            if self.empty_response:
+                raise EmptyResponseError
+
+            response, func_err, content_err = self.consolidate_chunks()
+            if response:
+                completion = response
+            self.calculate_and_show_tokens_and_cost(messages, completion)
+        finally:
+            self.preprocess_response()
+
+            if self.partial_response_content:
+                self.io.ai_output(self.partial_response_content)
+
+    # ---- clipboard completion logic ------------------------------------------
+    def copy_paste_completion(self, messages, model):
+
+        try:
+            from cecli.helpers import copypaste
+        except ImportError:
+            self.io.tool_error("copy/paste mode requires the pyperclip package.")
+            self.io.tool_output("Install it with: pip install pyperclip")
+            raise
+
+        def content_to_text(content):
+            """Extract text from the various content formats cecli/LLMs can produce."""
+            if not content:
+                return ""
+            if isinstance(content, str):
+                return content
+            if isinstance(content, list):
+                parts = []
+                for part in content:
+                    if isinstance(part, dict):
+                        text = part.get("text")
+                        if isinstance(text, str):
+                            parts.append(text)
+                    elif isinstance(part, str):
+                        parts.append(part)
+                return "".join(parts)
+            if isinstance(content, dict):
+                text = content.get("text")
+                if isinstance(text, str):
+                    return text
+                return ""
+            return str(content)
+
+        lines = []
+        for message in messages:
+            text_content = content_to_text(message.get("content"))
+            if not text_content:
+                continue
+            role = message.get("role")
+            if role:
+                lines.append(f"{role.upper()}:\n{text_content}")
+            else:
+                lines.append(text_content)
+
+        prompt_text = "\n\n".join(lines).strip()
+
+        # --- incremental context: strip previously-sent exchange ---
+        last_prompt = getattr(self, "_last_prompt_text", None)
+        last_response = getattr(self, "_last_response_text", None)
+        _full_prompt = prompt_text  # Keep the original for storage
+        if last_prompt is not None and last_response is not None:
+            expected_prefix = f"{last_prompt}\n\nASSISTANT:\n{last_response}"
+            if prompt_text.startswith(expected_prefix):
+                new_only = prompt_text[len(expected_prefix) :].strip()
+                if new_only:
+                    prompt_text = new_only
+
+        self._last_prompt_text = _full_prompt
+
+        try:
+            copypaste.copy_to_clipboard(prompt_text)
+        except copypaste.ClipboardError as err:
+            self.io.tool_error(f"Unable to copy prompt to clipboard: {err}")
+            raise
+
+        self.io.tool_output("Request copied to clipboard.")
+        self.io.tool_output("Paste it into your LLM interface, then copy the reply back.")
+        self.io.tool_output("Waiting for clipboard updates (Ctrl+C to cancel)...")
+
+        try:
+            last_value = copypaste.read_clipboard()
+        except copypaste.ClipboardError as err:
+            self.io.tool_error(f"Unable to read clipboard: {err}")
+            raise
+
+        try:
+            response_text = copypaste.wait_for_clipboard_change(initial=last_value)
+        except copypaste.ClipboardError as err:
+            self.io.tool_error(f"Unable to read clipboard: {err}")
+            raise
+
+        self._last_response_text = response_text
+
+        def _safe_token_count(text):
+            """Return token count via the model tokenizer, falling back to a heuristic."""
+            if not text:
+                return 0
+            try:
+                count = model.token_count(text)
+                if isinstance(count, int) and count >= 0:
+                    return count
+            except Exception as ex:
+                try:
+                    ex_info = LiteLLMExceptions().get_ex_info(ex)
+                    if ex_info and ex_info.description:
+                        self.io.tool_warning(
+                            f"Token count failed: {ex_info.description} Falling back to heuristic."
+                        )
+                except Exception:
+                    pass
+            return int(math.ceil(len(text) / 4))
+
+        prompt_tokens = _safe_token_count(prompt_text)
+        completion_tokens = _safe_token_count(response_text)
+        total_tokens = prompt_tokens + completion_tokens
+
+        completion = litellm.ModelResponse(
+            id=f"chatcmpl-{uuid.uuid4()}",
+            choices=[
+                litellm.Choices(
+                    index=0,
+                    finish_reason="stop",
+                    message=litellm.Message(role="assistant", content=response_text),
+                )
+            ],
+            created=int(time.time()),
+            model=model.name,
+            usage={
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+            },
+        )
+
+        kwargs = dict(model=model.name, messages=messages, stream=False)
+        hash_object = hashlib.sha1(json.dumps(kwargs, sort_keys=True).encode())
+        return hash_object, completion
+
+    # ---- attach the clipboard methods and return -----------------------------
+    DynamicCopyPasteCoder.send = send
+    DynamicCopyPasteCoder.copy_paste_completion = copy_paste_completion
+    return DynamicCopyPasteCoder

{cecli_dev-0.100.10rc2 → cecli_dev-0.100.11}/cecli/commands/core.py

@@ -1,6 +1,7 @@
 import json
 import re
 import sys
+import weakref
 from pathlib import Path
 
 from cecli.commands.utils.registry import CommandRegistry
@@ -55,6 +56,18 @@ class ReloadProgramSignal(BaseException):
 class Commands:
     scraper = None
 
+    def _get_coder(self):
+        """Return coder via weak reference, or None if collected."""
+        if self._coder_ref is not None:
+            return self._coder_ref()
+        return None
+
+    def _set_coder(self, value):
+        """Store coder as weakref to break circular reference chains."""
+        self._coder_ref = weakref.ref(value) if value is not None else None
+
+    coder = property(_get_coder, _set_coder)
+
     def clone(self):
         cloned = Commands(
             self.io,
@@ -87,7 +100,8 @@ class Commands:
         original_read_only_fnames=None,
     ):
         self.io = io
-        self.coder = coder
+        # Use weak ref to avoid circular reference chains
+        self._coder_ref = weakref.ref(coder) if coder else None
         self.parser = parser
         self.args = args
         self.verbose = verbose