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

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

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

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

{cecli_dev-0.100.11rc2 → cecli_dev-0.100.11rc4}/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.11rc2 → cecli_dev-0.100.11rc4}/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.11rc2 → cecli_dev-0.100.11rc4}/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.11rc2 → cecli_dev-0.100.11rc4}/cecli/coders/copypaste_coder.py

@@ -80,7 +80,7 @@ class CopyPasteCoder(Coder):
         target_coder_class = None
         if coders is not None and selected_edit_format:
             # Use EDIT_FORMAT_MAP from base_coder to find the right coder class by edit_format
-            from cecli.coders.base_coder import EDIT_FORMAT_MAP
+            from cecli.coders import EDIT_FORMAT_MAP
 
             coder_name = EDIT_FORMAT_MAP.get(selected_edit_format)
             if coder_name:

{cecli_dev-0.100.11rc2 → cecli_dev-0.100.11rc4}/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.11rc2 → cecli_dev-0.100.11rc4}/cecli/helpers/hashline.py

@@ -1427,109 +1427,89 @@ def _apply_closure_safeguard(
     original_content: str,
     resolved_ops: list,
     file_path: str = None,
-) -> list:
+) -> tuple[list, list]:
     """
-    Use tree-sitter to heal edit boundaries by simulating edits and checking syntax.
-
-    For each replace/delete operation, this simulates applying the edit with
-    the replacement text, parses the resulting code with tree-sitter, and
-    checks if the result is syntactically valid (no ERROR/MISSING nodes).
-
-    If the edit produces invalid syntax (e.g., missing closing braces),
-    it progressively expands/contracts the start and end boundaries by a
-    step and re-tests until the resulting code parses correctly or the
-    maximum number of expansion steps is exhausted.
-
-    This prevents the common LLM edit error of "eating" outer scope
-    closing braces, parentheses, or brackets by finding the nearest
-    syntactically valid edit boundary.
-
-    Args:
-        original_content: Original source code (without hashlines)
-        resolved_ops: List of resolved operation dicts with start_idx/end_idx
-        file_path: File path to determine tree-sitter language
+    Use tree-sitter to heal edit boundaries by simulating edits and scoring by AST health.
+    Evicts edits that strictly increase the number of syntax errors.
 
     Returns:
-        Modified resolved_ops with healed boundaries
+        tuple: (safe_resolved_ops, rejected_ops)
+        - safe_resolved_ops: Operations with healed boundaries
+        - rejected_ops: List of dicts with {"index": int, "error": str} for evicted operations
     """
-
-    def is_syntactically_valid(source_bytes: bytes, parser) -> bool:
-        try:
-            tree = parser.parse(source_bytes)
-            return not tree.root_node.has_error
-        except Exception:
-            return False
-
-    def apply_edit(
-        source_lines: list[str],
-        start: int,
-        end: int,
-        replacement: list[str],
-    ) -> bytes:
-        """Applies the edit and returns the new source code as bytes."""
-        new_lines = source_lines[:start] + replacement + source_lines[end + 1 :]
-        return "\n".join(new_lines).encode("utf-8")
-
-    def count_closures(source_bytes: bytes) -> int:
-        """Counts the total number of brackets, braces, and parenthesis."""
-        return sum(source_bytes.count(b) for b in b"{}[]()")
-
-    def get_indentation(line: str) -> int:
-        """Helper to safely calculate the leading whitespace of a line."""
-        return len(line) - len(line.lstrip(" \t"))
-
     if not resolved_ops or not file_path:
-        return resolved_ops
+        return resolved_ops, []
 
-    # Determine language from file path
     from cecli.helpers.grep_ast.parsers import filename_to_lang
     from cecli.helpers.grep_ast.tsl import get_language, get_parser
 
     lang = filename_to_lang(file_path)
     if not lang:
-        return resolved_ops
+        return resolved_ops, []
 
-    # Set up tree-sitter parser
     try:
         language = get_language(lang)  # noqa
         parser = get_parser(lang)
     except Exception:
-        # Can't determine language, skip safeguard
-        return resolved_ops
+        return resolved_ops, []
 
     source_lines = original_content.splitlines()
+    source_bytes = original_content.encode("utf-8")
+
+    def apply_edit(
+        lines: list[str],
+        start: int,
+        end: int,
+        replacement: list[str],
+    ) -> bytes:
+        """Applies the edit and returns the new source code as bytes."""
+        new_lines = lines[:start] + replacement + lines[end + 1 :]
+        return "\n".join(new_lines).encode("utf-8")
+
+    def count_ast_errors(node) -> int:
+        """
+        Recursively counts MISSING or ERROR nodes in the AST.
+        """
+        errors = 0
+        if node.is_missing or node.type == "ERROR":
+            errors += 1
+        for child in node.children:
+            errors += count_ast_errors(child)
+        return errors
+
+    # Establish the baseline syntax health of the original file
+    base_tree = parser.parse(source_bytes)
+    baseline_error_count = count_ast_errors(base_tree.root_node)
+
+    safe_resolved_ops = []
+    rejected_ops = []
 
     for resolved in resolved_ops:
         op = resolved["op"]
         if op["operation"] not in {"replace", "insert", "delete"}:
+            safe_resolved_ops.append(resolved)
             continue
 
         llm_start = resolved["start_idx"]
         llm_end = resolved["end_idx"]
 
-        # Clamp to valid bounds
         if llm_start < 0 or llm_start >= len(source_lines):
+            safe_resolved_ops.append(resolved)
             continue
         if llm_end < llm_start:
+            safe_resolved_ops.append(resolved)
             continue
 
-        # Get replacement text
         replacement_text = op.get("text", "") or ""
         if op["operation"] == "delete":
             replacement_text = ""
         repl_lines = replacement_text.splitlines()
 
-        # Clamp end to valid range
         llm_end = min(llm_end, len(source_lines) - 1)
 
-        # --- THE HEALING LOOP ---
-        # Generate all combinations of offsets in {-2, -1, 0, 1, 2} for both
-        # start and end, then filter to syntactically valid edits and rank
-        # by cumulative movement (abs(start_shift) + abs(end_shift)) as a
-        # primary criterion to bias toward minimal range perturbation.
-
         offsets = [0, 1, -1, 2, -2]
         all_candidates = []
+
         for start_shift in offsets:
             for end_shift in offsets:
                 candidate_start = max(0, llm_start - start_shift)
@@ -1538,7 +1518,6 @@ def _apply_closure_safeguard(
                 if candidate_end < candidate_start:
                     continue
 
-                # Skip candidates that overlap with other operations' ranges
                 overlaps = False
                 for other_op in resolved_ops:
                     if other_op is resolved:
@@ -1552,87 +1531,52 @@ def _apply_closure_safeguard(
                 if overlaps:
                     continue
 
-                # Skip candidates that would create duplicate adjacent content at edit boundaries
                 if _would_create_duplicate_content(
                     source_lines, candidate_start, candidate_end, repl_lines
                 ):
                     continue
 
-                test_source = apply_edit(
+                test_source_bytes = apply_edit(
                     source_lines,
                     candidate_start,
                     candidate_end,
                     repl_lines,
                 )
 
-                if is_syntactically_valid(test_source, parser):
-                    # Determine properties for tiebreaking
-                    is_partial = (start_shift == 0) ^ (end_shift == 0)  # XOR: exactly one is zero
-                    is_downward = start_shift <= 0  # Negative/zero shift = moving down
-                    is_both = start_shift == end_shift  # Whole range expansion/contraction
-                    closures = count_closures(test_source)
-                    start_line_match = source_lines[candidate_start] == source_lines[llm_start]
-                    end_line_match = source_lines[candidate_end] == source_lines[llm_end]
-                    cumulative_movement = abs(start_shift) + abs(end_shift)
-
-                    # --- INDENTATION SCORING ---
-                    indent_score = 0
-                    if repl_lines:
-                        # Safely grab the first and last non-empty replacement lines
-                        first_repl = next((line for line in repl_lines if line.strip()), "")
-                        last_repl = next(
-                            (line for line in reversed(repl_lines) if line.strip()), ""
-                        )
-
-                        # Check Start Boundary Match
-                        if first_repl and candidate_start < len(source_lines):
-                            source_start_line = source_lines[candidate_start]
-                            if source_start_line.strip() and get_indentation(
-                                first_repl
-                            ) == get_indentation(source_start_line):
-                                indent_score += 1
-
-                        # Check End Boundary Match
-                        if last_repl and candidate_end < len(source_lines):
-                            source_end_line = source_lines[candidate_end]
-                            if source_end_line.strip() and get_indentation(
-                                last_repl
-                            ) == get_indentation(source_end_line):
-                                indent_score += 1
-
-                    all_candidates.append(
-                        {
-                            "start_idx": candidate_start,
-                            "end_idx": candidate_end,
-                            "start_line_match": start_line_match,
-                            "end_line_match": end_line_match,
-                            "source_len": len(test_source),
-                            "is_partial": is_partial,
-                            "is_downward": is_downward,
-                            "is_both": is_both,
-                            "closure_count": closures,
-                            "indent_score": indent_score,
-                            "cumulative_movement": cumulative_movement,
-                            "offsets": (start_shift, end_shift),
-                        }
-                    )
+                # Parse the candidate to get structural truth
+                edited_tree = parser.parse(test_source_bytes)
+                ast_error_count = count_ast_errors(edited_tree.root_node)
+
+                is_partial = (start_shift == 0) ^ (end_shift == 0)
+                is_downward = start_shift <= 0
+                is_both = start_shift == end_shift
+                start_line_match = source_lines[candidate_start] == source_lines[llm_start]
+                end_line_match = source_lines[candidate_end] == source_lines[llm_end]
+                cumulative_movement = abs(start_shift) + abs(end_shift)
+
+                all_candidates.append(
+                    {
+                        "start_idx": candidate_start,
+                        "end_idx": candidate_end,
+                        "ast_error_count": ast_error_count,
+                        "start_line_match": start_line_match,
+                        "end_line_match": end_line_match,
+                        "cumulative_movement": cumulative_movement,
+                        "is_partial": is_partial,
+                        "is_downward": is_downward,
+                        "is_both": is_both,
+                    }
+                )
 
         if all_candidates:
-            # Sort using the new hierarchy:
-            # 1. Cumulative movement (ascending — less movement is better)
-            # 2. Fewest total closures (minimize structural pollution)
-            # 3. Indentation Score (Descending: 2 is better than 0)
-            # 4. Longest source (preserve more file content)
-            # 5. Partial expansions over full range shifts
-            # 6. Downward changes over upward changes
+            # 1. AST Health is the absolute highest priority.
+            # 2. Cumulative movement acts as the tie-breaker for equally valid ASTs.
             all_candidates.sort(
                 key=lambda r: (
+                    r["ast_error_count"],  # Ascending: fewer syntax errors wins
                     not r["start_line_match"],  # Descending: True first
                     not r["end_line_match"],  # Descending: True first
                     r["cumulative_movement"],  # Ascending: smaller is better
-                    -r["indent_score"],  # Descending: larger score is better (2 > 1 > 0)
-                    -r["source_len"],  # Descending: larger is better
-                    r["closure_count"],  # Ascending: smaller is better
                     not r["is_partial"],  # Booleans: False comes before True
                     not r["is_downward"],  # Booleans: False comes before True
                     r["is_both"],  # Booleans: False comes before True
@@ -1640,10 +1584,30 @@ def _apply_closure_safeguard(
             )
 
             best = all_candidates[0]
+
+            # EVICTION GATE: If the absolute best boundary still introduces NEW
+            # syntax errors compared to the original file, discard the edit entirely.
+            if best["ast_error_count"] > baseline_error_count:
+
+                rejected_ops.append(
+                    {
+                        "index": resolved["index"],
+                        "error": (
+                            f"Edit introduces new syntax error(s) (baseline: {baseline_error_count}, "
+                            f"after edit: {best['ast_error_count']}) and none of the "
+                            f"{len(all_candidates)} candidate boundary adjustments could resolve it"
+                        ),
+                        "operation": op,
+                    }
+                )
+                continue
+
             resolved["start_idx"] = best["start_idx"]
             resolved["end_idx"] = best["end_idx"]
 
-    return resolved_ops
+        safe_resolved_ops.append(resolved)
+
+    return safe_resolved_ops, rejected_ops
 
 
 def apply_hashline_operations(
@@ -1794,7 +1758,16 @@ def apply_hashline_operations(
 
     if file_path:
         # Apply tree-sitter based closure safeguard to snap boundaries to AST nodes
-        resolved_ops = _apply_closure_safeguard(original_content, resolved_ops, file_path)
+        safe_ops, rejected_ops = _apply_closure_safeguard(original_content, resolved_ops, file_path)
+        resolved_ops = safe_ops
+        for rejected in rejected_ops:
+            failed_ops.append(
+                {
+                    "index": rejected["index"],
+                    "error": rejected["error"],
+                    "operation": rejected["operation"],
+                }
+            )
 
         # Fix edit boundaries where replacement content duplicates adjacent lines
         source_lines = original_content.splitlines()

{cecli_dev-0.100.11rc2 → cecli_dev-0.100.11rc4}/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.11rc2 → cecli_dev-0.100.11rc4}/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