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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.11rc2
+Version: 0.100.11rc3
 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.11rc3}/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.11rc3'
+__version_tuple__ = version_tuple = (0, 100, 11, 'rc3')
 
-__commit_id__ = commit_id = 'ge6afc3ffc'
+__commit_id__ = commit_id = 'g11ba4d315'

{cecli_dev-0.100.11rc2 → cecli_dev-0.100.11rc3}/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.11rc3}/cecli/tools/edit_text.py

@@ -24,6 +24,12 @@ OPERATION_NOUNS = {
 }
 
 
+USER_EDIT_CATEGORIES = {
+    "no_changes": "No Changes",
+    "syntax_errors": "Syntax Errors",
+}
+
+
 class Tool(BaseTool):
     NORM_NAME = "edittext"
     TRACK_INVOCATIONS = False
@@ -37,54 +43,58 @@ class Tool(BaseTool):
             "name": "EditText",
             "description": (
                 "Edit text in one or more files using content ID markers. "
-                "Supports replace and delete operations in a single call. "
-                "Can handle an array of edits across multiple files. "
-                "Each edit must include its own file_path and operation type. "
-                "Use content ID ranges with the start_line and end_line parameters with format "
-                "`content_id::` (the content id with the :: demarcator). For empty files, use `@000` as the "
-                "content ID references. "
-                "Start and end values are inclusive: start and end content IDs both count as "
-                "part of the range to replace or delete. "
-                "Edits within a file must not be adjacent or overlapping."
+                "You can perform multiple 'replace' or 'delete' operations in a single call. "
+                "CRITICAL RULES: "
+                "1. Start and end content IDs are INCLUSIVE. Both will be modified or deleted. "
+                "2. Edits within the same file MUST NOT be adjacent or overlapping. "
+                "3. For empty files, you MUST use '@000' as the content ID reference."
             ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "edits": {
                         "type": "array",
+                        "description": (
+                            "List of edit operations to apply. Each edit requires a "
+                            "file path, operation type, start/end IDs, and text."
+                        ),
                         "items": {
                             "type": "object",
                             "properties": {
                                 "file_path": {
                                     "type": "string",
-                                    "description": "Required file path for this specific edit.",
+                                    "description": (
+                                        "The absolute or relative path to the file being edited."
+                                    ),
                                 },
                                 "operation": {
                                     "type": "string",
                                     "enum": ["replace", "delete"],
                                     "description": (
-                                        "The type of operation: 'replace' (replace range with"
-                                        " text) or 'delete' (remove range)."
+                                        "Choose 'replace' to swap the ID range with new text, "
+                                        "or 'delete' to remove the ID range entirely."
                                     ),
                                 },
                                 "start_line": {
                                     "type": "string",
                                     "description": (
-                                        "Content ID for start line. Only include the id and demarcator."
+                                        "The exact content ID and demarcator for the start of the edit "
+                                        "(e.g., 'abc::'). For empty files, use '@000'."
                                     ),
                                 },
                                 "end_line": {
                                     "type": "string",
                                     "description": (
-                                        "Content ID for end line. Only include the id and demarcator."
+                                        "The exact content ID and demarcator for the end of the edit "
+                                        "(e.g., 'xyz::'). For empty files, use '@000'."
                                     ),
                                 },
                                 "text": {
                                     "type": "string",
                                     "description": (
-                                        "Text content for replace operations. "
-                                        "Empty string for delete operations. "
-                                        "Do not include content IDs inside replacement text"
+                                        "The exact replacement text. If operation is 'delete', "
+                                        'this MUST be an empty string (""). '
+                                        "NEVER include content IDs in this text."
                                     ),
                                 },
                             },
@@ -96,9 +106,11 @@ class Tool(BaseTool):
                                 "text",
                             ],
                         },
-                        "description": "Array of edits to apply.",
                     },
-                    "change_id": {"type": "string"},
+                    "change_id": {
+                        "type": "string",
+                        "description": "Optional tracking ID for this batch of edits.",
+                    },
                 },
                 "required": ["edits"],
             },
@@ -255,7 +267,9 @@ class Tool(BaseTool):
 
                         except Exception as e:
                             # Record failed edit but continue with others
-                            file_failed_edits.append(f"Edit {edit_index + 1}: {str(e)}")
+                            file_failed_edits.append(
+                                f"Edit {edit_index + 1} - {cls._categorize_edit_error(str(e))}"
+                            )
                             continue
 
                     # Apply all operations in batch
@@ -269,13 +283,27 @@ class Tool(BaseTool):
                         if new_content != original_content:
                             file_successful_edits += len(successful_ops)
                         else:
-                            raise ToolError("Invalid Edit - Update content ID bounds")
+                            # Be specific about why content didn't change
+                            if failed_ops:
+                                error_details = "; ".join(
+                                    f"Edit {op['index'] + 1}: {op['error']}" for op in failed_ops
+                                )
+                                raise ToolError(
+                                    f"Invalid Edit - Update content ID bounds: {error_details}"
+                                )
+                            else:
+                                raise ToolError(
+                                    "Invalid Edit - Update content ID bounds - "
+                                    "all edits resulted in unchanged content"
+                                )
 
                         if len(failed_ops):
                             for failed_op in failed_ops:
                                 op_index = failed_op["index"]
                                 op_error = failed_op["error"]
-                                file_failed_edits.append(f"Edit {op_index + 1}: {str(op_error)}")
+                                file_failed_edits.append(
+                                    f"Edit {op_index + 1} - {cls._categorize_edit_error(str(op_error))}"
+                                )
                     except Exception as e:
                         # If batch operation fails, mark all operations as failed
                         for edit_index, _ in file_edits:
@@ -339,7 +367,9 @@ class Tool(BaseTool):
                 except Exception as e:
                     # Record all edits for this file as failed
                     for edit_index, _ in file_edits:
-                        all_failed_edits.append(f"Edit {edit_index + 1}: {str(e)}")
+                        all_failed_edits.append(
+                            f"Edit {edit_index + 1} - {cls._categorize_edit_error(str(e))}"
+                        )
                     continue
 
             # If dry run, return all results
@@ -360,10 +390,6 @@ class Tool(BaseTool):
                 raise ToolError(error_msg)
 
             # 5. Format and return result
-            # Log failed edit messages to console for visibility
-            if all_failed_edits:
-                for failed_msg in all_failed_edits:
-                    coder.io.tool_error(failed_msg)
 
             if files_processed == 1:
                 # Single file case
@@ -459,6 +485,9 @@ class Tool(BaseTool):
                             original_content = coder.io.read_text(abs_path)
 
                             if original_content is not None:
+                                start_line, end_line = resolve_content_to_hashline_ids(
+                                    original_content, start_line, end_line
+                                )
                                 diff_output = get_hashline_diff(
                                     original_content=strip_hashline(original_content),
                                     start_line_hash=start_line,
@@ -483,3 +512,21 @@ class Tool(BaseTool):
                         coder.io.tool_output("")
 
         tool_footer(coder=coder, tool_response=tool_response, params=params)
+
+    @classmethod
+    def _categorize_edit_error(cls, error_msg: str) -> str:
+        """Categorize an edit error message into a user-friendly display category.
+
+        Maps errors from apply_hashline_operations to simplified category names
+        for user-facing output instead of displaying full error details.
+
+        Args:
+            error_msg: The raw error message string.
+
+        Returns:
+            str: The display category name (e.g., "No Changes", "Syntax Errors").
+        """
+        error_lower = error_msg.lower()
+        if "syntax error" in error_lower or "introduces new syntax" in error_lower:
+            return USER_EDIT_CATEGORIES["syntax_errors"]
+        return USER_EDIT_CATEGORIES["no_changes"]

{cecli_dev-0.100.11rc2 → cecli_dev-0.100.11rc3}/cecli_dev.egg-info/PKG-INFO

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.100.11rc2",
+  "tag": "0.100.11rc3",
   "distance": 0,
-  "node": "ge6afc3ffc1f3bdf42e47e0ece67faa27674c9362",
+  "node": "g11ba4d31552be3bd51e2dc4fa32c676f0e5c783d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-06-30"