cecli-dev 0.100.5__tar.gz → 0.100.6rc1__tar.gz

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.5
+Version: 0.100.6rc1
 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.5 → cecli_dev-0.100.6rc1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.5'
-__version_tuple__ = version_tuple = (0, 100, 5)
+__version__ = version = '0.100.6rc1'
+__version_tuple__ = version_tuple = (0, 100, 6, 'rc1')
 
-__commit_id__ = commit_id = 'g525f9aba5'
+__commit_id__ = commit_id = 'gd52e51e0f'

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/coders/agent_coder.py

@@ -1115,7 +1115,7 @@ class AgentCoder(Coder):
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
                 "File editing tools are currently disabled. Use `ReadRange` to determine the"
-                " current content hash prefixes needed to perform an edit and activate them when"
+                " current content ID prefixes needed to perform an edit and activate them when"
                 " you are ready to edit a file."
             )
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/helpers/conversation/files.py

@@ -281,14 +281,17 @@ class ConversationFiles:
             diff_message = {
                 "role": "user",
                 "content": (
-                    f"{rel_fname} has been updated. Here is a git diff of the changes to"
-                    f" review:\n\n{diff}"
+                    f"{rel_fname} has been updated. Review this git diff of the changes to"
+                    f" ensure the modifications are intended:\n\n{diff}"
                 ),
             }
 
             assistant_msg = {
                 "role": "assistant",
-                "content": f"Thank you for sharing this diff of the updates to {rel_fname}.",
+                "content": (
+                    f"Thank you for sharing this diff of the updates to {rel_fname}."
+                    " I will review their contents next turn."
+                ),
             }
 
             ConversationService.get_manager(coder).add_message(

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/helpers/hashline.py

@@ -650,6 +650,20 @@ def _apply_start_stitching(
                     # The replacement line matches the line being replaced
                     # Don't stitch to a line in lines_before_range
                     continue
+
+                # Require 2 consecutive matching lines to avoid false positives
+                # (single boilerplate lines like "import sys" or "def foo():"
+                # are too likely to be coincidental)
+                if line_idx + 1 < len(replacement_lines) and match_index + 1 < len(
+                    lines_before_range_normalized
+                ):
+                    next_repl = replacement_lines[line_idx + 1]
+                    next_repl_stripped = strip_hashline(next_repl)
+                    if not next_repl_stripped.endswith("\n"):
+                        next_repl_stripped += "\n"
+                    if next_repl_stripped != lines_before_range_normalized[match_index + 1]:
+                        continue  # Only 1 line matches — likely coincidental
+
                 # Found a line that already exists before the range!
                 # This is a non-contiguous match - we need to "stitch" the replacement
                 # at this exact content match to prevent duplicate code structures
@@ -694,9 +708,9 @@ def _apply_start_stitching(
                     start_idx = new_start_idx
                     replacement_lines = new_replacement_lines
                 else:
-                    # Can't extend backward due to overlap, but we can still truncate
-                    # the replacement text to avoid duplication
-                    replacement_lines = new_replacement_lines
+                    # Can't extend backward due to overlap with another operation
+                    # Don't truncate without extending — that would silently lose content
+                    continue  # Try next line instead
 
                 # We've found our stitching point, break out of the loop
                 break
@@ -772,6 +786,15 @@ def _apply_end_stitching(
             # Check if this line exists anywhere in lines_after_range_normalized
             try:
                 match_index = lines_after_range_normalized.index(replacement_line_stripped)
+
+                # Require 2 consecutive matching lines to reduce false positives
+                if line_idx - 1 >= 0 and match_index - 1 >= 0:
+                    prev_repl = replacement_lines[line_idx - 1]
+                    prev_repl_stripped = strip_hashline(prev_repl)
+                    if not prev_repl_stripped.endswith("\n"):
+                        prev_repl_stripped += "\n"
+                    if prev_repl_stripped != lines_after_range_normalized[match_index - 1]:
+                        continue  # Only 1 line matches — likely coincidental
                 # Found a line that already exists after the range!
                 # This is a non-contiguous match - we need to "stitch" the replacement
                 # at this exact content match to prevent duplicate code structures
@@ -900,109 +923,6 @@ def _apply_range_shifting(hashed_lines, resolved_ops):
     return resolved_ops
 
 
-# Regex configuration
-RE_CODE_NOISE = r'(#.*|//.*|/\*[\s\S]*?\*/|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\')'
-
-
-def get_brace_balance(lines_to_check: list[str]) -> int:
-    """
-    Calculates the net curly brace debt of a list of lines.
-    Automatically strips hashlines, comments, and string literals.
-    """
-    text = "".join(lines_to_check)
-    clean_code = strip_hashline(text)
-    clean_code = re.sub(RE_CODE_NOISE, "", clean_code)
-    return clean_code.count("{") - clean_code.count("}")
-
-
-def _apply_closure_safeguard(hashed_lines, resolved_ops):
-    """
-    Enhanced closure safeguard with dynamic bidirectional search.
-    """
-    # Tune these to adjust how far the 'healing' logic searches
-    MAX_LOOK_DOWN = 5
-    # Note: We'll calculate the actual MAX_LOOK_UP per operation
-    # to ensure we don't scan past the start_idx.
-
-    for i, resolved in enumerate(resolved_ops):
-        op = resolved["op"]
-        if op["operation"] not in {"replace", "delete"}:
-            continue
-
-        replacement_text = op.get("text", "") or ""
-        replacement_lines = replacement_text.splitlines(keepends=True)
-
-        # --- PHASE 1: BIDIRECTIONAL STRUCTURAL HEALING ---
-        if get_brace_balance([replacement_text]) == 0:
-            start_idx = resolved["start_idx"]
-            orig_end_idx = resolved["end_idx"]
-
-            if get_brace_balance(hashed_lines[start_idx : orig_end_idx + 1]) != 0:
-                # Dynamic Search List Generation
-                # We limit look-up so we don't scan before the start_idx
-                actual_max_up = orig_end_idx - start_idx
-                actual_max_down = max(MAX_LOOK_DOWN, orig_end_idx - start_idx)
-                search_offsets = []
-
-                # Generate alternating offsets: [1, -1, 2, -2, ... N]
-                for dist in range(1, max(actual_max_down, actual_max_up) + 1):
-                    if dist <= actual_max_down:
-                        search_offsets.append(dist)
-                    if dist <= actual_max_up:
-                        search_offsets.append(-dist)
-
-                for offset in search_offsets:
-                    candidate_end = orig_end_idx + offset
-
-                    # Safety: check bounds and avoid overlapping other ops
-                    if candidate_end < start_idx or candidate_end >= len(hashed_lines):
-                        continue
-
-                    if any(
-                        j != i and (other["start_idx"] <= candidate_end <= other["end_idx"])
-                        for j, other in enumerate(resolved_ops)
-                    ):
-                        continue
-
-                    if get_brace_balance(hashed_lines[start_idx : candidate_end + 1]) == 0:
-                        resolved["end_idx"] = candidate_end
-                        break
-
-        # --- PHASE 2: CONTRACTION (Indentation Guard) ---
-        # Prevents replacing an outer-scope brace if the replacement text already
-        # includes its own correctly indented closer.
-        if not replacement_lines:
-            continue
-
-        last_repl_line = strip_hashline(replacement_lines[-1])
-        last_repl_stripped = last_repl_line.strip().rstrip(";,")
-
-        if last_repl_stripped and last_repl_stripped[-1] in "})]":
-            # Calculate replacement indent
-            repl_indent = len(last_repl_line) - len(last_repl_line.lstrip(" \t"))
-
-            if resolved["end_idx"] < len(hashed_lines):
-                end_line = strip_hashline(hashed_lines[resolved["end_idx"]])
-                check_end = end_line.strip().rstrip(";,")
-
-                if check_end and check_end[-1] in "})]":
-                    # Calculate indent of the existing brace in the file
-                    file_indent = len(end_line) - len(end_line.lstrip(" \t"))
-
-                    # If the file's brace is less indented, it belongs to an outer scope
-                    if file_indent < repl_indent and resolved["end_idx"] > resolved["start_idx"]:
-                        new_end_idx = resolved["end_idx"] - 1
-
-                        # Safety: don't contract into another operation's territory
-                        if not any(
-                            j != i and (other["start_idx"] <= new_end_idx <= other["end_idx"])
-                            for j, other in enumerate(resolved_ops)
-                        ):
-                            resolved["end_idx"] = new_end_idx
-
-    return resolved_ops
-
-
 def _merge_replace_operations(resolved_ops):
     """
     Merge contiguous or overlapping replace operations.
@@ -1411,9 +1331,6 @@ def apply_hashline_operations(
     resolved_ops = _merge_replace_operations(resolved_ops)
     # Apply content-aware range expansion/shifting for replace operations
     # resolved_ops = _apply_range_shifting(hashed_lines, resolved_ops)
-    # Apply closure safeguard for braces/brackets
-    resolved_ops = _apply_closure_safeguard(hashed_lines, resolved_ops)
-
     # Sort by start_idx descending to apply from bottom to top
     # When operations have same start_idx, apply in order: insert, replace, delete
     # This ensures correct behavior when multiple operations target the same line

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/helpers/hashpos/hashpos.py

@@ -52,7 +52,7 @@ class HashPos:
     def generate_public_id(self, text: str, line_idx: int) -> str:
         """
         Generates a 4-char Base64 ID combining modulo buckets and context hash.
-        Layout: [2-bit b1] [10-bit Hash A] [2-bit b2] [10-bit Hash B]
+        Layout: [2-bit b1] [2-bit b2] [10-bit Hash A] [10-bit Hash B]
         """
         b1, b2 = self._get_region_bits(line_idx)
         neighborhood_hash = self._get_neighborhood_hash(line_idx)
@@ -62,8 +62,7 @@ class HashPos:
         hash_b = neighborhood_hash & 0x3FF
 
         # Construct the mixed 24-bit integer
-        packed = (b1 << 22) | (hash_a << 12) | (b2 << 10) | hash_b
-
+        packed = (b1 << 22) | (b2 << 20) | (hash_a << 10) | hash_b
         res = ""
         for _ in range(4):
             res += self.B64[packed % 64]
@@ -79,10 +78,9 @@ class HashPos:
             packed |= self.B64.index(char) << (6 * i)
 
         b1 = (packed >> 22) & 3
-        hash_a = (packed >> 12) & 0x3FF
-        b2 = (packed >> 10) & 3
+        b2 = (packed >> 20) & 3
+        hash_a = (packed >> 10) & 0x3FF
         hash_b = packed & 0x3FF
-
         mod_val = (b1 << 2) | b2
         neighborhood_hash = (hash_a << 10) | hash_b
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/prompts/agent.yml

@@ -29,8 +29,8 @@ main_system: |
 
   <context name="file_format">
   ### 1. FILE FORMAT
-  File contents will be prefixed with identifiers. Each line starts with a case-sensitive content hash followed by `::`. These are used to target where editing tools will perform edits.
-  They are algorithmically generated, maintained, and subject to change. Do not search for these content hashes. Focus on the lines they identify.
+  File contents will be prefixed with identifiers. Each line starts with a case-sensitive content ID followed by `::`. These are used to target where editing tools will perform edits.
+  They are algorithmically generated, maintained, and subject to change. Do not search for these content IDs. Focus on the lines they identify.
 
   **Example File Format :**
   il9n::#!/usr/bin/env python3

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/prompts/hashline.yml

@@ -6,7 +6,7 @@ main_system: |
   Act as an expert software developer. Plan carefully, explain your logic briefly, and execute via LOCATE/CONTENTS blocks.
 
   ### 1. FILE FORMAT
-  Files are provided in "hashline" format. Each line starts with a case-sensitive content hash followed by `::`. 
+  Files are provided in "hashline" format. Each line starts with a case-sensitive content ID followed by `::`. 
   These hashes are used as identifiers for lines when editing.
   
   **Example File Format :**

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/tools/edit_text.py

@@ -35,13 +35,13 @@ class Tool(BaseTool):
         "function": {
             "name": "EditText",
             "description": (
-                "Edit text in one or more files using content hash markers. "
+                "Edit text in one or more files using content ID markers. "
                 "Supports replace, delete, and insert operations in a single call. "
                 "Can handle an array of up to 10 edits across multiple files. "
                 "Each edit must include its own file_path and operation type. "
-                "Use content hash ranges with the start_line and end_line parameters with format "
+                "Use content ID ranges with the start_line and end_line parameters with format "
                 "`{4 char hash}` (without the braces). For empty files, use `@000` as the "
-                "content hash references."
+                "content ID references."
             ),
             "parameters": {
                 "type": "object",
@@ -74,14 +74,14 @@ class Tool(BaseTool):
                                 "start_line": {
                                     "type": "string",
                                     "description": (
-                                        "Content hash for start line: `{4 char hash}` (without "
+                                        "content ID for start line: `{4 char hash}` (without "
                                         "the braces)"
                                     ),
                                 },
                                 "end_line": {
                                     "type": "string",
                                     "description": (
-                                        "Content hash for end line: `{4 char hash}` (without the"
+                                        "content ID for end line: `{4 char hash}` (without the"
                                         " braces)"
                                     ),
                                 },
@@ -248,7 +248,7 @@ class Tool(BaseTool):
                         if new_content != original_content:
                             file_successful_edits += len(successful_ops)
                         else:
-                            raise ToolError("Invalid Edit - Update content hash bounds")
+                            raise ToolError("Invalid Edit - Update content ID bounds")
 
                         if len(failed_ops):
                             for failed_op in failed_ops:
@@ -446,7 +446,7 @@ class Tool(BaseTool):
                                     text=strip_hashline(text),
                                 )
                         except ContentHashError as e:
-                            diff_output = f"Content hash verification failed: {str(e)}"
+                            diff_output = f"content ID verification failed: {str(e)}"
                         except Exception:
                             pass
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc1}/cecli/tools/grep.py

@@ -46,24 +46,14 @@ class Tool(BaseTool):
                                 },
                                 "use_regex": {
                                     "type": "boolean",
-                                    "default": False,
+                                    "default": True,
                                     "description": "Whether to use regex.",
                                 },
                                 "case_insensitive": {
                                     "type": "boolean",
-                                    "default": False,
+                                    "default": True,
                                     "description": "Whether to perform a case-insensitive search.",
                                 },
-                                "context_before": {
-                                    "type": "integer",
-                                    "default": 5,
-                                    "description": "Number of lines to show before a match.",
-                                },
-                                "context_after": {
-                                    "type": "integer",
-                                    "default": 5,
-                                    "description": "Number of lines to show after a match.",
-                                },
                             },
                             "required": ["pattern"],
                         },
@@ -117,8 +107,8 @@ class Tool(BaseTool):
             pattern = strip_hashline(search_op.get("pattern"))
             file_pattern = search_op.get("file_pattern", "*")
             directory = search_op.get("directory", search_op.get("path", "."))
-            use_regex = search_op.get("use_regex", False)
-            case_insensitive = search_op.get("case_insensitive", False)
+            use_regex = search_op.get("use_regex", True)
+            case_insensitive = search_op.get("case_insensitive", True)
             context_before = search_op.get("context_before", 5)
             context_after = search_op.get("context_after", 5)