cecli-dev 1.6.0rc3__tar.gz → 1.6.0rc4__tar.gz

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.0rc3'
-__version_tuple__ = version_tuple = (1, 6, 0, 'rc3')
+__version__ = version = '1.6.0rc4'
+__version_tuple__ = version_tuple = (1, 6, 0, 'rc4')
 
-__commit_id__ = commit_id = 'g51e92ff65'
+__commit_id__ = commit_id = 'gf40f954f0'

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/cecli/commands/tokens.py

@@ -1,4 +1,5 @@
-from typing import List
+import json
+from typing import Any, Dict, List, Optional
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
@@ -9,6 +10,140 @@ class TokensCommand(BaseCommand):
     NORM_NAME = "tokens"
     DESCRIPTION = "Report on the number of tokens used by the current chat context"
 
+    @classmethod
+    def _extract_file_name(cls, msg: Dict[str, Any]) -> Optional[str]:
+        """Extract file name from a message dictionary."""
+        if not isinstance(msg, dict):
+            return None
+
+        # Check explicit image_file metadata first
+        fname = msg.get("image_file")
+        if fname:
+            return fname
+
+        content = msg.get("content")
+        if isinstance(content, str):
+            if content.startswith(("Original File Contents For", "Current File Contents For")):
+                lines = content.split("\n", 3)
+                if len(lines) > 1:
+                    return lines[1].strip()
+            elif content.startswith("Image file: "):
+                return content[len("Image file: ") :].strip()
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict):
+                    if part.get("image_file"):
+                        return part.get("image_file")
+                    text = part.get("text")
+                    if isinstance(text, str):
+                        if text.startswith(
+                            ("Original File Contents For", "Current File Contents For")
+                        ):
+                            lines = text.split("\n", 3)
+                            if len(lines) > 1:
+                                return lines[1].strip()
+                        elif text.startswith("Image file: "):
+                            return text[len("Image file: ") :].strip()
+                elif isinstance(part, str):
+                    if part.startswith(("Original File Contents For", "Current File Contents For")):
+                        lines = part.split("\n", 3)
+                        if len(lines) > 1:
+                            return lines[1].strip()
+                    elif part.startswith("Image file: "):
+                        return part[len("Image file: ") :].strip()
+
+        return None
+
+    @staticmethod
+    def binary_token_count(data_url: str, bytes_per_pixel: float = 1.0) -> int:
+        """Estimate OpenAI vision tokens for a base64 media data URL.
+
+        Assumes a 4:3 aspect ratio and 1 byte per pixel, which is a reasonable middle
+        ground for binary media when the true dimensions are unknown. The tile cost is
+        inflated by 1.33 and floored to keep the estimate on the pessimistic side.
+        """
+        import math
+
+        b64_data = data_url.split(",", 1)[1] if "," in data_url else data_url
+        padding = b64_data.count("=")
+        rough_bytes = max(0, (len(b64_data) * 3 // 4) - padding)
+        total_pixels = rough_bytes / bytes_per_pixel
+        height = math.sqrt((3 / 4) * total_pixels)
+        width = (4 / 3) * height
+
+        if max(width, height) > 2048:
+            scale = 2048 / max(width, height)
+            width *= scale
+            height *= scale
+
+        if min(width, height) > 768:
+            scale = 768 / min(width, height)
+            width *= scale
+            height *= scale
+
+        tiles = math.ceil(width / 512) * math.ceil(height / 512)
+
+        return math.floor((85 + (170 * tiles)) * 1.33)
+
+    @classmethod
+    def _extract_key_paths(cls, obj: Any, prefix: str = "") -> List[str]:
+        """Return the dot-separated paths of every leaf in a nested structure.
+
+        List indices are included as numeric segments, e.g. "0.image_url.url".
+        """
+        if isinstance(obj, dict):
+            items = obj.items()
+        elif isinstance(obj, list):
+            items = enumerate(obj)
+        else:
+            return [prefix] if prefix else []
+
+        paths = []
+        for key, value in items:
+            path = f"{prefix}.{key}" if prefix else str(key)
+            paths.extend(cls._extract_key_paths(value, path))
+
+        return paths
+
+    @classmethod
+    def _get_path_value(cls, obj: Any, path: str) -> Any:
+        """Resolve a dot-separated path produced by _extract_key_paths."""
+        for part in path.split("."):
+            obj = obj[int(part)] if isinstance(obj, list) else obj[part]
+
+        return obj
+
+    @classmethod
+    def _count_value_tokens(cls, coder, key: str, value: Any) -> int:
+        """Count tokens for an extracted value, estimating data URLs as binary media."""
+        if key == "url" and isinstance(value, str) and value.startswith("data:"):
+            return cls.binary_token_count(value)
+
+        return coder.main_model.token_count(value)
+
+    @classmethod
+    def _count_message_tokens(cls, coder, msg: Dict[str, Any]) -> int:
+        """Count tokens for a message, estimating binary data URLs instead of raw base64."""
+        content = msg.get("content") if isinstance(msg, dict) else None
+
+        if not isinstance(content, (list, dict)):
+            return coder.main_model.token_count([msg])
+
+        total = 0
+
+        for path in cls._extract_key_paths(content):
+            key = path.rsplit(".", 1)[-1]
+
+            if not key.isdigit() and key not in ("text", "content", "url"):
+                continue
+
+            value = cls._get_path_value(content, path)
+
+            if isinstance(value, str):
+                total += cls._count_value_tokens(coder, key, value)
+
+        return total
+
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         res = []
@@ -55,6 +190,13 @@ class TokensCommand(BaseCommand):
 
         res.append((system_tokens, "system messages", ""))
 
+        # tool definitions
+        tool_list = coder.get_tool_list()
+
+        if tool_list:
+            tokens_tools = coder.main_model.token_count(json.dumps(tool_list))
+            res.append((tokens_tools, "tool schemas", ""))
+
         # chat history
         msgs_done = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.DONE)
         msgs_cur = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.CUR)
@@ -123,27 +265,10 @@ class TokensCommand(BaseCommand):
             # Group messages by file (each file has user and assistant messages)
             file_tokens = {}
             for msg in readonly_msgs:
-                # Extract file name from message content
-                content = msg.get("content", "")
-                if content.startswith("Original File Contents For"):
-                    # Extract file path from "File Contents {path}:"
-                    lines = content.split("\n", 3)
-                    if lines:
-                        file_line = lines[1]
-                        fname = file_line.strip()
-                        # Calculate tokens for this message
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
-                elif "image_file" in msg:
-                    # Handle image files
-                    fname = msg.get("image_file")
-                    if fname:
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
+                fname = cls._extract_file_name(msg)
+                if fname:
+                    tokens = cls._count_message_tokens(coder, msg)
+                    file_tokens[fname] = file_tokens.get(fname, 0) + tokens
 
             # Add to results
             for fname, tokens in file_tokens.items():
@@ -158,27 +283,10 @@ class TokensCommand(BaseCommand):
             msgs = ConversationService.get_manager(coder).get_messages_dict(tag=tag)
             if msgs:
                 for msg in msgs:
-                    # Extract file name from message content
-                    content = msg.get("content", "")
-                    if content.startswith("Original File Contents For"):
-                        # Extract file path from "File Contents {path}:"
-                        lines = content.split("\n", 3)
-                        if lines:
-                            file_line = lines[1]
-                            fname = file_line.strip()
-                            # Calculate tokens for this message
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
-                    elif "image_file" in msg:
-                        # Handle image files
-                        fname = msg.get("image_file")
-                        if fname:
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
+                    fname = cls._extract_file_name(msg)
+                    if fname:
+                        tokens = cls._count_message_tokens(coder, msg)
+                        editable_file_tokens[fname] = editable_file_tokens.get(fname, 0) + tokens
 
         # Add editable files to results
         for fname, tokens in editable_file_tokens.items():

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/cecli/tui/app.py

@@ -201,6 +201,12 @@ class TUI(App):
             description="Record Voice",
             show=True,
         )
+        self.bind(
+            self._encode_keys(self.get_keys_for("paste")),
+            "paste_clipboard",
+            description="Paste Clipboard",
+            show=True,
+        )
 
         self.register_theme(BASE_THEME)
         self.theme = "cecli"
@@ -284,6 +290,7 @@ class TUI(App):
             "editor": "ctrl+o",
             "history": "alt+shift+h",
             "voice": "ctrl+r",
+            "paste": "alt+v",
             "focus": "ctrl+f",
             "cancel": "ctrl+c",
             "clear": "ctrl+l",
@@ -829,6 +836,12 @@ class TUI(App):
             self.action_start_voice()
             return
 
+        if stripped == "/paste":
+            input_area = self.query_one("#input", InputArea)
+            input_area.value = ""
+            self.action_paste_clipboard()
+            return
+
         # Intercept /editor and /edit commands to handle with TUI suspension
         if (
             stripped in ("/editor", "/edit")
@@ -1280,6 +1293,11 @@ class TUI(App):
         self._voice_stopping = False
         self.run_worker(self._run_voice(coder, self._voice_stop_queue), group="voice")
 
+    def action_paste_clipboard(self):
+        """Paste an image or text from the system clipboard (keyboard shortcut)."""
+        coder = self._get_visible_coder()
+        self.run_worker(self._run_paste(coder), group="paste")
+
     def action_open_editor(self):
         """Open an external editor to compose a prompt (keyboard shortcut)."""
         # Get current input text to use as initial content
@@ -2124,6 +2142,29 @@ class TUI(App):
             self._voice_stopping = False
             self.update_key_hints(generating=self._currently_generating)
 
+    async def _run_paste(self, coder):
+        """Run the paste command on a worker so clipboard I/O doesn't block the UI."""
+        from cecli.commands.paste import PasteCommand
+
+        try:
+            await PasteCommand.execute(coder.io, coder, "")
+            self._refresh_file_list(coder)
+        except Exception as err:
+            self.show_error(f"Unable to paste clipboard content: {err}")
+
+    def _refresh_file_list(self, coder):
+        """Refresh the file list and autocomplete after the coder's chat files change."""
+        try:
+            input_area = self.query_one("#input", InputArea)
+            files = list(coder.get_addable_relative_files())
+            commands = coder.commands.get_commands() if getattr(coder, "commands", None) else []
+            input_area.update_autocomplete_data(files, commands)
+
+            file_list = self.query_one("#file-list", FileList)
+            file_list.update_files()
+        except Exception:
+            pass
+
 
 def patch_color_name_to_rgb():
     """Inject Rich 256-color names into Textual's COLOR_NAME_TO_RGB dict.

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/cecli/tui/widgets/input_area.py

@@ -247,6 +247,11 @@ class InputArea(TextArea):
             self.app.action_start_voice()
             return
 
+        if self.app.is_key_for("paste", event.key):
+            event.stop()
+            event.prevent_default()
+            self.app.action_paste_clipboard()
+
         if self.app.is_key_for("history", event.key):
             event.stop()
             event.prevent_default()

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/cecli/website/docs/config/tui.md

@@ -54,7 +54,9 @@ tui-config:
     completion: "tab"
     stop: "escape"
     editor: "ctrl+o"
-    history: "ctrl+r"
+    history: "alt+shift+h"
+    voice: "ctrl+r"
+    paste: "alt+v"
     cycle_forward: "tab"
     cycle_backward: "shift+tab"
     input_start: "ctrl+home"
@@ -82,7 +84,9 @@ The TUI provides customizable key bindings for all major actions. The default ke
 | Cancel | `ctrl+c` | Stop and stash current input prompt |
 | Stop | `escape` | Interrupt the current LLM response or task |
 | Editor | `ctrl+o` | Open up default terminal text editor for input | 
-| Search History | `ctrl+r` | Search through history for previous commands (requires fzf to be installed) | 
+| Search History | `alt+shift+h` | Search through history for previous commands (requires fzf to be installed) | 
+| Voice | `ctrl+r` | Record and transcribe voice input (dictation) into the chat |
+| Paste Clipboard | `alt+v` | Paste image or text from the system clipboard into the chat |
 | Cycle Forward | `tab` | Cycle forward through completion suggestions |
 | Cycle Backward | `shift+tab` | Cycle backward through completion suggestions |
 | Input Start | `ctrl+home` | Move cursor to start of first line |

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/cecli_dev.egg-info/PKG-INFO

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

@@ -0,0 +1,8 @@
+{
+  "tag": "1.6.0rc4",
+  "distance": 0,
+  "node": "gf40f954f008c713c430c3eb29c53afab92dd9d92",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-18"
+}

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/tests/basic/test_commands.py

@@ -420,6 +420,125 @@ class TestCommands(TestCase):
         self.assertIn("foo.txt", console_output)
         self.assertIn("bar.txt", console_output)
 
+    async def test_cmd_tokens_with_image_list_content(self):
+        from cecli.commands.tokens import TokensCommand
+        from cecli.helpers.conversation import ConversationService, MessageTag
+
+        # Direct unit tests for _extract_file_name
+        self.assertIsNone(TokensCommand._extract_file_name(None))
+        self.assertIsNone(TokensCommand._extract_file_name("not a dict"))
+        self.assertIsNone(TokensCommand._extract_file_name({}))
+        self.assertIsNone(TokensCommand._extract_file_name({"content": None}))
+        self.assertIsNone(TokensCommand._extract_file_name({"content": "Just a normal message"}))
+
+        # String content
+        self.assertEqual(
+            TokensCommand._extract_file_name(
+                {"content": "Original File Contents For:\n/path/to/file.py\n\ncode..."}
+            ),
+            "/path/to/file.py",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name(
+                {"content": "Current File Contents For:\n/path/to/file2.py\n\ncode..."}
+            ),
+            "/path/to/file2.py",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name({"content": "Image file: photo.png"}),
+            "photo.png",
+        )
+
+        # image_file key
+        self.assertEqual(
+            TokensCommand._extract_file_name({"image_file": "photo.jpg"}),
+            "photo.jpg",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name(
+                {
+                    "image_file": "photo.jpg",
+                    "content": [{"type": "image_url", "image_url": {}}],
+                }
+            ),
+            "photo.jpg",
+        )
+
+        # List content
+        self.assertEqual(
+            TokensCommand._extract_file_name(
+                {
+                    "content": [
+                        {"type": "text", "text": "Image file: nested.png"},
+                        {"type": "image_url", "image_url": {}},
+                    ]
+                }
+            ),
+            "nested.png",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name(
+                {
+                    "content": [
+                        {"type": "text", "text": "Original File Contents For:\nmodule.py\n\ncode"}
+                    ]
+                }
+            ),
+            "module.py",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name({"content": [{"image_file": "from_part.png"}]}),
+            "from_part.png",
+        )
+        self.assertEqual(
+            TokensCommand._extract_file_name({"content": ["Image file: string_part.png"]}),
+            "string_part.png",
+        )
+
+        # Integration test with Coder / Commands execution
+        io = InputOutput(pretty=False, fancy_input=False, yes=True)
+        coder = await Coder.create(self.GPT35, None, io)
+        commands = Commands(io, coder)
+
+        manager = ConversationService.get_manager(coder)
+        img_msg = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "Image file: test_image.png"},
+                {"type": "image_url", "image_url": {"url": "data:image/png;base64,123"}},
+            ],
+            "image_file": "test_image.png",
+        }
+        manager.add_message(
+            message_dict=img_msg,
+            tag=MessageTag.READONLY_FILES,
+            hash_key=("image_user", "test_image.png"),
+        )
+
+        img_msg_no_attr = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "Image file: another_image.png"},
+                {"type": "image_url", "image_url": {"url": "data:image/png;base64,456"}},
+            ],
+        }
+        manager.add_message(
+            message_dict=img_msg_no_attr,
+            tag=MessageTag.CHAT_FILES,
+            hash_key=("image_user", "another_image.png"),
+        )
+
+        stdout = StringIO()
+        sys.stdout = stdout
+        try:
+            commands.execute("tokens", "")
+        finally:
+            sys.stdout = sys.__stdout__
+
+        console_output = stdout.getvalue()
+        self.assertIn("test_image.png", console_output)
+        self.assertIn("another_image.png", console_output)
+
     async def test_cmd_add_from_subdir(self):
         repo = git.Repo.init()
         repo.config_writer().set_value("user", "name", "Test User").release()

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc4}/tests/tui/test_app.py

@@ -513,3 +513,89 @@ def test_submit_voice_intercepts_without_agent_queue(tui_instance, text):
     assert tui_instance.input_queue.empty()
     push_input.assert_not_called()
     wake_input.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_run_paste_executes_paste_command(tui_instance):
+    """The paste hotkey runs the paste command on a worker without queuing input."""
+    coder = MagicMock()
+    tui_instance._get_visible_coder = MagicMock(return_value=coder)
+    tui_instance.run_worker = MagicMock()
+    tui_instance._refresh_file_list = MagicMock()
+
+    tui_instance.action_paste_clipboard()
+
+    coroutine = tui_instance.run_worker.call_args.args[0]
+    tui_instance.run_worker.assert_called_once_with(coroutine, group="paste")
+    tui_instance._get_visible_coder.assert_called_once_with()
+
+    with patch("cecli.commands.paste.PasteCommand.execute", new=AsyncMock()) as execute:
+        await coroutine
+        execute.assert_awaited_once_with(coder.io, coder, "")
+    tui_instance._refresh_file_list.assert_called_once_with(coder)
+
+
+@pytest.mark.asyncio
+async def test_run_paste_reports_errors(tui_instance):
+    """Clipboard failures surface through the status bar instead of crashing."""
+    coder = MagicMock()
+    tui_instance.show_error = MagicMock()
+
+    with patch(
+        "cecli.commands.paste.PasteCommand.execute",
+        new=AsyncMock(side_effect=RuntimeError("no clipboard")),
+    ):
+        await tui_instance._run_paste(coder)
+
+    tui_instance.show_error.assert_called_once_with(
+        "Unable to paste clipboard content: no clipboard"
+    )
+
+
+@pytest.mark.parametrize("text", ["/paste", "  /paste \n"])
+def test_submit_paste_intercepts_without_agent_queue(tui_instance, text):
+    import queue
+
+    input_area = MagicMock(value=text)
+    tui_instance.query_one = MagicMock(return_value=input_area)
+    tui_instance.action_paste_clipboard = MagicMock()
+    tui_instance.add_user_message = MagicMock()
+    tui_instance.input_queue = queue.Queue()
+
+    with (
+        patch("cecli.tui.app.queues.push_coder_input") as push_input,
+        patch("cecli.tui.app.queues.wake_input_waiters") as wake_input,
+    ):
+        tui_instance.on_input_area_submit(MagicMock(value=text))
+
+    assert input_area.value == ""
+    tui_instance.action_paste_clipboard.assert_called_once_with()
+    input_area.save_to_history.assert_not_called()
+    tui_instance.add_user_message.assert_not_called()
+    assert tui_instance.input_queue.empty()
+    push_input.assert_not_called()
+    wake_input.assert_not_called()
+
+
+def test_refresh_file_list_updates_autocomplete_and_file_list(tui_instance):
+    """The paste refresh updates both autocomplete data and the file list."""
+    coder = MagicMock()
+    coder.get_addable_relative_files.return_value = ["a.py", "b.py"]
+    coder.commands.get_commands.return_value = ["/add"]
+
+    input_area = MagicMock()
+    file_list = MagicMock()
+
+    def mock_query_one(selector, *args):
+        if selector == "#input":
+            return input_area
+        if selector == "#file-list":
+            return file_list
+        raise AssertionError(f"unexpected selector: {selector}")
+
+    tui_instance.query_one = mock_query_one
+
+    tui_instance._refresh_file_list(coder)
+
+    input_area.update_autocomplete_data.assert_called_once_with(["a.py", "b.py"], ["/add"])
+    file_list.update_files.assert_called_once_with()

cecli_dev-1.6.0rc3/cecli_dev.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.6.0rc3",
-  "distance": 0,
-  "node": "g51e92ff6518bd1f937c205973813822080109cc8",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-17"
-}