cecli-dev 1.0.0rc4__tar.gz → 1.0.0rc5__tar.gz

{cecli_dev-1.0.0rc4 → cecli_dev-1.0.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.0rc4
+Version: 1.0.0rc5
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -59,6 +59,7 @@ Requires-Dist: rapidfuzz>=3.0
 Requires-Dist: ngram>=4.0.3
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
+Requires-Dist: orjson>=3.11.6
 Requires-Dist: importlib-metadata>=7.2.1
 Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tree-sitter==0.23.2; python_version < "3.10"

{cecli_dev-1.0.0rc4 → cecli_dev-1.0.0rc5}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0rc4'
-__version_tuple__ = version_tuple = (1, 0, 0, 'rc4')
+__version__ = version = '1.0.0rc5'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc5')
 
-__commit_id__ = commit_id = 'g8087eba31'
+__commit_id__ = commit_id = 'g5575d3301'

{cecli_dev-1.0.0rc4 → cecli_dev-1.0.0rc5}/cecli/coders/agent_coder.py

@@ -62,7 +62,6 @@ class AgentCoder(Coder):
         self.max_tool_vector_history = 20
         self.read_tools = {
             "command",
-            "commandinteractive",
             "explorecode",
             "ls",
             "readfile",
@@ -72,7 +71,6 @@ class AgentCoder(Coder):
         }
         self.write_tools = {
             "command",
-            "commandinteractive",
             "editfile",
             "undochange",
         }
@@ -83,6 +81,7 @@ class AgentCoder(Coder):
         self.change_tracker = ChangeTracker()
         self.args = kwargs.get("args")
         self.files_added_in_exploration = set()
+        self.file_read_cache = set()
         self.tool_call_count = 0
         self.turn_count = 0
         self.max_reflections = 15

{cecli_dev-1.0.0rc4 → cecli_dev-1.0.0rc5}/cecli/helpers/agents/service.py

@@ -575,7 +575,7 @@ class AgentService:
 
         Args:
 
-        .. note::
+        .. note:
 
             **Ordering dependency with mark_sub_agent_finished()**
 

{cecli_dev-1.0.0rc4 → cecli_dev-1.0.0rc5}/cecli/helpers/hashline.py

@@ -3,7 +3,11 @@ import json
 import re
 from collections import Counter
 
-from cecli.helpers.hashpos.hashpos import HashPos
+from cecli.helpers.hashpos.hashpos import (  # noqa
+    HASH_DELIMITER,
+    UNIQUE_HASH_DELIMITER,
+    HashPos,
+)
 
 HASHLINE_PREFIX_RE = HashPos.HASH_PREFIX_RE
 
@@ -72,14 +76,14 @@ def strip_hashline(text: str) -> str:
     return HashPos.strip_prefix(text)
 
 
-def normalize_hashline(hashline_str: str) -> str:
+def normalize_hashline(hashline_str: str, throw=True) -> str:
     """
     Normalize a hashline string to the content id hash fragment.
     """
     if hashline_str in ("@000", "000@"):
         return hashline_str
     try:
-        return HashPos.normalize(hashpos_str=hashline_str)
+        return HashPos.normalize(hashpos_str=hashline_str, throw=throw)
     except ValueError as e:
         raise ContentHashError(str(e))
 
@@ -275,6 +279,7 @@ def resolve_content_to_hashline_ids(
     original_content: str,
     start_value: str,
     end_value: str = None,
+    start_hint_line: int | None = None,
 ) -> tuple:
     """
     Resolve potential line content values to proper hashline content IDs.
@@ -295,6 +300,8 @@ def resolve_content_to_hashline_ids(
         original_content: Original file content (without hash prefixes)
         start_value: The start_line value from the edit
         end_value: The end_line value from the edit (optional)
+        start_hint_line: 0-based line number hint used to disambiguate
+                        non-unique start_value matches (optional)
 
     Returns:
         tuple: (resolved_start, resolved_end) with hash IDs or original values
@@ -331,8 +338,11 @@ def resolve_content_to_hashline_ids(
 
     def _resolve_to_hash_id(lines, idx, hp):
         """Generate a hash ID for the line at the given index."""
-        hash_id = hp.generate_public_id(lines[idx], idx)
-        return hash_id + "::"
+        line_text = lines[idx]
+        # Compute the occurrence number (1-based) of this line instance
+        occurrence = 1 + sum(1 for i in range(idx) if lines[i] == line_text)
+        hash_id = hp.generate_public_id(line_text, idx, occurrence)
+        return HashPos.get_wrapped_id(hash_id)
 
     lines = original_content.splitlines()
     hp = HashPos(original_content)
@@ -354,6 +364,13 @@ def resolve_content_to_hashline_ids(
             if len(containing_indices) == 1:
                 resolved_start_idx = containing_indices[0]
                 resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
+            elif len(containing_indices) > 1 and start_hint_line is not None:
+                # Multiple matches - pick closest to hint line
+                resolved_start_idx = min(
+                    containing_indices,
+                    key=lambda idx: abs(idx - start_hint_line),
+                )
+                resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
     elif start_value is not None and _looks_like_content_id(start_value):
         # Already a content ID - try to resolve it to find the line position
         # for proximity matching with end_value
@@ -363,7 +380,22 @@ def resolve_content_to_hashline_ids(
             if candidates:
                 resolved_start_idx = candidates[0]
         except (ContentHashError, ValueError):
-            pass
+            # The value looks like a content ID but normalized to UNIQUE_HASH_DELIMITER which can't
+            # be spatially resolved. Fall back: strip the UNIQUE_HASH_DELIMITER prefix and treat the
+            # remaining content as line content to match.
+            content = HashPos.strip_prefix(start_value)
+            if content != start_value and content.strip():
+                containing_indices = _find_substring_matches(lines, content)
+                if len(containing_indices) == 1:
+                    resolved_start_idx = containing_indices[0]
+                    resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
+                elif len(containing_indices) > 1 and start_hint_line is not None:
+                    # Multiple matches - pick closest to hint line
+                    resolved_start_idx = min(
+                        containing_indices,
+                        key=lambda idx: abs(idx - start_hint_line),
+                    )
+                    resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
 
     # Resolve end_value based on proximity to start position
     resolved_end = end_value
@@ -389,6 +421,30 @@ def resolve_content_to_hashline_ids(
                     key=lambda idx: abs(idx - resolved_start_idx),
                 )
                 resolved_end = _resolve_to_hash_id(lines, closest_idx, hp)
+    elif end_value is not None and _looks_like_content_id(end_value):
+        # Already a content ID - try to resolve it
+        try:
+            normalized = normalize_hashline(end_value)
+            candidates = hp.resolve_to_lines(normalized)
+            if candidates and resolved_start_idx is not None:
+                # Pick candidate closest to start position
+                resolved_end = _resolve_to_hash_id(lines, candidates[0], hp)
+        except (ContentHashError, ValueError):
+            # The value looks like a content ID but normalized to UNIQUE_HASH_DELIMITER which can't
+            # be spatially resolved. Fall back: strip the UNIQUE_HASH_DELIMITER prefix and treat the
+            # remaining content as line content to match.
+            content = HashPos.strip_prefix(end_value)
+            if content != end_value and content.strip():
+                containing_indices = _find_substring_matches(lines, content)
+                if len(containing_indices) == 1:
+                    idx = containing_indices[0]
+                    resolved_end = _resolve_to_hash_id(lines, idx, hp)
+                elif len(containing_indices) > 1 and resolved_start_idx is not None:
+                    closest_idx = min(
+                        containing_indices,
+                        key=lambda idx: abs(idx - resolved_start_idx),
+                    )
+                    resolved_end = _resolve_to_hash_id(lines, closest_idx, hp)
 
     return resolved_start, resolved_end
 
@@ -1705,6 +1761,152 @@ def _apply_closure_safeguard(
     return safe_resolved_ops, rejected_ops
 
 
+def _try_resolve_as_unique_line(
+    hp: HashPos,
+    value: str,
+) -> str | None:
+    """
+    Try to resolve a value by matching it against unique lines in the source content.
+
+    If the value (after stripping) matches exactly one line in the source
+    AND that line appears only once (unique), returns a tilde-wrapped hash ID
+    that can be resolved to line indices by the HashPos engine.
+
+    This serves as a preliminary resolution step that can salvage operations
+    whose hash references could not be normalized, by checking if the value
+    corresponds to unique line content in the file.
+
+    Args:
+        hp: HashPos instance for the source content
+        value: The value to resolve (typically line content rather than a hash)
+
+    Returns:
+        A tilde-wrapped hash ID if resolution succeeds, None otherwise
+    """
+    if not hp or not value:
+        return None
+
+    value_stripped = value.strip()
+    if not value_stripped:
+        return None
+
+    # Find all lines that exactly match this value
+    matching_lines = []
+    for i, line in enumerate(hp.lines):
+        if line.strip() == value_stripped:
+            matching_lines.append((i, line))
+
+    # Only resolve if it matches exactly one unique line
+    if len(matching_lines) == 1:
+        idx, matched_line = matching_lines[0]
+        # Verify the line is actually unique in the source (appears only once)
+        if hp.line_counts.get(matched_line, 0) == 1:
+            hash_id = hp.generate_public_id(matched_line, idx, 1)
+            return HashPos.get_wrapped_id(hash_id)
+
+    return None
+
+
+def _raise_clear_hash_error(hp, op, key):
+    """Raise a ContentHashError with a clear message explaining why a value couldn't be resolved.
+
+    Checks if the value matches line content in the file and provides specific guidance
+    about how to fix the reference (use hashed ID prefix, check for duplicates, etc.).
+    """
+    value = op.get(key, "")
+    value_stripped = value.strip() if value else ""
+
+    if not hp or not value_stripped:
+        raise ContentHashError(
+            f"Could not resolve '{value}' as a content ID. "
+            "Use a hashed ID prefix (e.g., `~XXXX~`) to target the line."
+        )
+
+    # Count how many lines contain this value as a substring
+    matching_count = 0
+    for line in hp.lines:
+        if value_stripped in line:
+            matching_count += 1
+
+    if matching_count > 1:
+        raise ContentHashError(
+            f"Line '{value_stripped}' appears {matching_count} times in the file. "
+            "Use the hashed ID prefix (e.g., `~XXXX~`) to disambiguate "
+            "which occurrence to target."
+        )
+    elif matching_count == 1:
+        raise ContentHashError(
+            f"Line '{value_stripped}' was found once in the file but could not be "
+            "resolved as a unique content ID. Use the hashed ID prefix (e.g., `~XXXX~`) "
+            "to target it precisely."
+        )
+    else:
+        raise ContentHashError(
+            f"Line '{value_stripped}' was not found in the file. "
+            "Use the exact line content or a hashed ID prefix (e.g., `~XXXX~`) "
+            "to target the desired line."
+        )
+
+
+def _detect_overlapping_ranges(resolved_ops):
+    """Check resolved operations for genuinely overlapping ranges.
+
+    Detects operations where ranges overlap in a way that can't be resolved
+    by simple deduplication (same-start) or containment. These non-trivial
+    overlaps (e.g., a delete range partially overlapping a replace range)
+    are flagged and returned as failed operations with a clear message.
+    The overlapping operations' indices are also returned so the caller
+    can exclude them from `resolved_ops`.
+
+    Returns a tuple of (failed_ops, indices_to_remove).
+    - failed_ops: list of failed operation dicts with overlap errors
+    - indices_to_remove: set of operation indices to remove from resolved_ops
+    """
+    if len(resolved_ops) < 2:
+        return [], set()
+
+    failed_ops = []
+    indices_to_remove = set()
+    for i in range(len(resolved_ops)):
+        a = resolved_ops[i]
+        a_start = a["start_idx"]
+        a_end = a["end_idx"]
+
+        for j in range(i + 1, len(resolved_ops)):
+            b = resolved_ops[j]
+            b_start = b["start_idx"]
+            b_end = b["end_idx"]
+
+            # Skip trivial cases handled elsewhere:
+            # 1. Same start line - handled by _deduplicate_ranges
+            if a_start == b_start:
+                continue
+
+            # 2. One range fully contained within the other - handled by _merged_contained_ranges
+            if (a_start <= b_start and b_end <= a_end) or (b_start <= a_start and a_end <= b_end):
+                continue
+
+            # Check if ranges genuinely overlap (not just adjacent/contiguous)
+            # Two ranges [a_start, a_end] and [b_start, b_end] overlap if
+            # a_start <= b_end and b_start <= a_end
+            if a_start <= b_end and b_start <= a_end:
+                op_a = a["op"]
+                op_b = b["op"]
+                error_msg = (
+                    f"Operation {a['index'] + 1} ({op_a['operation']}, lines "
+                    f"{a_start}-{a_end}) overlaps with operation {b['index'] + 1} "
+                    f"({op_b['operation']}, lines {b_start}-{b_end}). "
+                    "Edits with overlapping ranges are not supported. "
+                    "Combine them into a single edit or use non-overlapping ranges."
+                )
+                failed_ops.append({"index": a["index"], "error": error_msg, "operation": op_a})
+                failed_ops.append({"index": b["index"], "error": error_msg, "operation": op_b})
+                indices_to_remove.add(i)
+                indices_to_remove.add(j)
+
+    return failed_ops, indices_to_remove
+
+
 def apply_hashline_operations(
     original_content: str,
     operations: list,
@@ -1730,15 +1932,35 @@ def apply_hashline_operations(
     # Normalize hashline inputs in operations
     normalized_operations = []
     failed_ops = []
+    # Create a single HashPos instance for preliminary resolution and content hashing
+    hp = HashPos(original_content) if original_content else HashPos("")
     # Loop through each operation to normalize hashline strings
     for i, op in enumerate(operations):
         try:
             normalized_op = op.copy()
             # Normalize start line hash to ensure consistent format
-            normalized_op["start_line_hash"] = normalize_hashline(op["start_line_hash"])
+            try:
+                normalized_op["start_line_hash"] = normalize_hashline(op["start_line_hash"])
+            except (ContentHashError, ValueError):
+                # Preliminary resolution: check if the value matches a unique line
+                resolved = _try_resolve_as_unique_line(hp, op["start_line_hash"])
+                if resolved is not None:
+                    normalized_op["start_line_hash"] = resolved
+                else:
+                    _raise_clear_hash_error(hp, op, "start_line_hash")
+
             if "end_line_hash" in op:
                 # Normalize end line hash if present
-                normalized_op["end_line_hash"] = normalize_hashline(op["end_line_hash"])
+                try:
+                    normalized_op["end_line_hash"] = normalize_hashline(op["end_line_hash"])
+                except (ContentHashError, ValueError):
+                    # Preliminary resolution: check if the value matches a unique line
+                    resolved = _try_resolve_as_unique_line(hp, op["end_line_hash"])
+                    if resolved is not None:
+                        normalized_op["end_line_hash"] = resolved
+                    else:
+                        _raise_clear_hash_error(hp, op, "end_line_hash")
+
             normalized_operations.append(normalized_op)
         except Exception as e:
             failed_ops.append({"index": i, "error": str(e), "operation": op})
@@ -1755,7 +1977,7 @@ def apply_hashline_operations(
 
     # Apply hashline to original content once
     # This converts content to hashed lines for line tracking
-    hashed_content = hashline(original_content)
+    hashed_content = hp.format_content()
     hashed_lines = hashed_content.splitlines(keepends=True)
 
     # Resolve all operations to indices first
@@ -1833,6 +2055,14 @@ def apply_hashline_operations(
         except Exception as e:
             failed_ops.append({"index": i, "error": str(e), "operation": op})
 
+    # Check for overlapping ranges among resolved operations
+    overlap_failures, overlap_indices = _detect_overlapping_ranges(resolved_ops)
+    for overlap_failure in overlap_failures:
+        failed_ops.append(overlap_failure)
+    # Remove overlapping operations from resolved_ops so they don't get applied
+    if overlap_indices:
+        resolved_ops = [op for i, op in enumerate(resolved_ops) if i not in overlap_indices]
+
     # Honor cancellations: remove operations that are cancelled by later cancel operations
     resolved_ops = _honor_cancellations(resolved_ops)
     # Deduplicate: if multiple operations start on the same line, keep only the latest one