cecli-dev 0.100.6rc8__tar.gz → 0.100.7rc2__tar.gz

{cecli_dev-0.100.6rc8 → cecli_dev-0.100.7rc2}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.6rc8'
-__version_tuple__ = version_tuple = (0, 100, 6, 'rc8')
+__version__ = version = '0.100.7rc2'
+__version_tuple__ = version_tuple = (0, 100, 7, 'rc2')
 
-__commit_id__ = commit_id = 'g2da275a7a'
+__commit_id__ = commit_id = 'g845b666e7'

{cecli_dev-0.100.6rc8 → cecli_dev-0.100.7rc2}/cecli/coders/agent_coder.py

@@ -153,6 +153,7 @@ class AgentCoder(Coder):
             config, "skip_cli_confirmations", nested.getter(config, "yolo", [])
         )
         config["command_timeout"] = nested.getter(config, "command_timeout", 30)
+        config["allowed_commands"] = nested.getter(config, "allowed_commands", [])
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
         config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
 
@@ -1433,9 +1434,11 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
             content = self.io.read_text(abs_path)
             if content is None or not content.strip():
                 return None
+
+            current_tasks = "\n".join(self.current_tasks)
             result = '<context name="todo_list" from="agent">\n'
             result += "## Current Active Tasks\n\n"
-            result += f"```{"\n".join(self.current_tasks)}```\n"
+            result += f"```{current_tasks}```\n"
             result += "</context>"
             return result
         except Exception as e:

{cecli_dev-0.100.6rc8 → cecli_dev-0.100.7rc2}/cecli/coders/base_coder.py

@@ -427,6 +427,7 @@ class Coder(metaclass=UsageMeta):
         self.registered_servers = {"included": set(), "excluded": set()}
         self.interrupt_event = ThreadSafeEvent()
         self.uuid = str(generate_unique_id())
+        self.reflected_message = None
 
         if uuid:
             self.uuid = str(uuid)
@@ -2560,7 +2561,9 @@ class Coder(metaclass=UsageMeta):
                     return
         finally:
             if self.mdstream:
-                content_to_show = self.live_incremental_response(True)
+                content_to_show = (
+                    "" if self.tui and self.tui() else self.live_incremental_response(True)
+                )
                 self.stream_wrapper(content_to_show, final=True)
             self.mdstream = None
 
@@ -3583,24 +3586,13 @@ class Coder(metaclass=UsageMeta):
                         except AttributeError:
                             reasoning_content = None
 
-                    if reasoning_content:
-                        if nested.getter(self.args, "show_thinking"):
-                            if not self.got_reasoning_content:
-                                text += f"<{REASONING_TAG}>\n\n"
-                            text += reasoning_content
-                            self.got_reasoning_content = True
-                            received_content = True
-                        self.token_profiler.on_token()
-                        self.io.update_spinner_suffix(reasoning_content)
-                        self.partial_response_reasoning_content += reasoning_content
-
                     try:
                         content = chunk.choices[0].delta.content
                         if content:
                             if self.got_reasoning_content and not self.ended_reasoning_content:
                                 text += f"\n\n</{self.reasoning_tag_name}>\n\n"
-                                self.ended_reasoning_content = True
 
+                            self.ended_reasoning_content = True
                             text += content
                             received_content = True
                             self.token_profiler.on_token()
@@ -3608,6 +3600,22 @@ class Coder(metaclass=UsageMeta):
                     except AttributeError:
                         pass
 
+                    if reasoning_content:
+                        if (
+                            nested.getter(self.args, "show_thinking")
+                            and not self.ended_reasoning_content
+                        ):
+                            if not self.got_reasoning_content:
+                                text += f"<{REASONING_TAG}>\n\n"
+
+                            text += reasoning_content
+                            self.got_reasoning_content = True
+                            received_content = True
+
+                        self.token_profiler.on_token()
+                        self.io.update_spinner_suffix(reasoning_content)
+                        self.partial_response_reasoning_content += reasoning_content
+
                 self.partial_response_content += text
 
                 chunk_index += 1
@@ -3634,6 +3642,16 @@ class Coder(metaclass=UsageMeta):
         except (asyncio.CancelledError, KeyboardInterrupt):
             raise KeyboardInterrupt
 
+        if (
+            self.show_pretty()
+            and nested.getter(self.args, "show_thinking")
+            and self.got_reasoning_content
+            and not self.ended_reasoning_content
+        ):
+            self.partial_response_content += f"\n\n</{self.reasoning_tag_name}>\n\n"
+            content_to_show = self.live_incremental_response(False)
+            self.stream_wrapper(content_to_show, final=False)
+
         # The Part Doing the Heavy Lifting Now
         self.consolidate_chunks()
 
@@ -3657,6 +3675,11 @@ class Coder(metaclass=UsageMeta):
         func_err = None
         content_err = None
 
+        last_chunk = self.partial_response_chunks[len(self.partial_response_chunks) - 1]
+        if last_chunk:
+            if getattr(last_chunk, "usage", None):
+                response.usage = last_chunk.usage
+
         # Collect provider-specific fields from chunks to preserve them
         # We need to track both by ID (primary) and index (fallback) since
         # early chunks might not have IDs established yet
@@ -3848,6 +3871,7 @@ class Coder(metaclass=UsageMeta):
             cache_hit_tokens = (
                 getattr(completion.usage, "prompt_cache_hit_tokens", 0)
                 or getattr(completion.usage, "cache_read_input_tokens", 0)
+                or nested.getter(completion.usage, "prompt_tokens_details.cached_tokens", 0)
                 or 0
             )
             cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0

{cecli_dev-0.100.6rc8 → cecli_dev-0.100.7rc2}/cecli/commands/utils/base_command.py

@@ -159,6 +159,12 @@ class BaseCommand(ABC, metaclass=CommandMeta):
         await new_coder.generate(user_message=user_msg, preproc=False)
         coder.coder_commit_hashes = new_coder.coder_commit_hashes
 
+        # Transfer files added during the /agent (or other temp-coder) turn back to the original
+        if new_coder.abs_fnames - original_coder.abs_fnames:
+            original_coder.abs_fnames.update(new_coder.abs_fnames)
+        if new_coder.abs_read_only_fnames - original_coder.abs_read_only_fnames:
+            original_coder.abs_read_only_fnames.update(new_coder.abs_read_only_fnames)
+
         # Clear manager and restore original state
         ConversationService.get_manager(original_coder).initialize(
             reset=True,

{cecli_dev-0.100.6rc8 → cecli_dev-0.100.7rc2}/cecli/helpers/hashline.py

@@ -1,6 +1,8 @@
 import difflib
 import re
 
+from cecli.helpers.grep_ast.parsers import filename_to_lang
+from cecli.helpers.grep_ast.tsl import get_language, get_parser
 from cecli.helpers.hashpos.hashpos import HashPos
 
 HASHLINE_PREFIX_RE = HashPos.HASH_PREFIX_RE
@@ -245,8 +247,13 @@ def resolve_content_to_hashline_ids(
     Resolve potential line content values to proper hashline content IDs.
 
     If start_value or end_value does not look like a content ID (hash),
-    search for the content in the original file. If found exactly once,
-    return the hash ID for that line instead.
+    search for the content in the original file using substring matching.
+
+    For start_value: Only resolves if exactly one line contains it as a
+    substring (unique match).
+
+    For end_value: Resolves by finding the closest line (by position) to
+    the resolved start line that contains it as a substring.
 
     This handles the case where LLMs return entire line content or fragments
     instead of content IDs in edit parameters.
@@ -274,42 +281,55 @@ def resolve_content_to_hashline_ids(
         except (ContentHashError, ValueError):
             return False
 
-    def _resolve_value(value: str) -> str:
-        if value is None:
-            return value
-        if _looks_like_content_id(value):
-            return value
-
-        # Value doesn't look like a content ID - try to find it as line content
-        lines = original_content.splitlines()
+    def _find_substring_matches(lines, value):
+        """Find all line indices where the value appears as a substring."""
         value_stripped = value.rstrip("\r\n")
+        return [i for i, line in enumerate(lines) if value_stripped in line]
 
-        # First try exact match (full line content)
-        matching_indices = [
-            i for i, line in enumerate(lines) if line.rstrip("\r\n") == value_stripped
-        ]
+    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 + "::"
 
-        if len(matching_indices) == 1:
-            idx = matching_indices[0]
-            hp = HashPos(original_content)
-            hash_id = hp.generate_public_id(lines[idx], idx)
-            return hash_id + "::"
+    lines = original_content.splitlines()
+    hp = HashPos(original_content)
 
-        # If no exact match, try substring match (value might be a fragment)
-        # Only resolve if exactly one line contains the value
-        containing_indices = [i for i, line in enumerate(lines) if value_stripped in line]
+    # Resolve start_value first (must be unique substring match)
+    resolved_start = start_value
+    resolved_start_idx = None
 
+    if start_value is not None and not _looks_like_content_id(start_value):
+        containing_indices = _find_substring_matches(lines, start_value)
         if len(containing_indices) == 1:
-            idx = containing_indices[0]
-            hp = HashPos(original_content)
-            hash_id = hp.generate_public_id(lines[idx], idx)
-            return hash_id + "::"
+            resolved_start_idx = containing_indices[0]
+            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
+        try:
+            normalized = normalize_hashline(start_value)
+            candidates = hp.resolve_to_lines(normalized)
+            if candidates:
+                resolved_start_idx = candidates[0]
+        except (ContentHashError, ValueError):
+            pass
 
-        # Can't resolve uniquely - return original value
-        return value
+    # Resolve end_value based on proximity to start position
+    resolved_end = end_value
 
-    resolved_start = _resolve_value(start_value)
-    resolved_end = _resolve_value(end_value) if end_value is not None else end_value
+    if end_value is not None and not _looks_like_content_id(end_value):
+        containing_indices = _find_substring_matches(lines, end_value)
+        if len(containing_indices) == 1:
+            # Unique match - resolve directly
+            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:
+            # Multiple matches - pick closest to start position
+            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
 
@@ -1269,9 +1289,302 @@ def sort_ranges(op):
     return (-start_idx, priority)
 
 
+def _would_create_duplicate_content(source_lines, candidate_start, candidate_end, repl_lines):
+    """
+    Check if applying the edit would create duplicate adjacent content at boundaries.
+    """
+    if not repl_lines:
+        return False
+
+    # Check start boundary: first replacement line matches line before edit range
+    if candidate_start > 0:
+        line_before = source_lines[candidate_start - 1].strip()
+        first_repl = repl_lines[0].strip()
+        # Ensure the line actually contains text to prevent eating blank lines
+        if line_before and line_before == first_repl:
+            return True
+
+    # Check end boundary: last replacement line matches line after edit range
+    if candidate_end < len(source_lines) - 1:
+        line_after = source_lines[candidate_end + 1].strip()
+        last_repl = repl_lines[-1].strip()
+        if line_after and line_after == last_repl:
+            return True
+
+    return False
+
+
+def _fix_duplicate_content_boundaries(source_lines, resolved_ops):
+    """
+    Expand edit boundaries when replacement content duplicates adjacent lines.
+    """
+    for resolved in resolved_ops:
+        op = resolved["op"]
+        if op["operation"] not in {"replace", "insert", "delete"}:
+            continue
+        repl_text = op.get("text", "") or ""
+        repl_lines = repl_text.splitlines()
+        if not repl_lines:
+            continue
+
+        start_idx = resolved["start_idx"]
+        end_idx = resolved["end_idx"]
+
+        # Expand start backward if first replacement line duplicates line before
+        while start_idx > 0:
+            line_before = source_lines[start_idx - 1].strip()
+            first_repl = repl_lines[0].strip()
+            if line_before and line_before == first_repl:
+                start_idx -= 1
+            else:
+                break
+
+        # Expand end forward if last replacement line duplicates line after
+        while end_idx < len(source_lines) - 1:
+            line_after = source_lines[end_idx + 1].strip()
+            last_repl = repl_lines[-1].strip()
+            if line_after and line_after == last_repl:
+                end_idx += 1
+            else:
+                break
+
+        resolved["start_idx"] = start_idx
+        resolved["end_idx"] = end_idx
+
+    return resolved_ops
+
+
+def _apply_closure_safeguard(
+    original_content: str,
+    resolved_ops: list,
+    file_path: str = None,
+) -> 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
+
+    Returns:
+        Modified resolved_ops with healed boundaries
+    """
+
+    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
+
+    # Determine language from file path
+    lang = filename_to_lang(file_path)
+    if not lang:
+        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
+
+    source_lines = original_content.splitlines()
+    MAX_STEPS = 3  # Maximum expansion steps
+
+    for resolved in resolved_ops:
+        op = resolved["op"]
+        if op["operation"] not in {"replace", "insert", "delete"}:
+            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):
+            continue
+        if llm_end < llm_start:
+            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 ---
+        # Try original bounds first (distance 0), then progressively expand
+        # outward in rounds. At each round d>=1, test exactly 4 candidates:
+        #   1. Both indices down by d lines (range shifts down)
+        #   2. Both indices up by d lines (range shifts up)
+        #   3. Start index down by d lines, end unchanged (partial expansion)
+        #   4. End index down by d lines, start unchanged (partial expansion)
+        #
+        # If multiple candidates are valid at a round, select using:
+        #   1. Longest resulting source code (preserve more code)
+        #   2. Partial expansions over full range shifts
+        #   3. Downward changes over upward changes
+
+        found_valid = False
+        EFFECTIVE_STEPS = MAX_STEPS
+
+        if llm_start == llm_end:
+            EFFECTIVE_STEPS = 1
+
+        for distance in range(EFFECTIVE_STEPS + 1):
+            if distance == 0:
+                round_candidates = [(0, 0)]
+            else:
+                round_candidates = [
+                    (-distance, 0),  # Start down only (partial)
+                    (+distance, 0),  # Start up only (partial)
+                    (0, +distance),  # End down only (partial)
+                    (0, -distance),  # End up only (partial)
+                    (-distance, +distance),  # Both indices down
+                    (+distance, -distance),  # Both indices up
+                    (+distance, +distance),  # Expand outward (start up, end down)
+                    (-distance, -distance),  # Contract inward (start down, end up)
+                ]
+
+            valid_at_round = []
+            for start_shift, end_shift in round_candidates:
+                candidate_start = max(0, llm_start - start_shift)
+                candidate_end = min(len(source_lines) - 1, llm_end + end_shift)
+
+                if candidate_end < candidate_start:
+                    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(
+                    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)
+
+                    # --- 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
+
+                    valid_at_round.append(
+                        {
+                            "start_idx": candidate_start,
+                            "end_idx": candidate_end,
+                            "source_len": len(test_source),
+                            "is_partial": is_partial,
+                            "is_downward": is_downward,
+                            "is_both": is_both,
+                            "closure_count": closures,
+                            "indent_score": indent_score,
+                        }
+                    )
+
+            if valid_at_round:
+                # Sort using the new hierarchy:
+                # 1. Fewest total closures (minimize structural pollution)
+                # 2. Indentation Score (Descending: 2 is better than 0)
+                # 3. Longest source (preserve more file content)
+                # 4. Partial expansions over full range shifts
+                # 5. Downward changes over upward changes
+                valid_at_round.sort(
+                    key=lambda r: (
+                        -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
+                    )
+                )
+
+                best = valid_at_round[0]
+                resolved["start_idx"] = best["start_idx"]
+                resolved["end_idx"] = best["end_idx"]
+                found_valid = True
+                break
+
+        if not found_valid:
+            pass
+
+    return resolved_ops
+
+
 def apply_hashline_operations(
     original_content: str,
     operations: list,
+    file_path: str = None,
 ) -> tuple[str, list, list]:
     """
     Apply multiple hashline operations sequentially.
@@ -1308,6 +1621,13 @@ def apply_hashline_operations(
 
     if not normalized_operations:
         return original_content, [], failed_ops
+    # Convert insert operations without @000 marker to inclusive replace operations
+    for op in normalized_operations:
+        if op["operation"] == "insert":
+            start_hash_fragment, _, _ = parse_hashline(op["start_line_hash"])
+            if start_hash_fragment != "@000" and start_hash_fragment != "000@":
+                op["operation"] = "replace"
+                op["end_line_hash"] = op["start_line_hash"]
 
     # Apply hashline to original content once
     # This converts content to hashed lines for line tracking
@@ -1334,12 +1654,6 @@ def apply_hashline_operations(
                         hashed_lines, start_hash_fragment, start_line_num_str
                     )
 
-                    # if found_start is None:
-                    #    # Fall back to fragment matching if exact match fails
-                    #    found_start = find_hashline_by_fragment(
-                    #        hashed_lines, start_hash_fragment, start_line_num
-                    #    )
-
                     if found_start is None:
                         raise ContentHashError(
                             f"Start line hash fragment '{start_hash_fragment}' not found in file"
@@ -1407,8 +1721,14 @@ def apply_hashline_operations(
     resolved_ops = _merged_contained_ranges(resolved_ops)
     # Merge contiguous replace 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)
+    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)
+
+        # Fix edit boundaries where replacement content duplicates adjacent lines
+        source_lines = original_content.splitlines()
+        resolved_ops = _fix_duplicate_content_boundaries(source_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
@@ -1470,8 +1790,22 @@ def apply_hashline_operations(
                     # end_idx, replacement_lines = _apply_end_stitching(
                     #    hashed_lines, start_idx, end_idx, replacement_lines, max_overlap_check
                     # )
+                    # Preserve empty lines after the edit range
+                    # If there is an empty line immediately after the edit boundary,
+                    # track it so it can be restored if consumed by the replacement
+                    next_idx = end_idx + 1
+                    preserve_trailing_empty = (
+                        next_idx < len(hashed_lines) and hashed_lines[next_idx].strip() == ""
+                    )
 
                     hashed_lines[start_idx : end_idx + 1] = replacement_lines
+
+                    # Ensure the trailing empty line is preserved after replacement
+                    if preserve_trailing_empty:
+                        check_idx = start_idx + len(replacement_lines)
+                        if check_idx >= len(hashed_lines) or hashed_lines[check_idx].strip() != "":
+                            hashed_lines.insert(check_idx, "\n")
+
                 else:
                     # Empty text - replace with nothing (delete)
                     hashed_lines[start_idx : end_idx + 1] = []