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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.6
+Version: 0.99.7
 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.7}/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.7}/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.7'
+__version_tuple__ = version_tuple = (0, 99, 7)
 
-__commit_id__ = commit_id = 'g835b8b50f'
+__commit_id__ = commit_id = 'gf217080c8'

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

@@ -53,7 +53,7 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "commandinteractive",
-            "exploresymbols",
+            "explorecode",
             "ls",
             "grep",
             "showcontext",

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/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.7}/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.7}/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.7/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.7}/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:

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/cecli/main.py

@@ -23,6 +23,7 @@ import asyncio
 import json
 import os
 import re
+import shutil
 import threading
 import time
 import traceback
@@ -1511,6 +1512,36 @@ async def graceful_exit(coder=None, exit_code=0):
 
         if coder.mcp_manager and coder.mcp_manager.is_connected:
             await coder.mcp_manager.disconnect_all()
+    # Cleanup old agent directories
+    try:
+        git_root = get_git_root()
+        if git_root:
+            agents_dir = Path(git_root) / ".cecli" / "agents"
+        else:
+            agents_dir = Path(".cecli") / "agents"
+
+        if agents_dir.exists():
+            now = time.time()
+            week_seconds = 7 * 24 * 60 * 60
+
+            for agent_folder in agents_dir.iterdir():
+                if agent_folder.is_dir():
+                    try:
+                        mtime = agent_folder.stat().st_mtime
+                        if (now - mtime) > week_seconds:
+                            shutil.rmtree(agent_folder, ignore_errors=True)
+                        else:
+                            # Remove empty sub-folders in remaining folders
+                            for sub_folder in agent_folder.iterdir():
+                                if sub_folder.is_dir():
+                                    try:
+                                        sub_folder.rmdir()
+                                    except OSError:
+                                        pass
+                    except (OSError, PermissionError):
+                        pass
+    except Exception:
+        pass
 
     return exit_code
 

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/cecli/models.py

@@ -1128,7 +1128,6 @@ class Model(ModelSettings):
         from cecli.exceptions import LiteLLMExceptions
 
         litellm_ex = LiteLLMExceptions()
-        messages = model_request_parser(self, messages, None)
         retry_delay = 0.125
         if self.verbose:
             dump(messages)

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/cecli/prompts/agent.yml

@@ -39,7 +39,7 @@ main_system: |
   <context name="workflow_and_tool_usage">
   ## Core Workflow
   1. **Plan**: Start by using `UpdateTodoList` to outline the task.
-  2. **Explore**: Use discovery tools (`ExploreSymbols`, `Grep`, `Ls`) to research and gather understanding for you task. Use `ContextManager` to add files contents as context.
+  2. **Explore**: Use discovery tools (`ExploreCode`, `Grep`, `Ls`) to research and gather understanding for you task. Use `ContextManager` to add files contents as context.
   3. **Execute**: Use the appropriate editing tool. Mark files as editable with `ContextManager` before attempting edits. Proactively use skills if they are available.
   4. **Verify & Recover**: Review the diff output of every edit. If an edit fails or introduces linting errors, use `UndoChange` immediately.
   5. **Finished**: Use the `Finished` tool only after verifying the solution. Briefly summarize the changes for the user.

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/cecli/prompts/base.yml

@@ -84,8 +84,9 @@ rename_with_shell: ""
 go_ahead_tip: ""
 
 compaction_prompt: |
+  ---
   # Instruction: Context Compaction & State Preservation
-  The following conversation is exceeding the context limit. Transform this history into a "Mission Intent" summary that allows a new LLM instance to resume with zero loss of technical momentum.
+  The current conversation is exceeding the context limit. Transform this history into a "Mission Intent" summary that allows a new LLM instance to resume with zero loss of technical momentum.
   
   ## Required Output Format:
 
@@ -100,11 +101,11 @@ compaction_prompt: |
   ### 3. Strategic Pivot & Next Steps
   - **Current Intent**: What is the model currently trying to prove or implement?
   - **Immediate Next Steps**: The prioritized next tool calls and logic steps.
-  ---
-  ## Conversation History to Compact:
+
 
 observation_prompt: |
-  Review the following conversation history and extract an 
+  ---
+  Review the current conversation stream and extract an 
   event-based log of key decisions, tool outputs, and user requests.
   Focus on "what happened" rather than a narrative summary.
   Use a bulleted list of concise, factual statements.
@@ -112,7 +113,8 @@ observation_prompt: |
   Do not describe tool syntax; describe what was learned or changed in one sentence per bullet.
 
 reflection_prompt: |
-  Condense the following observation log into a consolidated set of 
+  ---
+  Condense this observation log into a consolidated set of 
   key historical facts. Additionally, explicitly state the 
   CURRENT GOALS and NEXT STEPS based on the history.
 

{cecli_dev-0.99.6 → cecli_dev-0.99.7}/cecli/tools/__init__.py

@@ -7,7 +7,7 @@ from . import (
     command_interactive,
     context_manager,
     delete_text,
-    explore_symbols,
+    explore_code,
     finished,
     git_branch,
     git_diff,
@@ -33,7 +33,7 @@ TOOL_MODULES = [
     command_interactive,
     context_manager,
     delete_text,
-    explore_symbols,
+    explore_code,
     finished,
     git_branch,
     git_diff,