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

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

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

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.100.8.dev"
+__version__ = "0.100.11.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/_version.py

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

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/args.py

@@ -1115,6 +1115,16 @@ def get_parser(default_config_files, git_root):
             " specified, a default command for your OS may be used."
         ),
     )
+    group.add_argument(
+        "--notification-bell",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Allow notification commands to produce an audible bell. When enabled, command"
+            " output is not suppressed so terminal bell escape sequences can ring through"
+            " (default: True)"
+        ),
+    )
     group.add_argument(
         "--command-prefix",
         default=None,

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/coders/agent_coder.py

@@ -157,9 +157,11 @@ class AgentCoder(Coder):
         config["large_file_token_threshold"] = nested.getter(
             config, "large_file_token_threshold", 8192
         )
+        config["show_lint_errors"] = nested.getter(config, "show_lint_errors", False)
         config["skip_cli_confirmations"] = nested.getter(
             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)
@@ -816,6 +818,11 @@ class AgentCoder(Coder):
             if interrupted:
                 raise KeyboardInterrupt("Interrupted during linting")
 
+            has_errors = False
+
+            if self.lint_outcome is False:
+                has_errors = True
+
             self.lint_outcome = not lint_errors
 
             if lint_errors:
@@ -824,21 +831,35 @@ class AgentCoder(Coder):
                     "# Fix any linting errors below, if possible and then continue with your task.",
                     1,
                 )
-                ConversationService.get_manager(self).remove_message_by_hash_key(
-                    ("lint_errors", "agent")
-                )
                 ConversationService.get_manager(self).add_message(
                     message_dict=dict(role="user", content=lint_errors),
-                    tag=MessageTag.CUR,
-                    hash_key=("lint_errors", "agent"),
+                    tag=MessageTag.LINT,
+                    hash_key=("lint_errors", "agent", lint_errors),
+                )
+                ConversationService.get_manager(self).add_message(
+                    message_dict=dict(
+                        role="user", content="Please address the latest linting errors."
+                    ),
+                    tag=MessageTag.LINT,
+                    hash_key=("lint_errors", "agent", lint_errors, "cta"),
                     promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
                     mark_for_demotion=1,
-                    force=True,
+                    mark_for_delete=0,
                 )
             else:
-                ConversationService.get_manager(self).remove_message_by_hash_key(
-                    ("lint_errors", "agent")
-                )
+                if has_errors:
+                    ConversationService.get_manager(self).add_message(
+                        message_dict=dict(
+                            role="user",
+                            content=(
+                                '<context name="linting_confirmation" from="agent">'
+                                "All linting errors resolved."
+                                "</context>"
+                            ),
+                        ),
+                        tag=MessageTag.LINT,
+                        hash_key=("lint_errors", "agent", str(time.monotonic_ns())),
+                    )
 
         return tool_responses
 

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/coders/base_coder.py

@@ -491,6 +491,7 @@ class Coder(metaclass=UsageMeta):
         self.mcp_manager = mcp_manager
         self.enable_context_compaction = enable_context_compaction
 
+        self.context_compaction_current_ratio = 0
         self.context_compaction_max_tokens = context_compaction_max_tokens
         self.context_compaction_summary_tokens = context_compaction_summary_tokens
         self.max_reflections = nested.getter(self.args, "max_reflections", 3)
@@ -1439,7 +1440,10 @@ class Coder(metaclass=UsageMeta):
             if mime_type.startswith("image/") and supports_images:
                 content = [
                     {"type": "text", "text": f"Image file: {rel_fname}"},
-                    {"type": "image_url", "image_url": {"url": image_url, "detail": "high"}},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": image_url, "detail": "high", "format": mime_type},
+                    },
                 ]
             elif mime_type == "application/pdf" and supports_pdfs:
                 content = [
@@ -2000,12 +2004,15 @@ class Coder(metaclass=UsageMeta):
 
         combined_tokens = done_tokens + cur_tokens + diff_tokens
 
+        self.context_compaction_current_ratio = all_tokens / self.context_compaction_max_tokens
+
         if force or (
             all_tokens >= self.context_compaction_max_tokens * 0.9
-            and ConversationService.get_chunks(self).last_clear_count > 10
+            and ConversationService.get_chunks(self).last_clear_count > 20
         ):
-            manager.clear_tag(MessageTag.DIFFS)
-            manager.clear_tag(MessageTag.FILE_CONTEXTS)
+            manager.clear_tag(MessageTag.LINT, ratio=0.33)
+            manager.clear_tag(MessageTag.DIFFS, ratio=0.33)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS, ratio=0.33)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
 
@@ -3248,6 +3255,12 @@ class Coder(metaclass=UsageMeta):
                 res += errors
                 res += "\n"
 
+        if self.edit_format in ("agent", "subagent"):
+            if self.agent_config.get("show_lint_errors"):
+                show_output = True
+            else:
+                show_output = False
+
         if res and show_output:
             self.io.tool_warning(res)
 

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/conversation/files.py

@@ -1,10 +1,14 @@
+import json
 import os
 import weakref
 from typing import Any, Dict, List, Optional, Tuple
 
 import xxhash
 
-from cecli.helpers.hashline import get_hashline_content_diff, hashline
+from cecli.helpers.hashline import (
+    get_hashline_content_diff,
+    hashline_formatted,
+)
 from cecli.repomap import RepoMap
 
 from .service import ConversationService
@@ -25,8 +29,11 @@ class ConversationFiles:
         self.uuid = coder.uuid
         self._file_contents_original: Dict[str, str] = {}
         self._file_contents_snapshot: Dict[str, str] = {}
+        self._file_json_contents: Dict[str, str] = {}
         self._file_timestamps: Dict[str, float] = {}
         self._file_diffs: Dict[str, str] = {}
+        self._file_diff_versions: Dict[str, int] = {}
+        self._file_context_versions: Dict[str, int] = {}
         self._file_stub_contents: Dict[str, str] = {}
         self._file_to_message_id: Dict[str, str] = {}
         self._image_files: Dict[str, bool] = {}
@@ -109,7 +116,10 @@ class ConversationFiles:
                 try:
                     content = coder.io.read_text(abs_fname, silent=True)
                     if coder.hashlines:
-                        content = hashline(content)
+                        content, json_str = hashline_formatted(
+                            content, file_name=abs_fname, partial=False
+                        )
+                        self._file_json_contents[abs_fname] = json_str
                 except Exception:
                     content = ""  # Empty content for unreadable files
 
@@ -226,7 +236,9 @@ class ConversationFiles:
         try:
             current_content = coder.io.read_text(abs_fname, silent=True)
             if coder.hashlines:
-                current_content = hashline(current_content)
+                current_content, _ = hashline_formatted(
+                    current_content, file_name=abs_fname, partial=False
+                )
         except Exception:
             return None
 
@@ -239,6 +251,9 @@ class ConversationFiles:
             abs_fname, self._file_contents_original[abs_fname]
         )
 
+        if not snapshot_content:
+            return None
+
         # Generate diff between snapshot and current content using hashline helper
         diff_text = get_hashline_content_diff(
             old_content=snapshot_content,
@@ -265,10 +280,14 @@ class ConversationFiles:
         """
         coder = self.get_coder()
         diff = self.generate_diff(fname)
+        diff_output = diff
 
         if diff:
-            # Store diff
+            # Increment diff version counter
             abs_fname = os.path.abspath(fname)
+            self._file_diff_versions[abs_fname] = self._file_diff_versions.get(abs_fname, 0) + 1
+
+            # Store diff
             self._file_diffs[abs_fname] = diff
 
             rel_fname = fname
@@ -278,6 +297,16 @@ class ConversationFiles:
                 rel_fname = coder.get_rel_fname(fname)
                 prefix_str = "content ID prefixed " if getattr(coder, "hashlines") else ""
 
+            if coder.hashlines:
+                # Wrap diff in JSON structure
+                diff_output = json.dumps(
+                    {
+                        "file_name": rel_fname,
+                        "prefixed_diff": diff,
+                    },
+                    ensure_ascii=False,
+                )
+
             # Add diff message to conversation
             content_hash = xxhash.xxh3_128_hexdigest(diff.encode("utf-8"))
 
@@ -285,7 +314,7 @@ class ConversationFiles:
                 "role": "user",
                 "content": (
                     f"{rel_fname} has been updated. Review this {prefix_str}diff of the changes to"
-                    f" ensure all modifications are appropriate:\n\n{diff}"
+                    f" ensure all modifications are appropriate:\n\n{diff_output}"
                 ),
             }
 
@@ -328,6 +357,22 @@ class ConversationFiles:
 
         return content or ""
 
+    def get_file_json(self, fname: str) -> Optional[str]:
+        """
+        Get the cached JSON metadata for a file, if available.
+
+        The JSON is generated and cached during add_file() and contains
+        file_name, start_line, end_line, partial, and prefixed_contents.
+
+        Args:
+            fname: Absolute file path
+
+        Returns:
+            JSON-formatted string, or None if not cached
+        """
+        abs_fname = os.path.abspath(fname)
+        return self._file_json_contents.get(abs_fname)
+
     def clear_file_cache(self, fname: Optional[str] = None, clear_contexts=True) -> None:
         """
         Clear cache for specific file or all files.
@@ -340,7 +385,10 @@ class ConversationFiles:
             self._file_contents_snapshot.clear()
             self._file_timestamps.clear()
             self._file_diffs.clear()
+            self._file_diff_versions.clear()
+            self._file_context_versions.clear()
             self._file_stub_contents.clear()
+            self._file_json_contents.clear()
             self._file_to_message_id.clear()
             if clear_contexts:
                 self._numbered_contexts.clear()
@@ -350,7 +398,10 @@ class ConversationFiles:
             self._file_contents_snapshot.pop(abs_fname, None)
             self._file_timestamps.pop(abs_fname, None)
             self._file_diffs.pop(abs_fname, None)
+            self._file_diff_versions.pop(abs_fname, None)
+            self._file_context_versions.pop(abs_fname, None)
             self._file_stub_contents.pop(abs_fname, None)
+            self._file_json_contents.pop(abs_fname, None)
             self._file_to_message_id.pop(abs_fname, None)
             self._image_files.pop(abs_fname, None)
             if clear_contexts:
@@ -402,6 +453,8 @@ class ConversationFiles:
             The merged range (start_line, end_line) that contains the input range.
         """
         abs_fname = os.path.abspath(file_path)
+        diff_version = self._file_diff_versions.get(abs_fname, 0)
+        context_version = self._file_context_versions.get(abs_fname, 0)
 
         # Validate range
         if start_line > end_line:
@@ -410,6 +463,11 @@ class ConversationFiles:
         # Get existing ranges
         existing_ranges = self._numbered_contexts.get(abs_fname, [])
 
+        if diff_version != context_version:
+            self._file_context_versions[abs_fname] = diff_version
+        # auto clear on edit
+        # existing_ranges = []
+
         # Add new range
         new_range = (start_line, end_line)
         all_ranges = existing_ranges + [new_range]
@@ -481,7 +539,7 @@ class ConversationFiles:
             abs_fname = os.path.abspath(file_path)
             self._last_merged_ranges.pop(abs_fname, None)
 
-    def get_file_context(self, file_path: str, all_ranges=False) -> str:
+    def get_file_context(self, file_path: str, all_ranges=False, check_versions=True) -> str:
         """
         Generate hashline representation of cached context ranges.
 
@@ -489,7 +547,8 @@ class ConversationFiles:
             file_path: Absolute file path
 
         Returns:
-            Hashline representation of cached ranges, or empty string if no ranges
+            JSON-formatted string with file_path, version, and results array,
+            or empty string if no ranges
         """
         abs_fname = os.path.abspath(file_path)
 
@@ -518,8 +577,10 @@ class ConversationFiles:
             return ""
 
         # Generate hashline representations for each range
-        context_parts = []
+        results = []
         content_lines = content.splitlines()
+        diff_version = self._file_diff_versions.get(abs_fname, 0)
+        context_version = self._file_context_versions.get(abs_fname, 0)
 
         for i, (start_line, end_line) in enumerate(ranges):
             # Note: hashline uses 1-based line numbers, so no conversion needed
@@ -532,15 +593,34 @@ class ConversationFiles:
             # Extract lines for this range (0-based indexing for list)
             lines = content_lines[start_line_adj - 1 : end_line_adj]
 
-            # Generate hashline representation using the hashline() function
-            # Join lines back with newlines for hashline()
+            # Generate JSON for this range using hashline_formatted()
             range_content = "\n".join(lines)
-            hashline_content = hashline(range_content, start_line=start_line_adj)
 
-            context_parts.append(hashline_content.strip())
+            # Don't duplicate whole contents that are already in context
+            if (
+                check_versions
+                and range_content == content
+                and (abs_fname in coder.abs_fnames or abs_fname in coder.abs_read_only_fnames)
+                and diff_version == context_version
+            ):
+                continue
+
+            _, json_str = hashline_formatted(
+                range_content, file_name=abs_fname, partial=True, start_line=start_line_adj
+            )
+            results.append(json.loads(json_str))
+
+        # Build and return the top-level JSON structure
+        # version = self._file_diff_versions.get(abs_fname, 0)
+        if results:
+            result = {
+                "file_path": file_path,
+                "results": results,
+                # "version": version,
+            }
+            return json.dumps(result, ensure_ascii=False)
 
-        # Join with ellipsis separator
-        return "\n...\n\n".join(context_parts)
+        return None
 
     def remove_file_context(self, file_path: str) -> None:
         """

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/conversation/integration.py

@@ -168,8 +168,8 @@ class ConversationChunks:
         if not coder:
             return
 
-        # if self._cancel_post_message_injections():
-        #     return
+        if self._cancel_post_message_injections():
+            return
 
         message = random.choice(
             [
@@ -192,7 +192,7 @@ class ConversationChunks:
                     " the current data."
                 ),
                 (
-                    "You’ve got what you need, please invoke the right tools to keep making"
+                    "Based on what you know, please invoke the right tools to keep making"
                     " progress towards our goal."
                 ),
                 (
@@ -286,13 +286,14 @@ class ConversationChunks:
 
         if (
             should_clear
+            and coder.context_compaction_current_ratio > 0.8
             and self.last_clear_count >= 20
             and diff_tokens + other_tokens > coder.context_compaction_max_tokens * 0.5
         ):
             self.last_clear_count = 0
 
             # Clear all diff messages
-            ConversationService.get_manager(coder).clear_tag(MessageTag.DIFFS)
+            ConversationService.get_manager(coder).clear_tag(MessageTag.DIFFS, 0.33)
             # Clear ConversationFiles caches to force regeneration
             ConversationService.get_files(coder).clear_file_cache(clear_contexts=False)
 
@@ -623,7 +624,16 @@ class ConversationChunks:
             ConversationService.get_files(coder).add_file(fname, force_refresh=refresh)
 
             # Get file content (with proper caching and stub generation)
-            content = ConversationService.get_files(coder).get_file_stub(fname)
+            content = None
+            if coder.edit_format in ("agent", "subagent"):
+                content = ConversationService.get_files(coder).get_file_json(fname)
+            else:
+                content = ConversationService.get_files(coder).get_file_stub(fname)
+
+            if not content:
+                ConversationService.get_files(coder).clear_file_cache(fname)
+                continue
+
             if content:
                 # Add user message with file path as hash_key
                 rel_fname = coder.get_rel_fname(fname)
@@ -704,7 +714,12 @@ class ConversationChunks:
             ConversationService.get_files(coder).add_file(fname, force_refresh=refresh)
 
             # Get file content (with proper caching and stub generation)
-            content = ConversationService.get_files(coder).get_file_stub(fname)
+            content = None
+            if coder.edit_format in ("agent", "subagent"):
+                content = ConversationService.get_files(coder).get_file_json(fname)
+            else:
+                content = ConversationService.get_files(coder).get_file_stub(fname)
+
             if not content:
                 ConversationService.get_files(coder).clear_file_cache(fname)
                 continue
@@ -998,14 +1013,25 @@ class ConversationChunks:
     def flush_removals(self):
         self._deferred_removals.clear()
 
-    def _cancel_post_message_injections(self):
+    def _cancel_post_message_injections(self, modulus=10):
         coder = self.get_coder()
         if not coder:
             return False
 
         # Add system reminder as a pre-prompt context block
-        if coder.edit_format in ("agent", "subagent") and coder.turn_count % 5 != 0:
-            return True
+        if coder.edit_format in ("agent", "subagent"):
+            if coder.turn_count < modulus:
+                return True
+
+            if coder.edit_allowed and not coder._get_repetitive_tools():
+                return True
+
+            if coder.turn_count % modulus != 0:
+                # and coder.turn_count % modulus != 0
+                if not coder.edit_allowed:
+                    return False
+                else:
+                    return True
 
         return False
 

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/conversation/manager.py

@@ -370,8 +370,14 @@ class ConversationManager:
                 messages_dict = self._add_cache_control(messages_dict)
         return messages_dict
 
-    def clear_tag(self, tag: str) -> None:
-        """Remove all messages with given tag."""
+    def clear_tag(self, tag: str, ratio: float = 0) -> None:
+        """Remove all messages with given tag.
+
+        Args:
+            tag: The tag to remove messages for
+            ratio: If > 0, only consider the newest ratio portion of messages
+                   (e.g., 0.25 = newest 25%)
+        """
         if not isinstance(tag, MessageTag):
             try:
                 tag = MessageTag(tag)
@@ -381,7 +387,13 @@ class ConversationManager:
         tag_str = tag.value
         messages_to_remove = []
 
-        for message in self._messages:
+        # If ratio is set, only look at the newest portion of messages
+        messages = self._messages
+        if ratio > 0:
+            count = max(1, int(len(messages) * ratio))
+            messages = messages[-count:]
+
+        for message in messages:
             if message.tag == tag_str:
                 messages_to_remove.append(message)
 
@@ -394,17 +406,25 @@ class ConversationManager:
             self._tag_cache.pop(tag_str, None)
             self._tag_cache.pop(self._ALL_MESSAGES_CACHE_KEY, None)
 
-    def remove_messages_by_hash_key_pattern(self, pattern_checker) -> None:
+    def remove_messages_by_hash_key_pattern(self, pattern_checker, ratio: float = 0) -> None:
         """
         Remove messages whose hash_key matches a pattern.
 
         Args:
             pattern_checker: A function that takes a hash_key (tuple) and returns True
                             if the message should be removed
+            ratio: If > 0, only consider the newest ratio portion of messages
+                   (e.g., 0.25 = newest 25%)
         """
         messages_to_remove = []
 
-        for message in self._messages:
+        # If ratio is set, only look at the newest portion of messages
+        messages = self._messages
+        if ratio > 0:
+            count = max(1, int(len(messages) * ratio))
+            messages = messages[-count:]
+
+        for message in messages:
             if message.hash_key and pattern_checker(message.hash_key):
                 messages_to_remove.append(message)
 
@@ -421,17 +441,25 @@ class ConversationManager:
                 self._tag_cache.pop(tag, None)
             self._tag_cache.pop(self._ALL_MESSAGES_CACHE_KEY, None)
 
-    def remove_message_by_hash_key(self, hash_key: Tuple[str, ...]) -> bool:
+    def remove_message_by_hash_key(self, hash_key: Tuple[str, ...], ratio: float = 0) -> bool:
         """
         Remove a message by its exact hash key.
 
         Args:
             hash_key: The exact hash key to match
+            ratio: If > 0, only consider the newest ratio portion of messages
+                   (e.g., 0.25 = newest 25%)
 
         Returns:
             True if a message was removed, False otherwise
         """
-        messages_to_remove = [m for m in self._messages if m.hash_key == hash_key]
+        # If ratio is set, only look at the newest portion of messages
+        messages = self._messages
+        if ratio > 0:
+            count = max(1, int(len(messages) * ratio))
+            messages = messages[-count:]
+
+        messages_to_remove = [m for m in messages if m.hash_key == hash_key]
         if not messages_to_remove:
             return False
 

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/conversation/tags.py

@@ -19,6 +19,7 @@ class MessageTag(str, Enum):
     CHAT_FILES = "chat_files"
     EDIT_FILES = "edit_files"
     DIFFS = "diffs"
+    LINT = "lint"
     FILE_CONTEXTS = "file_contexts"
     CUR = "cur"
     DONE = "done"
@@ -37,6 +38,7 @@ DEFAULT_TAG_PRIORITY: Dict[MessageTag, int] = {
     MessageTag.CHAT_FILES: 200,
     MessageTag.EDIT_FILES: 200,
     MessageTag.DIFFS: 200,
+    MessageTag.LINT: 200,
     MessageTag.FILE_CONTEXTS: 200,
     MessageTag.DONE: 200,
     MessageTag.CUR: 200,
@@ -56,6 +58,7 @@ DEFAULT_TAG_TIMESTAMP_OFFSET: Dict[MessageTag, int] = {
     MessageTag.CHAT_FILES: 0,
     MessageTag.EDIT_FILES: 0,
     MessageTag.DIFFS: 0,
+    MessageTag.LINT: 0,
     MessageTag.FILE_CONTEXTS: 0,
     MessageTag.DONE: 0,
     MessageTag.CUR: 0,

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/conversation/utils.py

@@ -1,7 +1,8 @@
-import hashlib
 import json
 from typing import Any, Dict, Optional, Tuple
 
+import xxhash
+
 
 def generate_message_hash(
     role: str,
@@ -35,7 +36,7 @@ def generate_message_hash(
         else:
             key_data = f"{role}:{content or ''}"
 
-    return hashlib.md5(key_data.encode("utf-8")).hexdigest()
+    return xxhash.xxh3_128_hexdigest(key_data.encode("utf-8"))
 
 
 def validate_message_dict(message_dict: Dict[str, Any]) -> bool:

{cecli_dev-0.100.10rc4 → cecli_dev-0.100.11rc2}/cecli/helpers/hashline.py

@@ -1,4 +1,5 @@
 import difflib
+import json
 import re
 
 from cecli.helpers.hashpos.hashpos import HashPos
@@ -27,6 +28,39 @@ def hashline(text: str, start_line: int = 1) -> str:
     return hp.format_content(start_line=start_line)
 
 
+def hashline_formatted(
+    text: str, file_name: str, partial: bool, start_line: int = 1
+) -> tuple[str, str]:
+    """
+    Generate hashline-formatted content and return it as both raw hashline text and a JSON structure.
+
+    Args:
+        text: Input text
+        file_name: The file name or path
+        partial: Whether the content represents a partial file
+        start_line: Starting line number (default 1)
+
+    Returns:
+        A tuple of (raw_hashline_text, json_text):
+        - raw_hashline_text: The HashPos-prefixed content (same as hashline())
+        - json_text: JSON-formatted string with file_name, start_line, end_line, partial, and
+          prefixed_contents
+    """
+    hp = HashPos(text)
+    prefixed = hp.format_content(start_line=start_line)
+    end_line = start_line + hp.total - 1
+
+    result = {
+        "file_name": file_name,
+        "start_line": start_line,
+        "end_line": end_line,
+        "partial": partial,
+        "prefixed_contents": prefixed,
+    }
+
+    return prefixed, json.dumps(result, ensure_ascii=False)
+
+
 # int_to_2digit_52 removed as it is no longer used by the HashPos engine.