cecli-dev 0.96.1__tar.gz → 0.96.3__tar.gz

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.96.1
+Version: 0.96.3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -47,7 +47,6 @@ Requires-Dist: socksio>=1.0.0
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: shtab>=1.7.2
 Requires-Dist: oslex>=0.1.3
-Requires-Dist: google-generativeai>=0.8.5
 Requires-Dist: mcp>=1.24.0
 Requires-Dist: textual>=6.0.0
 Requires-Dist: truststore

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/__init__.py

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

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.96.1'
-__version_tuple__ = version_tuple = (0, 96, 1)
+__version__ = version = '0.96.3'
+__version_tuple__ = version_tuple = (0, 96, 3)
 
-__commit_id__ = commit_id = 'g537255968'
+__commit_id__ = commit_id = 'gc5417d2f9'

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/coders/agent_coder.py

@@ -12,8 +12,6 @@ from collections import Counter, defaultdict
 from datetime import datetime
 from pathlib import Path
 
-from litellm import experimental_mcp_client
-
 from cecli import urls, utils
 from cecli.change_tracker import ChangeTracker
 from cecli.helpers import nested
@@ -29,6 +27,7 @@ from cecli.helpers.similarity import (
     normalize_vector,
 )
 from cecli.helpers.skills import SkillsManager
+from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
 from cecli.repo import ANY_GIT_ERROR
 from cecli.tools.utils.registry import ToolRegistry
@@ -306,7 +305,7 @@ class AgentCoder(Coder):
             }
             try:
                 session = await server.connect()
-                call_result = await experimental_mcp_client.call_openai_tool(
+                call_result = await litellm.experimental_mcp_client.call_openai_tool(
                     session=session, openai_tool=tool_call_dict
                 )
                 content_parts = []
@@ -800,11 +799,9 @@ I will proceed based on the current context.""")
             saved_message = await self.auto_commit(self.files_edited_by_tools)
             if not saved_message and hasattr(self.gpt_prompts, "files_content_gpt_edits_no_repo"):
                 saved_message = self.gpt_prompts.files_content_gpt_edits_no_repo
-            self.move_back_cur_messages(saved_message)
         self.tool_call_count = 0
         self.files_added_in_exploration = set()
         self.files_edited_by_tools = set()
-        self.move_back_cur_messages(None)
         return False
 
     async def _execute_tool_with_registry(self, norm_tool_name, params):

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/coders/architect_coder.py

@@ -52,12 +52,8 @@ class ArchitectCoder(AskCoder):
 
         editor_coder = await Coder.create(**new_kwargs)
 
-        # Clear ALL messages for editor coder (start fresh)
-        ConversationManager.reset()
-
         # Re-initialize ConversationManager with editor coder
-        ConversationManager.initialize(editor_coder)
-        ConversationManager.clear_cache()
+        ConversationManager.initialize(editor_coder, reset=True, reformat=True)
 
         if self.verbose:
             editor_coder.show_announcements()
@@ -69,48 +65,45 @@ class ArchitectCoder(AskCoder):
             editor_all_messages = ConversationManager.get_messages()
 
             # Clear manager and restore original state
-            ConversationManager.reset()
-            ConversationManager.initialize(original_coder or self)
+            ConversationManager.initialize(original_coder or self, reset=True, reformat=True)
 
             # Restore original messages with all metadata
             for msg in original_all_messages:
-                ConversationManager.add_message(
-                    msg.to_dict(),
-                    MessageTag(msg.tag),
-                    priority=msg.priority,
-                    timestamp=msg.timestamp,
-                    mark_for_delete=msg.mark_for_delete,
-                    hash_key=msg.hash_key,
-                )
+                if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
+                    ConversationManager.add_message(
+                        message_dict=msg.message_dict,
+                        tag=MessageTag(msg.tag),
+                        priority=msg.priority,
+                        mark_for_delete=msg.mark_for_delete,
+                        force=True,
+                    )
 
             # Append editor's DONE and CUR messages (but not other tags like SYSTEM)
             for msg in editor_all_messages:
                 if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
                     ConversationManager.add_message(
-                        msg.to_dict(),
-                        MessageTag(msg.tag),
+                        message_dict=msg.message_dict,
+                        tag=MessageTag(msg.tag),
                         priority=msg.priority,
-                        timestamp=msg.timestamp,
                         mark_for_delete=msg.mark_for_delete,
-                        hash_key=msg.hash_key,
+                        force=True,
                     )
 
-            self.move_back_cur_messages("I made those changes to the files.")
             self.total_cost = editor_coder.total_cost
             self.coder_commit_hashes = editor_coder.coder_commit_hashes
         except Exception as e:
             self.io.tool_error(e)
             # Restore original state on error
-            ConversationManager.reset()
-            ConversationManager.initialize(original_coder or self)
+            ConversationManager.initialize(original_coder or self, reset=True, reformat=True)
+
             for msg in original_all_messages:
-                ConversationManager.add_message(
-                    msg.to_dict(),
-                    MessageTag(msg.tag),
-                    priority=msg.priority,
-                    timestamp=msg.timestamp,
-                    mark_for_delete=msg.mark_for_delete,
-                    hash_key=msg.hash_key,
-                )
+                if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
+                    ConversationManager.add_message(
+                        message_dict=msg.message_dict,
+                        tag=MessageTag(msg.tag),
+                        priority=msg.priority,
+                        mark_for_delete=msg.mark_for_delete,
+                        force=True,
+                    )
 
         raise SwitchCoderSignal(main_model=self.main_model, edit_format="architect")

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/coders/base_coder.py

@@ -1659,7 +1659,7 @@ class Coder:
 
     # Old summarization system removed - using context compaction logic instead
 
-    async def compact_context_if_needed(self, force=False):
+    async def compact_context_if_needed(self, force=False, message=""):
         if not self.enable_context_compaction:
             return
 
@@ -1687,9 +1687,14 @@ class Coder:
             # Check if done_messages alone exceed the limit
             if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
                 # Create a summary of the done_messages
+                # Append custom message to compaction prompt if provided
+                compaction_prompt = self.gpt_prompts.compaction_prompt
+                if message:
+                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
+
                 summary_text = await self.summarizer.summarize_all_as_text(
                     done_messages,
-                    self.gpt_prompts.compaction_prompt,
+                    compaction_prompt,
                     self.context_compaction_summary_tokens,
                 )
 
@@ -1719,9 +1724,14 @@ class Coder:
             # Check if cur_messages alone exceed the limit (after potentially compacting done_messages)
             if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
                 # Create a summary of the cur_messages
+                # Append custom message to compaction prompt if provided
+                compaction_prompt = self.gpt_prompts.compaction_prompt
+                if message:
+                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
+
                 cur_summary_text = await self.summarizer.summarize_all_as_text(
                     cur_messages,
-                    self.gpt_prompts.compaction_prompt,
+                    compaction_prompt,
                     self.context_compaction_summary_tokens,
                 )
 
@@ -1774,32 +1784,6 @@ class Coder:
             self.io.tool_warning("Proceeding with full history for now.")
             return
 
-    def move_back_cur_messages(self, message):
-        # Move CUR messages to DONE in ConversationManager
-        # Get current CUR messages
-        cur_messages = ConversationManager.get_messages_dict(MessageTag.CUR)
-
-        # Clear CUR messages from ConversationManager
-        ConversationManager.clear_tag(MessageTag.CUR)
-
-        # Add them back as DONE messages
-        for msg in cur_messages:
-            ConversationManager.add_message(
-                message_dict=msg,
-                tag=MessageTag.DONE,
-            )
-
-        # TODO check for impact on image messages
-        if message:
-            ConversationManager.add_message(
-                message_dict=dict(role="user", content=message),
-                tag=MessageTag.DONE,
-            )
-            ConversationManager.add_message(
-                message_dict=dict(role="assistant", content="Ok."),
-                tag=MessageTag.DONE,
-            )
-
     def normalize_language(self, lang_code):
         """
         Convert a locale code such as ``en_US`` or ``fr`` into a readable
@@ -2277,8 +2261,6 @@ class Coder:
             if not saved_message and hasattr(self.gpt_prompts, "files_content_gpt_edits_no_repo"):
                 saved_message = self.gpt_prompts.files_content_gpt_edits_no_repo
 
-            self.move_back_cur_messages(saved_message)
-
         if not interrupted:
             add_rel_files_message = await self.check_for_file_mentions(content)
             if add_rel_files_message:
@@ -3783,8 +3765,6 @@ class Coder:
 
         await self.repo.commit(fnames=self.need_commit_before_edits, coder=self)
 
-        # files changed, move cur messages back behind the files messages
-        # self.move_back_cur_messages(self.gpt_prompts.files_content_local_edits)
         return True
 
     def get_edits(self, mode="update"):

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/commands/compact.py

@@ -7,7 +7,9 @@ class CompactCommand(BaseCommand):
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
-        await coder.compact_context_if_needed(force=True)
+        # Pass args as message parameter if it's not empty
+        message = args.strip() if args else ""
+        await coder.compact_context_if_needed(force=True, message=message)
 
     @classmethod
     def get_help(cls) -> str:

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/commands/editor_model.py

@@ -62,12 +62,8 @@ class EditorModelCommand(BaseCommand):
 
             temp_coder = await Coder.create(**new_kwargs)
 
-            # Clear ALL messages for temp coder (start fresh)
-            ConversationManager.reset()
-
             # Re-initialize ConversationManager with temp coder
-            ConversationManager.initialize(temp_coder)
-            ConversationManager.clear_cache()
+            ConversationManager.initialize(temp_coder, reset=True, reformat=True)
 
             verbose = kwargs.get("verbose", False)
             if verbose:
@@ -82,37 +78,30 @@ class EditorModelCommand(BaseCommand):
                 temp_all_messages = ConversationManager.get_messages()
 
                 # Clear manager and restore original state
-                ConversationManager.reset()
-                ConversationManager.initialize(original_coder)
+                ConversationManager.initialize(original_coder, reset=True, reformat=True)
 
                 # Restore original messages with all metadata
                 for msg in original_all_messages:
-                    ConversationManager.add_message(
-                        msg.to_dict(),
-                        MessageTag(msg.tag),
-                        priority=msg.priority,
-                        timestamp=msg.timestamp,
-                        mark_for_delete=msg.mark_for_delete,
-                        hash_key=msg.hash_key,
-                    )
+                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
+                        ConversationManager.add_message(
+                            message_dict=msg.message_dict,
+                            tag=MessageTag(msg.tag),
+                            priority=msg.priority,
+                            mark_for_delete=msg.mark_for_delete,
+                            force=True,
+                        )
 
                 # Append temp coder's DONE and CUR messages (but not other tags like SYSTEM)
                 for msg in temp_all_messages:
                     if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
                         ConversationManager.add_message(
-                            msg.to_dict(),
-                            MessageTag(msg.tag),
+                            message_dict=msg.message_dict,
+                            tag=MessageTag(msg.tag),
                             priority=msg.priority,
-                            timestamp=msg.timestamp,
                             mark_for_delete=msg.mark_for_delete,
-                            hash_key=msg.hash_key,
+                            force=True,
                         )
 
-                # Move back cur messages with appropriate message
-                coder.move_back_cur_messages(
-                    f"Editor model {model_name} made those changes to the files."
-                )
-
                 # Restore the original model configuration
                 from cecli.commands import SwitchCoderSignal
 

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/commands/model.py

@@ -67,12 +67,8 @@ class ModelCommand(BaseCommand):
 
             temp_coder = await Coder.create(**new_kwargs)
 
-            # Clear ALL messages for temp coder (start fresh)
-            ConversationManager.reset()
-
             # Re-initialize ConversationManager with temp coder
-            ConversationManager.initialize(temp_coder)
-            ConversationManager.clear_cache()
+            ConversationManager.initialize(temp_coder, reset=True, reformat=True)
 
             verbose = kwargs.get("verbose", False)
             if verbose:
@@ -87,35 +83,30 @@ class ModelCommand(BaseCommand):
                 temp_all_messages = ConversationManager.get_messages()
 
                 # Clear manager and restore original state
-                ConversationManager.reset()
-                ConversationManager.initialize(original_coder)
+                ConversationManager.initialize(original_coder, reset=True, reformat=True)
 
                 # Restore original messages with all metadata
                 for msg in original_all_messages:
-                    ConversationManager.add_message(
-                        msg.to_dict(),
-                        MessageTag(msg.tag),
-                        priority=msg.priority,
-                        timestamp=msg.timestamp,
-                        mark_for_delete=msg.mark_for_delete,
-                        hash_key=msg.hash_key,
-                    )
+                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
+                        ConversationManager.add_message(
+                            message_dict=msg.message_dict,
+                            tag=MessageTag(msg.tag),
+                            priority=msg.priority,
+                            mark_for_delete=msg.mark_for_delete,
+                            force=True,
+                        )
 
                 # Append temp coder's DONE and CUR messages (but not other tags like SYSTEM)
                 for msg in temp_all_messages:
                     if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
                         ConversationManager.add_message(
-                            msg.to_dict(),
-                            MessageTag(msg.tag),
+                            message_dict=msg.message_dict,
+                            tag=MessageTag(msg.tag),
                             priority=msg.priority,
-                            timestamp=msg.timestamp,
                             mark_for_delete=msg.mark_for_delete,
-                            hash_key=msg.hash_key,
+                            force=True,
                         )
 
-                # Move back cur messages with appropriate message
-                coder.move_back_cur_messages(f"Model {model_name} made those changes to the files.")
-
                 # Restore the original model configuration
                 from cecli.commands import SwitchCoderSignal
 

{cecli_dev-0.96.1 → cecli_dev-0.96.3}/cecli/commands/reset.py

@@ -20,7 +20,7 @@ class ResetCommand(BaseCommand):
             ConversationFiles.reset()  # Clear all file caches
 
             # Re-initialize ConversationManager with current coder
-            ConversationManager.initialize(coder)
+            ConversationManager.initialize(coder, reformat=True)
             ConversationFiles.initialize(coder)
 
             # Clear TUI output if available

cecli_dev-0.96.3/cecli/commands/tokens.py

@@ -0,0 +1,235 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers.conversation import ConversationManager, MessageTag
+
+
+class TokensCommand(BaseCommand):
+    NORM_NAME = "tokens"
+    DESCRIPTION = "Report on the number of tokens used by the current chat context"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        res = []
+
+        coder.choose_fence()
+        coder.format_chat_chunks()
+
+        # Show progress indicator
+        total_files = len(coder.abs_fnames) + len(coder.abs_read_only_fnames)
+        if total_files > 20:
+            io.tool_output(f"Calculating tokens for {total_files} files...")
+
+        # system messages - sum of SYSTEM, STATIC, EXAMPLES, and REMINDER tags
+        system_tags = [
+            MessageTag.SYSTEM,
+            MessageTag.STATIC,
+            MessageTag.EXAMPLES,
+            MessageTag.REMINDER,
+        ]
+        system_tokens = 0
+
+        for tag in system_tags:
+            msgs = ConversationManager.get_messages_dict(tag=tag)
+            if msgs:
+                system_tokens += coder.main_model.token_count(msgs)
+
+        # Calculate context block tokens (they are part of STATIC messages)
+        context_block_total = 0
+
+        # Enhanced context blocks (only for agent mode)
+        if hasattr(coder, "use_enhanced_context") and coder.use_enhanced_context:
+            # Force token calculation if it hasn't been done yet
+            if hasattr(coder, "_calculate_context_block_tokens"):
+                if not hasattr(coder, "tokens_calculated") or not coder.tokens_calculated:
+                    coder._calculate_context_block_tokens()
+
+            # Calculate total context block tokens
+            if hasattr(coder, "context_block_tokens") and coder.context_block_tokens:
+                context_block_total = sum(coder.context_block_tokens.values())
+
+                # Subtract context block tokens from system token count
+                # Context blocks are part of STATIC messages, so we need to subtract them
+                system_tokens = max(0, system_tokens - context_block_total)
+
+        res.append((system_tokens, "system messages", ""))
+
+        # chat history
+        msgs_done = ConversationManager.get_messages_dict(tag=MessageTag.DONE)
+        msgs_cur = ConversationManager.get_messages_dict(tag=MessageTag.CUR)
+        tokens_done = 0
+        tokens_cur = 0
+
+        if msgs_done:
+            tokens_done = coder.main_model.token_count(msgs_done)
+
+        if msgs_cur:
+            tokens_cur = coder.main_model.token_count(msgs_cur)
+
+        if tokens_cur + tokens_done:
+            res.append((tokens_cur + tokens_done, "chat history", "use /clear to clear"))
+
+        # repo map
+        if coder.repo_map:
+            tokens = coder.main_model.token_count(
+                ConversationManager.get_messages_dict(tag=MessageTag.REPO)
+            )
+            res.append((tokens, "repository map", "use --map-tokens to resize"))
+
+        # Display enhanced context blocks (only for agent mode)
+        # Note: Context block tokens were already calculated and subtracted from system messages
+        if hasattr(coder, "use_enhanced_context") and coder.use_enhanced_context:
+            if hasattr(coder, "context_block_tokens") and coder.context_block_tokens:
+                for block_name, tokens in coder.context_block_tokens.items():
+                    # Format the block name more nicely
+                    display_name = block_name.replace("_", " ").title()
+                    res.append(
+                        (tokens, f"{display_name} context block", "/context-blocks to toggle")
+                    )
+
+        file_res = []
+
+        # Calculate tokens for read-only files using READONLY_FILES tag
+        readonly_msgs = ConversationManager.get_messages_dict(tag=MessageTag.READONLY_FILES)
+        if readonly_msgs:
+            # Group messages by file (each file has user and assistant messages)
+            file_tokens = {}
+            for msg in readonly_msgs:
+                # Extract file name from message content
+                content = msg.get("content", "")
+                if content.startswith("File Contents"):
+                    # Extract file path from "File Contents {path}:"
+                    lines = content.split("\n", 1)
+                    if lines:
+                        file_line = lines[0]
+                        if file_line.startswith("File Contents"):
+                            fname = file_line[13:].rstrip(":")
+                            # Calculate tokens for this message
+                            tokens = coder.main_model.token_count([msg])
+                            if fname not in file_tokens:
+                                file_tokens[fname] = 0
+                            file_tokens[fname] += tokens
+                elif "image_file" in msg:
+                    # Handle image files
+                    fname = msg.get("image_file")
+                    if fname:
+                        tokens = coder.main_model.token_count([msg])
+                        if fname not in file_tokens:
+                            file_tokens[fname] = 0
+                        file_tokens[fname] += tokens
+
+            # Add to results
+            for fname, tokens in file_tokens.items():
+                relative_fname = coder.get_rel_fname(fname)
+                file_res.append((tokens, f"{relative_fname} (read-only)", "/drop to remove"))
+
+        # Calculate tokens for editable files using CHAT_FILES and EDIT_FILES tags
+        editable_tags = [MessageTag.CHAT_FILES, MessageTag.EDIT_FILES]
+        editable_file_tokens = {}
+
+        for tag in editable_tags:
+            msgs = ConversationManager.get_messages_dict(tag=tag)
+            if msgs:
+                for msg in msgs:
+                    # Extract file name from message content
+                    content = msg.get("content", "")
+                    if content.startswith("File Contents"):
+                        # Extract file path from "File Contents {path}:"
+                        lines = content.split("\n", 1)
+                        if lines:
+                            file_line = lines[0]
+                            if file_line.startswith("File Contents"):
+                                fname = file_line[13:].rstrip(":")
+                                # Calculate tokens for this message
+                                tokens = coder.main_model.token_count([msg])
+                                if fname not in editable_file_tokens:
+                                    editable_file_tokens[fname] = 0
+                                editable_file_tokens[fname] += tokens
+                    elif "image_file" in msg:
+                        # Handle image files
+                        fname = msg.get("image_file")
+                        if fname:
+                            tokens = coder.main_model.token_count([msg])
+                            if fname not in editable_file_tokens:
+                                editable_file_tokens[fname] = 0
+                            editable_file_tokens[fname] += tokens
+
+        # Add editable files to results
+        for fname, tokens in editable_file_tokens.items():
+            relative_fname = coder.get_rel_fname(fname)
+            file_res.append((tokens, f"{relative_fname}", "/drop to remove"))
+
+        if file_res:
+            file_res.sort()
+            res.extend(file_res)
+
+        io.tool_output(f"Approximate context window usage for {coder.main_model.name}, in tokens:")
+        io.tool_output()
+
+        width = 8
+        cost_width = 9
+
+        def fmt(v):
+            return format(int(v), ",").rjust(width)
+
+        col_width = max(len(row[1]) for row in res) if res else 0
+
+        cost_pad = " " * cost_width
+        total = 0
+        total_cost = 0.0
+        for tk, msg, tip in res:
+            total += tk
+            cost = tk * (coder.main_model.info.get("input_cost_per_token") or 0)
+            total_cost += cost
+            msg = msg.ljust(col_width)
+            io.tool_output(f"${cost:7.4f} {fmt(tk)} {msg} {tip}")  # noqa: E231
+
+        io.tool_output("=" * (width + cost_width + 1))
+        io.tool_output(f"${total_cost:7.4f} {fmt(total)} tokens total")  # noqa: E231
+
+        limit = coder.main_model.info.get("max_input_tokens") or 0
+        if not limit:
+            return format_command_result(io, "tokens", "Token report generated")
+
+        remaining = limit - total
+        if remaining > 1024:
+            io.tool_output(f"{cost_pad}{fmt(remaining)} tokens remaining in context window")
+        elif remaining > 0:
+            io.tool_error(
+                f"{cost_pad}{fmt(remaining)} tokens remaining in context window (use /drop or"
+                " /clear to make space)"
+            )
+        else:
+            io.tool_error(
+                f"{cost_pad}{fmt(remaining)} tokens remaining, window exhausted (use /drop or"
+                " /clear to make space)"
+            )
+        io.tool_output(f"{cost_pad}{fmt(limit)} tokens max context window size")
+
+        return format_command_result(io, "tokens", "Token report generated")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for tokens command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the tokens command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /tokens  # Show token usage for current chat context\n"
+        help_text += "\nThis command calculates and displays the approximate token usage for:\n"
+        help_text += "  - System messages\n"
+        help_text += "  - Chat history\n"
+        help_text += "  - Repository map\n"
+        help_text += "  - Editable files in chat\n"
+        help_text += "  - Read-only files\n"
+        help_text += "  - Read-only stub files\n"
+        help_text += "  - Enhanced context blocks (agent mode only)\n"
+        help_text += (
+            "\nThe report shows token counts, estimated costs, and remaining context window"
+            " space.\n"
+        )
+        return help_text