cecli-dev 0.100.11rc4__tar.gz → 0.100.11rc5__tar.gz

{cecli_dev-0.100.11rc4 → cecli_dev-0.100.11rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.11rc4
+Version: 0.100.11rc5
 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-0.100.11rc4 → cecli_dev-0.100.11rc5}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.11rc4'
-__version_tuple__ = version_tuple = (0, 100, 11, 'rc4')
+__version__ = version = '0.100.11rc5'
+__version_tuple__ = version_tuple = (0, 100, 11, 'rc5')
 
-__commit_id__ = commit_id = 'g7cf5b1173'
+__commit_id__ = commit_id = 'gef557d67b'

cecli_dev-0.100.11rc5/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.11rc4 → cecli_dev-0.100.11rc5}/cecli/helpers/conversation/integration.py

@@ -104,6 +104,10 @@ class ConversationChunks:
                     priority=75 + i,
                 )
 
+        if getattr(coder, "copy_paste_mode", False):
+            # Add copy-paste mode tool instructions for inline tool calling
+            self.add_copy_paste_tool_instructions()
+
         if self._cancel_post_message_injections():
             return
 
@@ -1035,6 +1039,84 @@ class ConversationChunks:
 
         return False
 
+    def add_copy_paste_tool_instructions(self) -> None:
+        """
+        Add tool instructions for copy/paste mode.
+
+        When in copy/paste mode, the model cannot use native API tool calling so
+        we inject instructions on how to embed tool calls inline using XML, JSON,
+        or bracket formats. These are parsed out by the extract_tools_from_content_*
+        functions in ``responses.py``.
+        """
+        coder = self.get_coder()
+        if not coder:
+            return
+
+        tool_list = coder.get_tool_list()
+        if not tool_list:
+            return
+
+        # Prepare a clean, serializable version of the tool list
+        tool_descriptions = []
+        for prefixed_tool in tool_list:
+            if isinstance(prefixed_tool, dict):
+                func = prefixed_tool.get("function", {})
+                tool_descriptions.append(
+                    {
+                        "name": func.get("name", ""),
+                        "description": func.get("description", ""),
+                        "parameters": func.get("parameters", {}),
+                    }
+                )
+            elif hasattr(prefixed_tool, "function") and hasattr(prefixed_tool.function, "name"):
+                tool_descriptions.append(
+                    {
+                        "name": getattr(prefixed_tool.function, "name", ""),
+                        "description": getattr(prefixed_tool.function, "description", ""),
+                        "parameters": getattr(prefixed_tool.function, "parameters", {}),
+                    }
+                )
+
+        tool_list_json = json.dumps(tool_descriptions, indent=2)
+
+        inline_tool_instructions = (
+            '<context name="tool_list">\n'
+            "You are in copy/paste mode. Since the LLM API transport is unavailable, "
+            "you MUST embed tool calls directly in your response content using one of the "
+            "following formats. The system will parse these out and execute them.\n\n"
+            "Available tools:\n"
+            f"{tool_list_json}\n\n"
+            "TOOL CALLING FORMATS (use any of these):\n\n"
+            "1. XML Function Format:\n"
+            "   <function=ToolName>\n"
+            "   <parameter=param_name>param_value_json</parameter>\n"
+            "   </function>\n\n"
+            "   Example:\n"
+            "   <function=Local--ReadRange>\n"
+            '   <parameter=read>[{"file_path": "example.py", "range_start": "def hello",'
+            ' "range_end": "def goodbye"}]</parameter>\n'
+            "   </function>\n\n"
+            "2. JSON Tool-Call Format:\n"
+            '   Embed a JSON object with "name" and "arguments" keys.\n\n'
+            "   Example:\n"
+            '   {"name": "Local--ReadRange", "arguments": {"read": [{"file_path": "example.py",'
+            ' "range_start": "class A", "range_end": "class Z"}]}}\n\n'
+            "3. Bracket Format:\n"
+            "   [ToolName(key1=value1, key2=value2)]\n\n"
+            "   Example:\n"
+            '   [Local--ReadRange(read=[{"file_path": "example.py", "range_start": "class A"}])]\n\n'
+            "IMPORTANT: Use the FULL prefixed tool name "
+            '(e.g., "Local--ReadRange" not just "ReadRange").\n'
+            "</context>"
+        )
+
+        ConversationService.get_manager(coder).add_message(
+            message_dict={"role": "system", "content": inline_tool_instructions},
+            tag=MessageTag.SYSTEM,
+            hash_key=("main", "copy_paste_tools"),
+            force=True,
+        )
+
     def _shuffle_reminders(self, content: str) -> str:
         """
         If the string is a critical_reminders block, shuffle all bulleted points

{cecli_dev-0.100.11rc4 → cecli_dev-0.100.11rc5}/cecli/tui/worker.py

@@ -156,7 +156,9 @@ class CoderWorker:
             else:
                 new_coder.show_announcements()
 
-            edit_format = getattr(target_coder, "edit_format", "code") or "code"
+            edit_format = kwargs.get(
+                "edit_format", getattr(target_coder, "edit_format", "code") or "code"
+            )
             self.output_queue.put(
                 {
                     "type": "mode_change",

{cecli_dev-0.100.11rc4 → cecli_dev-0.100.11rc5}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.11rc4
+Version: 0.100.11rc5
 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-0.100.11rc5/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.100.11rc5",
+  "distance": 0,
+  "node": "gef557d67b79d4b14678bee3df5367348f07fe9fc",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-01"
+}

{cecli_dev-0.100.11rc4 → cecli_dev-0.100.11rc5}/tests/coders/test_copypaste_coder.py

@@ -1,43 +1,33 @@
 import hashlib
 import json
-from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import pytest
 
-from cecli.coders.copypaste_coder import CopyPasteCoder
+from cecli.coders.copypaste_coder import get_copy_paste_coder_class
 from cecli.coders.editblock_coder import EditBlockCoder
 
+# Dynamically create a CopyPasteCoder class for testing purposes.
+# We use the 'diff' edit format so it inherits EditBlockCoder behavior.
+_TestModel = type("TestModel", (), {"edit_format": None, "name": "test"})
+CopyPasteCoder = get_copy_paste_coder_class("diff", _TestModel())
 
-def test_init_prompts_uses_selected_edit_format():
-    coder = CopyPasteCoder.__new__(CopyPasteCoder)
-    coder.args = SimpleNamespace(edit_format="diff")
-    coder.main_model = SimpleNamespace(edit_format=None)
-    coder.edit_format = None
-    coder.gpt_prompts = None
-
-    coder._init_prompts_from_selected_edit_format()
-
-    assert coder.gpt_prompts is not None
-    assert hasattr(coder.gpt_prompts, "main_system")
-    assert coder.edit_format == EditBlockCoder.edit_format
-
-
-def test_init_prompts_preserves_existing_when_no_match(monkeypatch):
-    coder = CopyPasteCoder.__new__(CopyPasteCoder)
-    coder.args = SimpleNamespace(edit_format="custom-format")
-    coder.main_model = SimpleNamespace(edit_format=None)
-    coder.edit_format = "original-format"
-    coder.gpt_prompts = "original-prompts"
-
-    import cecli.coders as coders
-
-    monkeypatch.setattr(coders, "__all__", [], raising=False)
 
-    coder._init_prompts_from_selected_edit_format()
+def test_dynamic_class_inherits_from_target_coder():
+    """The dynamic CopyPasteCoder class inherits from the target coder class."""
+    # Already created at module level: CopyPasteCoder = get_copy_paste_coder_class("diff", _TestModel())
+    assert issubclass(
+        CopyPasteCoder, EditBlockCoder
+    ), "CopyPasteCoder should inherit from EditBlockCoder for 'diff' format"
+    # The fixed CopyPasteCoder marker should also be in the MRO
+    from cecli.coders.copypaste_coder import CopyPasteCoder as FixedCopyPasteCoder
 
-    assert coder.gpt_prompts == "original-prompts"
-    assert coder.edit_format == "original-format"
+    assert (
+        FixedCopyPasteCoder in CopyPasteCoder.__mro__
+    ), "Fixed CopyPasteCoder should be in the MRO for isinstance checks"
+    # gpt_prompts should resolve correctly via the inherited property
+    assert CopyPasteCoder.prompt_format is not None
+    assert CopyPasteCoder.prompt_format == EditBlockCoder.prompt_format
 
 
 @pytest.mark.asyncio
@@ -51,7 +41,11 @@ async def test_send_uses_copy_paste_flow(monkeypatch):
     coder.partial_response_tool_calls = []
     coder.partial_response_function_call = None
     coder.chat_completion_call_hashes = []
-    coder.show_send_output = AsyncMock()
+    coder.interrupt_event = MagicMock()
+
+    coder.show_send_output = AsyncMock(
+        side_effect=lambda c: coder.partial_response_chunks.append(c)
+    )
     coder.calculate_and_show_tokens_and_cost = MagicMock()
 
     def fake_preprocess_response():