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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.11rc3
+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.11rc3 → 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.11rc3'
-__version_tuple__ = version_tuple = (0, 100, 11, 'rc3')
+__version__ = version = '0.100.11rc5'
+__version_tuple__ = version_tuple = (0, 100, 11, 'rc5')
 
-__commit_id__ = commit_id = 'g11ba4d315'
+__commit_id__ = commit_id = 'gef557d67b'

{cecli_dev-0.100.11rc3 → cecli_dev-0.100.11rc5}/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)"

{cecli_dev-0.100.11rc3 → cecli_dev-0.100.11rc5}/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.11rc3 → cecli_dev-0.100.11rc5}/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):

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.11rc3 → cecli_dev-0.100.11rc5}/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

{cecli_dev-0.100.11rc3 → 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.11rc3 → cecli_dev-0.100.11rc5}/cecli/helpers/skills.py

@@ -6,6 +6,7 @@ according to the Skills specification.
 """
 
 import re
+import weakref
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -69,7 +70,7 @@ class SkillsManager:
         self.include_list = set(include_list) if include_list else None
         self.exclude_list = set(exclude_list) if exclude_list else set()
         self.git_root = Path(git_root).expanduser().resolve() if git_root else None
-        self.coder = coder  # Weak reference to coder instance
+        self._coder_ref = weakref.ref(coder) if coder else None  # Weak reference to coder instance
 
         # Cache for loaded skills
         self._skills_cache: Dict[str, SkillContent] = {}
@@ -105,6 +106,18 @@ class SkillsManager:
 
             # Save initial state from config
 
+    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 _save_state(self):
         """Save current mutable state to the global skill state store.
 

{cecli_dev-0.100.11rc3 → cecli_dev-0.100.11rc5}/cecli/repo.py

@@ -1,5 +1,6 @@
 import contextlib
 import os
+import sys
 import time
 from pathlib import Path, PurePosixPath
 
@@ -84,7 +85,9 @@ class GitRepo:
         self.models = models
 
         self.normalized_path = {}
-        self.tree_files = {}
+        # Single-entry file cache: (commit_sha, interned_set_of_paths)
+        # Using a single entry (not per-commit dict) limits unbounded memory growth
+        self._tree_cache = None
 
         self.attribute_author = attribute_author
         self.attribute_committer = attribute_committer
@@ -602,8 +605,8 @@ class GitRepo:
 
         files = set()
         if commit:
-            if commit in self.tree_files:
-                files = self.tree_files[commit]
+            if self._tree_cache is not None and self._tree_cache[0] == commit.hexsha:
+                files = self._tree_cache[1]
             else:
                 try:
                     iterator = commit.tree.traverse()
@@ -612,7 +615,8 @@ class GitRepo:
                         try:
                             blob = next(iterator)
                             if blob.type == "blob":  # blob is a file
-                                files.add(blob.path)
+                                # Use sys.intern() to deduplicate path strings in memory
+                                files.add(sys.intern(blob.path))
                         except IndexError:
                             # Handle potential index error during tree traversal
                             # without relying on potentially unassigned 'blob'
@@ -629,7 +633,10 @@ class GitRepo:
                     self.io.tool_output("Is your git repo corrupted?")
                     return []
                 files = set(self.normalize_path(path) for path in files)
-                self.tree_files[commit] = set(files)
+                # Use single-entry cache (not per-commit dict) to limit memory growth
+                # Store only the SHA string (not the Commit object) to avoid retaining
+                # the entire git object graph (tree, blobs, parent commits, etc.)
+                self._tree_cache = (commit.hexsha, files)
 
         # Add staged files
         index = self.repo.index

{cecli_dev-0.100.11rc3 → 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.11rc3 → 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.11rc3
+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"
+}