cecli-dev 0.99.6__tar.gz → 0.99.8__tar.gz

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.6
+Version: 0.99.8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -78,6 +78,8 @@ Requires-Dist: codespell; extra == "dev"
 Requires-Dist: uv; extra == "dev"
 Requires-Dist: memray; extra == "dev"
 Requires-Dist: objgraph; extra == "dev"
+Requires-Dist: pympler; extra == "dev"
+Requires-Dist: guppy3; extra == "dev"
 Provides-Extra: help
 Requires-Dist: llama-index-embeddings-huggingface; extra == "help"
 Requires-Dist: numpy>=1.26.4; extra == "help"

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/__init__.py

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

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.6'
-__version_tuple__ = version_tuple = (0, 99, 6)
+__version__ = version = '0.99.8'
+__version_tuple__ = version_tuple = (0, 99, 8)
 
-__commit_id__ = commit_id = 'g835b8b50f'
+__commit_id__ = commit_id = 'g2e022d0e6'

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/change_tracker.py

@@ -21,7 +21,7 @@ class ChangeTracker:
 
         Parameters:
         - file_path: Path to the file that was changed
-        - change_type: Type of change (e.g., 'replacetext', 'insertlines')
+        - change_type: Type of change (e.g., 'edittext', 'insertlines')
         - original_content: Original content before the change
         - new_content: New content after the change
         - metadata: Additional information about the change (line numbers, positions, etc.)

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/coders/agent_coder.py

@@ -53,17 +53,17 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "commandinteractive",
-            "exploresymbols",
+            "explorecode",
             "ls",
+            "getlines",
             "grep",
-            "showcontext",
             "thinking",
             "updatetodolist",
         }
         self.write_tools = {
-            "deletetext",
-            "inserttext",
-            "replacetext",
+            "command",
+            "commandinteractive",
+            "edittext",
             "undochange",
         }
         self.edit_allowed = False
@@ -999,7 +999,7 @@ I will proceed based on the tool results and updated context.""")
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled.Use `ShowContext` to determine the"
+                "File editing tools are currently disabled.Use `GetLines` to determine the"
                 " current hashline prefixes needed to perform an edit and activate them when you"
                 " are ready to edit a file."
             )

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/commands/copy_context.py

@@ -4,6 +4,7 @@ import pyperclip
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers.conversation import ConversationService, MessageTag
 
 
 class CopyContextCommand(BaseCommand):
@@ -13,13 +14,13 @@ class CopyContextCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the copy-context command with given parameters."""
-        chunks = coder.format_chat_chunks()
+        manager = ConversationService.get_manager(coder)
 
         markdown = ""
 
-        # Only include specified chunks in order
-        for messages in [chunks.repo, chunks.readonly_files, chunks.chat_files]:
-            for msg in messages:
+        # Only include specified chunks in order using conversation tags
+        for tag in [MessageTag.REPO, MessageTag.READONLY_FILES, MessageTag.CHAT_FILES]:
+            for msg in manager.get_messages_dict(tag=tag):
                 # Only include user messages
                 if msg["role"] != "user":
                     continue

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/helpers/background_commands.py

@@ -11,7 +11,7 @@ import platform
 import subprocess
 import threading
 from collections import deque
-from typing import Dict, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 try:
     import pty
@@ -624,3 +624,51 @@ class BackgroundCommandManager:
                     ),
                 }
             return result
+
+    @staticmethod
+    def save_paginated_output(
+        output: str,
+        command_key: str,
+        page_size: int,
+        abs_root_path_func,
+        local_agent_folder_func,
+    ) -> Optional[Tuple[str, List[str], List[str]]]:
+        """
+        Save long output to paginated files in a folder for later access.
+
+        When output exceeds the page_size threshold, it is split into multiple
+        files named `{page_number}.txt` inside a folder named `{command_key}`
+        in the agent's local folder.
+
+        Args:
+            output: Full output text to save
+            command_key: Command key used for both folder naming and as the filename root
+            page_size: Maximum characters per page (typically large_file_token_threshold)
+            abs_root_path_func: Callable to convert relative path to absolute (e.g., coder.abs_root_path)
+            local_agent_folder_func: Callable to generate relative paths (e.g., coder.local_agent_folder)
+
+        Returns:
+            Tuple of (folder path, rel file paths list, alias paths list), or None if output fits in one page.
+        """
+        if not output or len(output) <= page_size:
+            return None
+
+        folder_path = local_agent_folder_func(command_key)
+        abs_folder = abs_root_path_func(folder_path)
+        os.makedirs(abs_folder, exist_ok=True)
+
+        num_pages = (len(output) + page_size - 1) // page_size
+
+        for i in range(num_pages):
+            page_num = i + 1
+            filename = f"{page_num}.txt"
+            abs_path = os.path.join(abs_folder, filename)
+            page_content = output[i * page_size : (i + 1) * page_size]
+            with open(abs_path, "w") as f:
+                f.write(page_content)
+
+        file_paths = [f"{folder_path}/{page_num}.txt" for page_num in range(1, num_pages + 1)]
+        alias_paths = [
+            f"command_key::{command_key}/{page_num}.txt" for page_num in range(1, num_pages + 1)
+        ]
+        return (folder_path, file_paths, alias_paths)

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/helpers/conversation/integration.py

@@ -786,12 +786,6 @@ class ConversationChunks:
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_user", file_path),
                 force=True,
-                promotion=(
-                    ConversationService.get_manager(coder).DEFAULT_TAG_PROMOTION_VALUE
-                    if promote_messages
-                    else None
-                ),
-                mark_for_demotion=1 if promote_messages else None,
             )
 
             ConversationService.get_manager(coder).add_message(
@@ -799,12 +793,6 @@ class ConversationChunks:
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_assistant", file_path),
                 force=True,
-                promotion=(
-                    ConversationService.get_manager(coder).DEFAULT_TAG_PROMOTION_VALUE
-                    if promote_messages
-                    else None
-                ),
-                mark_for_demotion=1 if promote_messages else None,
             )
 
     def reset(self) -> None:

cecli_dev-0.99.8/cecli/helpers/leak_detect.py

@@ -0,0 +1,351 @@
+"""Memory leak detection and heap analysis utilities.
+
+Provides a MemorySnapshot class to inspect the largest allocated objects
+in the Python heap: dicts, lists, and custom class instances.
+
+Usage:
+    from cecli.helpers.leak_detect import MemorySnapshot
+
+    snap = MemorySnapshot()
+    snap.print_report()
+
+    # Programmatic access:
+    for item in snap.largest_dicts(5):
+        print(item["size_kb"], item["keys"])
+"""
+
+from __future__ import annotations
+
+import gc
+import sys
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+# ── Optional dependency wrappers ──
+
+
+def _has_pympler() -> bool:
+    try:
+        import pympler  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def _pympler_deep_size(obj: Any) -> int:
+    """Return deep size of *obj* in bytes using pympler (if available)."""
+    from pympler import asizeof
+
+    return asizeof.asizeof(obj)
+
+
+def _has_guppy() -> bool:
+    try:
+        from guppy import hpy  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def _guppy_heap_summary() -> str:
+    """Return per-type heap summary as a formatted string (guppy)."""
+    from guppy import hpy
+
+    hp = hpy()
+    heap = hp.heap()
+    return str(heap)
+
+
+# ── Data structures ──
+
+
+@dataclass
+class ObjectInfo:
+    """Describes a single allocated object found during a heap scan."""
+
+    type_name: str
+    size_bytes: int
+    size_kb: float
+    repr_str: str
+    obj: Any = field(repr=False)
+
+    @property
+    def size_mb(self) -> float:
+        return self.size_bytes / (1024 * 1024)
+
+
+@dataclass
+class TypeSummary:
+    """Aggregated statistics for a single type across the heap."""
+
+    type_name: str
+    count: int
+    total_size_bytes: int
+
+    @property
+    def total_size_kb(self) -> float:
+        return self.total_size_bytes / 1024
+
+    @property
+    def total_size_mb(self) -> float:
+        return self.total_size_bytes / (1024 * 1024)
+
+
+# ── Snapshot class ──
+
+
+class MemorySnapshot:
+    """Capture and analyse the current Python heap.
+
+    Uses pympler when available for deep (recursive) size calculations;
+    falls back to sys.getsizeof (shallow) otherwise.
+
+    Example
+    -------
+    >>> snap = MemorySnapshot()
+    >>> snap.print_report()
+
+    Usage
+    -------
+    from cecli.helpers.leak_detect import MemorySnapshot
+    MemorySnapshot().print_report()
+    """
+
+    def __init__(self, force_gc: bool = True):
+        if force_gc:
+            gc.collect()
+        self._all_objects: List[Any] = gc.get_objects()
+        self._has_pympler = _has_pympler()
+        self._has_guppy = _has_guppy()
+
+    # ── Size helpers ──
+
+    def _size_of(self, obj: Any) -> int:
+        # if self._has_pympler:
+        #    return _pympler_deep_size(obj)
+        return sys.getsizeof(obj)
+
+    # ── Public query methods ──
+
+    def largest_objects(self, n: int = 15) -> List[ObjectInfo]:
+        """Return the *n* largest objects in the heap (any type)."""
+        seen: set = set()
+        results: List[ObjectInfo] = []
+
+        try:
+            for obj in self._all_objects:
+                obj_id = id(obj)
+                if obj_id in seen:
+                    continue
+                seen.add(obj_id)
+                size = self._size_of(obj)
+                if size < 1024:
+                    continue
+                try:
+                    short = repr(obj)[:80]
+                except Exception:
+                    short = "<repr failed>"
+                results.append(
+                    ObjectInfo(
+                        type_name=type(obj).__name__,
+                        size_bytes=size,
+                        size_kb=size / 1024,
+                        repr_str=short,
+                        obj=obj,
+                    )
+                )
+        except Exception as e:
+            print(e)
+
+        results.sort(key=lambda x: x.size_bytes, reverse=True)
+        print("result")
+        return results[:n]
+
+    def largest_dicts(self, n: int = 5) -> List[ObjectInfo]:
+        """Return the *n* largest ``dict`` objects."""
+        return self._filter_type(dict, n)
+
+    def largest_lists(self, n: int = 5) -> List[ObjectInfo]:
+        """Return the *n* largest ``list`` objects."""
+        return self._filter_type(list, n)
+
+    def largest_class_instances(
+        self, classes: Optional[tuple] = None, n: int = 5
+    ) -> List[ObjectInfo]:
+        """Return the *n* largest instances of the given *classes*.
+
+        When *classes* is ``None`` all instances of user-defined classes
+        (excluding builtins) are considered.
+        """
+        if classes is not None:
+            targets = tuple(c for c in classes if isinstance(c, type))
+        else:
+            # Heuristic: any type whose module is not a built-in.
+            targets = None
+
+        seen: set = set()
+        results: List[ObjectInfo] = []
+
+        for obj in self._all_objects:
+            obj_id = id(obj)
+            if obj_id in seen:
+                continue
+            seen.add(obj_id)
+            if not isinstance(obj, type) and not callable(obj):
+                if targets is not None:
+                    if not isinstance(obj, targets):
+                        continue
+                else:
+                    mod = type(obj).__module__
+                    if mod in ("builtins", "_abc", "abc"):
+                        continue
+                    if type(obj).__name__.startswith("_"):
+                        continue
+
+                size = self._size_of(obj)
+                if size < 512:
+                    continue
+                try:
+                    short = repr(obj)[:80]
+                except Exception:
+                    short = "<repr failed>"
+                results.append(
+                    ObjectInfo(
+                        type_name=type(obj).__name__,
+                        size_bytes=size,
+                        size_kb=size / 1024,
+                        repr_str=short,
+                        obj=obj,
+                    )
+                )
+
+        results.sort(key=lambda x: x.size_bytes, reverse=True)
+        return results[:n]
+
+    def type_summary(self, n: int = 15) -> List[TypeSummary]:
+        """Aggregate heap usage by type (total count and size)."""
+        counter: Counter = Counter()
+        size_map: Dict[str, int] = {}
+
+        seen: set = set()
+        for obj in self._all_objects:
+            obj_id = id(obj)
+            if obj_id in seen:
+                continue
+            seen.add(obj_id)
+            tn = type(obj).__name__
+            counter[tn] += 1
+            size_map[tn] = size_map.get(tn, 0) + self._size_of(obj)
+
+        sorted_types = sorted(counter, key=lambda t: size_map[t], reverse=True)
+
+        return [
+            TypeSummary(
+                type_name=tn,
+                count=counter[tn],
+                total_size_bytes=size_map[tn],
+            )
+            for tn in sorted_types[:n]
+        ]
+
+    def guppy_summary(self) -> Optional[str]:
+        """Return per-type heap summary string via guppy (if installed)."""
+        if not self._has_guppy:
+            return None
+        return _guppy_heap_summary()
+
+    # ── Report ──
+
+    def print_report(self) -> None:
+        """Print a human-readable memory report to stdout."""
+        print("=" * 70)
+        print("MemorySnapshot Report")
+        print(f"  Objects scanned : {len(self._all_objects):,}")
+        print(
+            f"  Deep sizes      : {'yes (pympler)' if self._has_pympler else 'no (sys.getsizeof)'}"
+        )
+        print(f"  Guppy available  : {'yes' if self._has_guppy else 'no'}")
+        print("=" * 70)
+
+        # 1. Largest objects
+        print("\n>> TOP 15 LARGEST OBJECTS (any type)")
+        print("  " + "-" * 60)
+        for item in self.largest_objects(15):
+            print(f"  {item.size_kb:>10.1f} KB  {item.type_name:<15s}  {item.repr_str}")
+
+        # 2. Largest dicts
+        print("\n>> LARGEST DICTS")
+        print("  " + "-" * 60)
+        for item in self.largest_dicts(5):
+            d = item.obj
+            keys_preview = list(d.keys())[:5] if isinstance(d, dict) else []
+            print(f"  {item.size_kb:>10.1f} KB  dict[{len(d)} keys]  keys={keys_preview!r}")
+
+        # 3. Largest lists
+        print("\n>> LARGEST LISTS")
+        print("  " + "-" * 60)
+        for item in self.largest_lists(5):
+            lst = item.obj
+            first = lst[0] if lst else "empty"
+            print(f"  {item.size_kb:>10.1f} KB  list[{len(lst)} items]  first={first!r}")
+
+        # 4. Largest class instances
+        print("\n>> LARGEST CLASS INSTANCES (custom)")
+        print("  " + "-" * 60)
+        for item in self.largest_class_instances(n=10):
+            print(f"  {item.size_kb:>10.1f} KB  {item.type_name}")
+
+        # 5. Type summary
+        print("\n>> TYPE SUMMARY (total size per type)")
+        print("  " + "-" * 60)
+        for ts in self.type_summary(12):
+            print(f"  {ts.total_size_kb:>10.1f} KB  ({ts.count:>7,} objs)  {ts.type_name}")
+
+        # 6. Guppy summary if available
+        if self._has_guppy:
+            print("\n>> GUPPY HEAP SUMMARY")
+            print("  " + "-" * 60)
+            summary = self.guppy_summary()
+            if summary:
+                for line in summary.split("\n"):
+                    print(f"  {line}")
+
+        print()
+
+    # ── Internal helpers ──
+
+    def _filter_type(self, typ: type, n: int) -> List[ObjectInfo]:
+        """Return the *n* largest objects of a specific built-in type."""
+        seen: set = set()
+        results: List[ObjectInfo] = []
+
+        for obj in self._all_objects:
+            obj_id = id(obj)
+            if obj_id in seen:
+                continue
+            seen.add(obj_id)
+            if not isinstance(obj, typ):
+                continue
+
+            size = self._size_of(obj)
+            if size < 512:
+                continue
+            try:
+                short = repr(obj)[:80]
+            except Exception:
+                short = "<repr failed>"
+            results.append(
+                ObjectInfo(
+                    type_name=type(obj).__name__,
+                    size_bytes=size,
+                    size_kb=size / 1024,
+                    repr_str=short,
+                    obj=obj,
+                )
+            )
+
+        results.sort(key=lambda x: x.size_bytes, reverse=True)
+        return results[:n]

{cecli_dev-0.99.6 → cecli_dev-0.99.8}/cecli/history.py

@@ -136,28 +136,11 @@ class ChatSummary:
         raise ValueError(err)
 
     async def summarize_all_as_text(self, messages, prompt, max_tokens=None):
-        content = ""
-        for msg in messages:
-            role = msg["role"].upper()
-            if role not in ("USER", "ASSISTANT"):
-                continue
-            if not msg.get("content"):
-                continue
-            content += f"# {role}\n"
-            content += msg["content"]
-            if not content.endswith("\n"):
-                content += "\n"
-
-        summarize_messages = [
-            dict(role="system", content=prompt),
-            dict(role="user", content=content),
-        ]
+        messages.append(dict(role="user", content=prompt))
 
         for model in self.models:
             try:
-                summary = await model.simple_send_with_retries(
-                    summarize_messages, max_tokens=max_tokens
-                )
+                summary = await model.simple_send_with_retries(messages, max_tokens=max_tokens)
                 if summary is not None:
                     return summary
             except Exception as e: