cecli-dev 0.99.2__tar.gz → 0.99.4__tar.gz

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.2
+Version: 0.99.4
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -52,6 +52,7 @@ Requires-Dist: textual>=6.0.0
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
+Requires-Dist: py-cymbal>=0.1.6
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: importlib-metadata>=7.2.1

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/__init__.py

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

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.2'
-__version_tuple__ = version_tuple = (0, 99, 2)
+__version__ = version = '0.99.4'
+__version_tuple__ = version_tuple = (0, 99, 4)
 
-__commit_id__ = commit_id = 'g7361036c0'
+__commit_id__ = commit_id = 'g25cca8975'

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/args.py

@@ -593,6 +593,12 @@ def get_parser(default_config_files, git_root):
         help="Show token processing and generation speed in usage report (default: False)",
         default=False,
     )
+    group.add_argument(
+        "--use-reminders",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable injecting reminder messages (default: True)",
+    )
     group.add_argument(
         "--completion-menu-color",
         metavar="COLOR",

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/coders/agent_coder.py

@@ -25,6 +25,7 @@ from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
 from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
+from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
 from cecli.utils import copy_tool_call, tool_call_to_dict
 
@@ -52,12 +53,9 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "commandinteractive",
-            "viewfilesatglob",
-            "viewfilesmatching",
+            "exploresymbols",
             "ls",
-            "viewfileswithsymbol",
             "grep",
-            "listchanges",
             "showcontext",
             "thinking",
             "updatetodolist",
@@ -328,7 +326,7 @@ class AgentCoder(Coder):
                 {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
             )
 
-        if self.auto_lint and used_write_tool and not self.edit_allowed:
+        if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
             lint_errors = self.lint_edited(edited, show_output=False)
             self.lint_outcome = not lint_errors
@@ -1018,25 +1016,25 @@ I will proceed based on the tool results and updated context.""")
 
             if not self.model_kwargs:
                 self.model_kwargs = {
-                    "temperature": default_temp + 0.1,
-                    "frequency_penalty": default_fp + 0.2,
+                    "temperature": default_temp + 2**-5,
+                    "frequency_penalty": default_fp + 2**-5,
                     # "presence_penalty": 0.1,
                 }
             else:
                 temperature = nested.getter(self.model_kwargs, "temperature", default_temp)
                 freq_penalty = nested.getter(self.model_kwargs, "frequency_penalty", default_fp)
 
-                self.model_kwargs["temperature"] = temperature + 0.1
-                self.model_kwargs["frequency_penalty"] = freq_penalty + 0.1
+                self.model_kwargs["temperature"] = temperature + 2**-5
+                self.model_kwargs["frequency_penalty"] = freq_penalty + 2**-5
 
                 if random.random() < 0.2:
                     self.model_kwargs["temperature"] = max(
                         default_temp,
-                        temperature - 0.15,
+                        temperature - 2**-4,
                     )
                     self.model_kwargs["frequency_penalty"] = max(
                         default_fp,
-                        freq_penalty - 0.15,
+                        freq_penalty - 2**-4,
                     )
 
             self.model_kwargs["temperature"] = max(
@@ -1160,7 +1158,7 @@ I will proceed based on the tool results and updated context.""")
 
         Parameters:
         - file_path: Path to the file to add
-        - explicit: Whether this was an explicit view command (vs. implicit through ViewFilesMatching)
+        - explicit: Whether this was an explicit view command (vs. implicit through other tools)
         """
         abs_path = self.abs_root_path(file_path)
         rel_path = self.get_rel_fname(abs_path)
@@ -1205,7 +1203,7 @@ I will proceed based on the tool results and updated context.""")
 
         Override parent's method to disable implicit file mention handling in agent mode.
         Files should only be added via explicit tool commands
-        (`View`, `ViewFilesAtGlob`, `ViewFilesMatching`, `ViewFilesWithSymbol`).
+        (`ContextManager`).
         """
         pass
 
@@ -1217,6 +1215,7 @@ I will proceed based on the tool results and updated context.""")
         inp = await super().preproc_user_input(inp)
         inp = self.wrap_user_input(inp)
 
+        BaseTool.clear_invocation_cache()
         self.agent_finished = False
         self.turn_count = 0
         return inp

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/coders/base_coder.py

@@ -42,6 +42,7 @@ from cecli.commands import Commands, SwitchCoderSignal
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import command_parser, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
+from cecli.helpers.observations.manager import ObservationManager
 from cecli.helpers.profiler import TokenProfiler
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
@@ -441,6 +442,7 @@ class Coder:
 
         # Initialize conversation system if enabled
         ConversationService.get_chunks(self).initialize_conversation_system()
+        self.observation_manager = ObservationManager.get_instance(self)
 
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
@@ -921,10 +923,10 @@ class Coder:
                             file_stub = RepoMap.get_file_stub(fname, self.io)
 
                             # Add message about showing definitions instead of full content
-                            self.io.tool_output(
-                                f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                                "Use /context-management to toggle truncation off if needed."
-                            )
+                            # self.io.tool_output(
+                            #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                            #    "Use /context-management to toggle truncation off if needed."
+                            # )
 
                             # Add a message in the content itself so the model knows it's truncated
                             truncation_note = (
@@ -989,10 +991,10 @@ class Coder:
                         file_stub = RepoMap.get_file_stub(fname, self.io)
 
                         # Add message about showing definitions instead of full content
-                        self.io.tool_output(
-                            f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                            "Use /context-management to toggle truncation off if needed."
-                        )
+                        # self.io.tool_output(
+                        #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                        #    "Use /context-management to toggle truncation off if needed."
+                        # )
 
                         # Add a message in the content itself so the model knows it's truncated
                         truncation_note = (
@@ -1746,11 +1748,14 @@ class Coder:
         if not self.enable_context_compaction:
             return
 
-        # Check if combined messages exceed the token limit,
-        # Get messages from ConversationManager
-        done_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DONE)
-        cur_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)
-        diff_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DIFFS)
+        # Trigger background observation/reflection check
+        await self.observation_manager.check_and_trigger()
+
+        manager = ConversationService.get_manager(self)
+        done_messages = manager.get_messages_dict(MessageTag.DONE)
+        cur_messages = manager.get_messages_dict(MessageTag.CUR)
+        diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
@@ -1768,129 +1773,97 @@ class Coder:
         self.io.update_spinner("Compacting...")
 
         try:
-            # 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,
+            compaction_prompt = self.gpt_prompts.compaction_prompt
+            if message:
+                compaction_prompt = f"{compaction_prompt}\n\n{message}"
+
+            async def summarize_and_update(messages, tag):
+                text = await self.summarizer.summarize_all_as_text(
+                    messages,
                     compaction_prompt,
                     self.context_compaction_summary_tokens,
                 )
+                if not text:
+                    raise ValueError(f"Summarization of {tag} messages returned empty.")
 
-                if not summary_text:
-                    raise ValueError("Summarization returned an empty result.")
+                if self.observation_manager.observations:
+                    obs_text = "\n".join(self.observation_manager.observations)
+                    text = f"HISTORICAL OBSERVATIONS:\n{obs_text}\n\n{text}"
 
-                # Replace old DONE messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.DONE)
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": summary_text,
-                    },
-                    tag=MessageTag.DONE,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary as the context for our conversation going"
-                            " forward."
-                        ),
-                    },
-                    tag=MessageTag.DONE,
-                )
+                manager.clear_tag(tag)
 
-            # 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,
-                    compaction_prompt,
-                    self.context_compaction_summary_tokens,
-                )
-
-                if not cur_summary_text:
-                    raise ValueError("Summarization of current messages returned an empty result.")
+                if tag == MessageTag.DONE:
+                    manager.add_message({"role": "user", "content": text}, tag=tag)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and the observations as context for"
+                                " our conversation going forward."
+                            ),
+                        },
+                        tag=tag,
+                    )
+                else:
+                    if self.last_user_message:
+                        manager.add_message(
+                            {"role": "user", "content": self.last_user_message}, tag=tag
+                        )
 
-                # Replace current CUR messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.CUR)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": "Ok. I am awaiting your summary of our goals to proceed.",
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                if self.last_user_message:
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
+                    manager.add_message(
+                        {
                             "role": "user",
-                            "content": self.last_user_message,
+                            "content": (
+                                "Here is a summary of our current goals and historical"
+                                f" context:\n{text}"
+                            ),
                         },
-                        tag=MessageTag.CUR,
+                        tag=tag,
                     )
 
-                # Add the summary conversation
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": "Ok. I am awaiting your summary of our goals to proceed.",
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": f"Here is a summary of our current goals:\n{cur_summary_text}",
-                    },
-                    tag=MessageTag.CUR,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary and proceed with our task."
-                            " I will first apply any changes in the summary and then"
-                            " continue exploration as necessary."
-                        ),
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-
-                # Find the last assistant messages in the current conversation
-                latest_messages = []
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and proceed with our task. I will"
+                                " first apply any changes in the summary and then continue"
+                                " exploration as necessary."
+                            ),
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                # Search from the end to find the most recent assistant messages
-                for msg in reversed(cur_messages):
-                    latest_messages.append(msg)
+                    latest_messages = []
+                    for msg in reversed(messages):
+                        latest_messages.append(msg)
+                        if msg["role"] == "assistant":
+                            break
+                    for msg in reversed(latest_messages):
+                        manager.add_message(msg, tag=tag)
 
-                    if msg["role"] == "assistant":
-                        break
+            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
+                await summarize_and_update(done_messages, MessageTag.DONE)
 
-                for msg in reversed(latest_messages):
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
-                            "role": msg["role"],
-                            "content": msg["content"],
-                        },
-                        tag=MessageTag.CUR,
-                    )
+            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
+                await summarize_and_update(cur_messages, MessageTag.CUR)
 
             self.io.tool_output("...chat history compacted.")
             self.io.update_spinner(self.io.last_spinner_text)
 
-            # Clear all diff and file context messages
-            ConversationService.get_manager(self).clear_tag(MessageTag.DIFFS)
-            ConversationService.get_manager(self).clear_tag(MessageTag.FILE_CONTEXTS)
-
-            # Reset ConversationFiles cache entirely
+            manager.clear_tag(MessageTag.DIFFS)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
+
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
             self.io.tool_warning("Proceeding with full history for now.")
@@ -2233,10 +2206,11 @@ class Coder:
 
         self.multi_response_content = ""
         if self.show_pretty():
-            spinner_text = (
-                f"Waiting for {self.get_active_model().name} •"
-                f" ${self.format_cost(self.total_cost)} session"
-            )
+            spinner_text = f"Waiting for {self.get_active_model().name}"
+
+            if not self.tui:
+                spinner_text += f" • ${self.format_cost(self.total_cost)} session"
+
             self.io.start_spinner(spinner_text)
             if self.stream:
                 self.mdstream = True
@@ -2763,8 +2737,8 @@ class Coder:
                     message_dict=tool_response,
                     tag=MessageTag.CUR,
                     hash_key=(tool_response["tool_call_id"], str(time.monotonic_ns())),
-                    promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
-                    mark_for_demotion=1,
+                    # promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
+                    # mark_for_demotion=1,
                 )
 
         return bool(tool_responses)
@@ -2951,8 +2925,8 @@ class Coder:
                 message_dict=msg,
                 tag=MessageTag.CUR,
                 hash_key=("assistant_message", str(msg), str(time.monotonic_ns())),
-                promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
-                mark_for_demotion=1,
+                # promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
+                # mark_for_demotion=1,
             )
 
     def get_file_mentions(self, content, ignore_current=False):
@@ -3541,13 +3515,18 @@ class Coder:
 
         self.message_tokens_received += completion_tokens
 
-        tokens_report = f"Tokens: {format_tokens(self.message_tokens_sent)} sent"
+        # Build the new streamlined format
+        tokens_parts = [format_tokens(prompt_tokens)]
 
-        if cache_write_tokens:
-            tokens_report += f", {format_tokens(cache_write_tokens)} cache write"
         if cache_hit_tokens:
-            tokens_report += f", {format_tokens(cache_hit_tokens)} cache hit"
-        tokens_report += f", {format_tokens(self.message_tokens_received)} received."
+            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
+        if cache_write_tokens:
+            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
+
+        tokens_str = "/".join(tokens_parts)
+
+        tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
+
         tokens_report = self.token_profiler.add_to_usage_report(
             tokens_report, self.message_tokens_sent, self.message_tokens_received
         )
@@ -3570,9 +3549,12 @@ class Coder:
         self.total_cost += cost
         self.message_cost += cost
 
+        total_combined_tokens = (
+            self.total_tokens_sent + self.total_tokens_received + prompt_tokens + completion_tokens
+        )
         cost_report = (
-            f"Cost: ${self.format_cost(self.message_cost)} message,"
-            f" ${self.format_cost(self.total_cost)} session."
+            f"${self.format_cost(self.message_cost)} • {format_tokens(total_combined_tokens)} ↑↓"
+            f" ${self.format_cost(self.total_cost)}"
         )
 
         if cache_hit_tokens and cache_write_tokens:
@@ -3630,8 +3612,11 @@ class Coder:
         self.total_tokens_sent += self.message_tokens_sent
         self.total_tokens_received += self.message_tokens_received
 
-        self.io.tool_output(self.usage_report)
-        self.io.rule()
+        if self.tui and self.tui():
+            self.tui().update_cost(self.usage_report.replace("\n", " "))
+        else:
+            self.io.tool_output(self.usage_report)
+            self.io.rule()
 
         self.message_cost = 0.0
         self.message_tokens_sent = 0

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/commands/clear.py

@@ -19,6 +19,7 @@ class ClearCommand(BaseCommand):
         ConversationService.get_manager(coder).clear_tag(MessageTag.FILE_CONTEXTS)
 
         ConversationService.get_files(coder).reset()
+        coder.observation_manager.reset()
 
         # Clear TUI output if available
         if coder.tui and coder.tui():

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/commands/load_hook.py

@@ -15,24 +15,28 @@ class LoadHookCommand(BaseCommand):
         if not args.strip():
             io.tool_error("Usage: /load-hook <hook-name>")
             return 1
-
-        hook_name = args.strip()
-
-        # Check if hook exists
+        hook_names = args.strip().split()
         hook_manager = HookManager()
-        if not hook_manager.hook_exists(hook_name):
-            io.tool_error(f"Error: Hook '{hook_name}' not found")
-            return 1
+        results = []
+        errors = 0
 
-        # Enable the hook
-        success = hook_manager.enable_hook(hook_name)
+        for hook_name in hook_names:
+            if not hook_manager.hook_exists(hook_name):
+                io.tool_error(f"Error: Hook '{hook_name}' not found")
+                results.append(f"Hook '{hook_name}' not found")
+                errors += 1
+                continue
 
-        if success:
-            io.tool_output(f"Hook '{hook_name}' enabled successfully")
-            return 0
-        else:
-            io.tool_error(f"Error: Failed to enable hook '{hook_name}'")
-            return 1
+            success = hook_manager.enable_hook(hook_name)
+            if success:
+                io.tool_output(f"Hook '{hook_name}' enabled successfully")
+                results.append(f"Hook '{hook_name}' enabled")
+            else:
+                io.tool_error(f"Error: Failed to enable hook '{hook_name}'")
+                results.append(f"Failed to enable hook '{hook_name}'")
+                errors += 1
+
+        return 0 if errors == 0 else 1
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
@@ -58,10 +62,10 @@ class LoadHookCommand(BaseCommand):
         """Get help text for the load-hook command."""
         help_text = super().get_help()
         help_text += "\nUsage:\n"
-        help_text += "  /load-hook <hook-name>  # Enable a specific hook\n"
+        help_text += "  /load-hook <hook-name>...  # Enable one or more hooks\n"
         help_text += "\nExamples:\n"
         help_text += "  /load-hook my_start_hook\n"
-        help_text += "  /load-hook check_commands\n"
-        help_text += "\nThis command enables a hook that was previously disabled.\n"
+        help_text += "  /load-hook check_commands my_start_hook\n"
+        help_text += "\nThis command enables one or more hooks that were previously disabled.\n"
         help_text += "Use /hooks to see all available hooks and their current state.\n"
         return help_text

{cecli_dev-0.99.2 → cecli_dev-0.99.4}/cecli/commands/load_mcp.py

@@ -19,25 +19,22 @@ class LoadMcpCommand(BaseCommand):
                 io, cls.NORM_NAME, "No MCP servers found, nothing to load."
             )
 
-        server_name = args.strip()
-        server = coder.mcp_manager.get_server(server_name)
-        if server is None:
-            return format_command_result(
-                io, cls.NORM_NAME, "", f"MCP server {server_name} does not exist."
-            )
-
-        did_connect = await coder.mcp_manager.connect_server(server.name)
-
-        if not did_connect:
-            return format_command_result(io, cls.NORM_NAME, f"Unable to load server: {server_name}")
+        server_names = args.strip().split()
+        results = []
+        for server_name in server_names:
+            server = coder.mcp_manager.get_server(server_name)
+            if server is None:
+                results.append(f"MCP server {server_name} does not exist.")
+                continue
 
-        try:
+            did_connect = await coder.mcp_manager.connect_server(server.name)
             if did_connect:
-                return format_command_result(io, cls.NORM_NAME, f"Loaded server: {server_name}")
+                results.append(f"Loaded server: {server_name}")
             else:
-                return format_command_result(
-                    io, cls.NORM_NAME, "", f"Unable to Load server: {server_name}"
-                )
+                results.append(f"Unable to load server: {server_name}")
+
+        try:
+            return format_command_result(io, cls.NORM_NAME, "\n".join(results))
         finally:
             from . import SwitchCoderSignal
 
@@ -69,9 +66,9 @@ class LoadMcpCommand(BaseCommand):
         """Get help text for the load-mcp command."""
         help_text = super().get_help()
         help_text += "\nUsage:\n"
-        help_text += "  /load-mcp <mcp-name>  # Load a mcp by name\n"
+        help_text += "  /load-mcp <mcp-name>...  # Load one or more mcps by name\n"
         help_text += "\nExamples:\n"
         help_text += "  /load-mcp context7  # Load the context7 mcp\n"
-        help_text += "  /load-mcp github  # Load the github mcp\n"
-        help_text += "\nThis command loads a MCP server by name.\n"
+        help_text += "  /load-mcp github context7  # Load both github and context7 mcps\n"
+        help_text += "\nThis command loads one or more MCP servers by name.\n"
         return help_text