cecli-dev 0.99.8__tar.gz → 0.99.10__tar.gz

{cecli_dev-0.99.8 → cecli_dev-0.99.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.8
+Version: 0.99.10
 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.99.8 → cecli_dev-0.99.10}/cecli/__init__.py

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

{cecli_dev-0.99.8 → cecli_dev-0.99.10}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.8'
-__version_tuple__ = version_tuple = (0, 99, 8)
+__version__ = version = '0.99.10'
+__version_tuple__ = version_tuple = (0, 99, 10)
 
-__commit_id__ = commit_id = 'g2e022d0e6'
+__commit_id__ = commit_id = 'gdd5ec67da'

{cecli_dev-0.99.8 → cecli_dev-0.99.10}/cecli/coders/agent_coder.py

@@ -31,6 +31,8 @@ from cecli.utils import copy_tool_call, tool_call_to_dict
 
 from .base_coder import Coder
 
+from cecli.helpers.coroutines import interruptible  # isort:skip
+
 
 class AgentCoder(Coder):
     """Mode where the LLM autonomously manages which files are in context."""
@@ -42,6 +44,9 @@ class AgentCoder(Coder):
     stop_on_empty = False
 
     def __init__(self, *args, **kwargs):
+        if kwargs.get("uuid", None):
+            self.uuid = kwargs.get("uuid")
+
         self.recently_removed = {}
         self.tool_usage_history = []
         self.loaded_custom_tools = []
@@ -55,7 +60,7 @@ class AgentCoder(Coder):
             "commandinteractive",
             "explorecode",
             "ls",
-            "getlines",
+            "readrange",
             "grep",
             "thinking",
             "updatetodolist",
@@ -301,8 +306,23 @@ class AgentCoder(Coder):
                 else:
                     all_results_content.append(f"Error: Unknown tool name '{tool_name}'")
                 if tasks:
-                    task_results = await asyncio.gather(*tasks)
-                    all_results_content.extend(str(res) for res in task_results)
+
+                    async def gather_and_await():
+                        return await asyncio.gather(*tasks, return_exceptions=True)
+
+                    task_results, interrupted = await interruptible(
+                        gather_and_await(), self.interrupt_event
+                    )
+
+                    if interrupted:
+                        self.io.tool_warning("Tool execution interrupted.")
+                        all_results_content.append("Tool execution interrupted by user.")
+                    elif task_results:
+                        for res in task_results:
+                            if isinstance(res, Exception):
+                                all_results_content.append(f"Error in tool execution: {res}")
+                            else:
+                                all_results_content.append(str(res))
 
                 if not await HookIntegration.call_post_tool_hooks(
                     self, tool_name, args_string, "\n\n".join(all_results_content)
@@ -393,7 +413,11 @@ class AgentCoder(Coder):
 """)
                 return f"Error executing tool call {tool_name}: {e}"
 
-        return await _exec_async()
+        result, interrupted = await interruptible(_exec_async(), self.interrupt_event)
+
+        if interrupted:
+            return "Tool execution interrupted by user."
+        return result
 
     def _calculate_context_block_tokens(self, force=False):
         """
@@ -618,9 +642,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         editable_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         editable_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"
@@ -642,9 +664,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         readonly_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         readonly_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"
@@ -999,7 +1019,7 @@ I will proceed based on the tool results and updated context.""")
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled.Use `GetLines` to determine the"
+                "File editing tools are currently disabled.Use `ReadRange` to determine the"
                 " current hashline prefixes needed to perform an edit and activate them when you"
                 " are ready to edit a file."
             )

{cecli_dev-0.99.8 → cecli_dev-0.99.10}/cecli/coders/base_coder.py

@@ -139,6 +139,12 @@ class Coder:
     partial_response_tool_calls = []
     commit_before_message = []
     message_cost = 0.0
+    total_tokens_sent = 0
+    total_tokens_received = 0
+    total_cached_tokens = 0
+    message_tokens_sent = 0
+    message_tokens_received = 0
+    message_cached_tokens = 0
     add_cache_headers = False
     cache_warming_thread = None
     num_cache_warming_pings = 0
@@ -227,6 +233,7 @@ class Coder:
                 ignore_mentions=from_coder.ignore_mentions,
                 total_tokens_sent=from_coder.total_tokens_sent,
                 total_tokens_received=from_coder.total_tokens_received,
+                total_cached_tokens=from_coder.total_cached_tokens,
                 file_watcher=from_coder.file_watcher,
                 mcp_manager=from_coder.mcp_manager,
                 uuid=from_coder.uuid,
@@ -316,6 +323,7 @@ class Coder:
         ignore_mentions=None,
         total_tokens_sent=0,
         total_tokens_received=0,
+        total_cached_tokens=0,
         file_watcher=None,
         auto_copy_context=False,
         auto_accept_architect=True,
@@ -331,6 +339,7 @@ class Coder:
     ):
         # initialize from args.map_cache_dir
         self.interrupt_event = asyncio.Event()
+        self.coroutines = coroutines
         self.uuid = generate_unique_id()
         if uuid:
             self.uuid = uuid
@@ -388,8 +397,10 @@ class Coder:
         self.total_cost = total_cost
         self.total_tokens_sent = total_tokens_sent
         self.total_tokens_received = total_tokens_received
+        self.total_cached_tokens = total_cached_tokens
         self.message_tokens_sent = 0
         self.message_tokens_received = 0
+        self.message_cached_tokens = 0
 
         self.token_profiler = TokenProfiler(
             enable_printing=nested.getter(self.args, "show_speed", False)
@@ -1370,11 +1381,6 @@ class Coder:
             except (SwitchCoderSignal, SystemExit):
                 # Re-raise SwitchCoder to be handled by outer try block
                 raise
-            except KeyboardInterrupt:
-                # Handle keyboard interrupt gracefully
-                self.io.set_placeholder("")
-                self.io.stop_spinner()
-                self.keyboard_interrupt()
             finally:
                 # Signal tasks to stop
                 self.input_running = False
@@ -1454,10 +1460,6 @@ class Coder:
 
                 await asyncio.sleep(0.1)  # Small yield to prevent tight loop
 
-            except KeyboardInterrupt:
-                self.io.set_placeholder("")
-                self.keyboard_interrupt()
-                await self.io.stop_task_streams()
             except (SwitchCoderSignal, SystemExit):
                 raise
             except Exception as e:
@@ -1738,8 +1740,7 @@ class Coder:
         # Ensure cursor is visible on exit
         Console().show_cursor(True)
 
-        self.io.tool_warning("\n\n^C KeyboardInterrupt")
-
+        self.io.tool_warning("^C KeyboardInterrupt")
         self.interrupt_event.set()
         self.last_keyboard_interrupt = time.time()
 
@@ -2178,6 +2179,8 @@ class Coder:
         # Notify IO that LLM processing is starting
         self.io.llm_started()
 
+        ConversationService.get_manager(self).flush_queue()
+
         if inp:
             # Make sure current coder actually has control of conversation system
             ConversationService.get_chunks(self).initialize_conversation_system()
@@ -2260,9 +2263,16 @@ class Coder:
                         self.io.tool_error(err_msg)
 
                     self.io.tool_output(f"Retrying in {retry_delay:.1f} seconds...")
-                    await asyncio.sleep(retry_delay)
+
+                    _res, interrupted_sleep = await coroutines.interruptible(
+                        asyncio.sleep(retry_delay), self.interrupt_event
+                    )
+                    if interrupted_sleep:
+                        interrupted = True
+                        break
+
                     continue
-                except KeyboardInterrupt:
+                except (KeyboardInterrupt, asyncio.CancelledError):
                     interrupted = True
                     break
                 except FinishReasonLength:
@@ -2627,11 +2637,19 @@ class Coder:
                             all_results_content.append("Tool Request Aborted.")
                             continue
 
-                        call_result = await experimental_mcp_client.call_openai_tool(
-                            session=session,
-                            openai_tool=new_tool_call,
+                        async def do_tool_call():
+                            return await experimental_mcp_client.call_openai_tool(
+                                session=session,
+                                openai_tool=new_tool_call,
+                            )
+
+                        call_result, interrupted = await coroutines.interruptible(
+                            do_tool_call(), self.interrupt_event
                         )
 
+                        if interrupted:
+                            raise KeyboardInterrupt("Tool call interrupted")
+
                         content_parts = []
                         if call_result.content:
                             for item in call_result.content:
@@ -2676,6 +2694,9 @@ class Coder:
                         }
                     )
 
+                except KeyboardInterrupt:
+                    self.io.tool_warning(f"Tool call {tool_call.function.name} interrupted.")
+                    raise
                 except Exception as e:
                     tool_error = f"Error executing tool call {tool_call.function.name}: \n{e}"
                     self.io.tool_warning(
@@ -2692,6 +2713,9 @@ class Coder:
                 tool_responses.append(
                     {"role": "tool", "tool_call_id": tool_call.id, "content": connection_error}
                 )
+        except asyncio.CancelledError:
+            # Re-raise CancelledError to ensure the task cancellation propagates
+            raise
         except Exception as e:
             connection_error = f"Could not connect to server {server.name}\n{e}"
             self.io.tool_warning(connection_error)
@@ -2726,7 +2750,15 @@ class Coder:
             return False
 
         # 5. Execute tools
-        tool_responses_by_server = await self._execute_tool_groups(tool_groups)
+        self.interrupt_event.clear()
+
+        tool_responses_by_server, interrupted = await coroutines.interruptible(
+            self._execute_tool_groups(tool_groups), self.interrupt_event
+        )
+
+        if interrupted:
+            self.io.tool_warning("Tool execution interrupted.")
+            return False
 
         # 6. Add responses to conversation (re-prefixing if necessary)
         tool_responses = []
@@ -3038,33 +3070,22 @@ class Coder:
         self.token_profiler.start()
 
         try:
-            completion_task = asyncio.create_task(
-                model.send_completion(
-                    messages,
-                    functions,
-                    self.stream,
-                    self.temperature,
-                    # This could include any tools, but for now it is just MCP tools
-                    tools=tools,
-                    override_kwargs=self.model_kwargs.copy(),
-                )
+            completion_coro = model.send_completion(
+                messages,
+                functions,
+                self.stream,
+                self.temperature,
+                # This could include any tools, but for now it is just MCP tools
+                tools=tools,
+                override_kwargs=self.model_kwargs.copy(),
+                interrupt_event=self.interrupt_event,
             )
-            interrupt_task = asyncio.create_task(self.interrupt_event.wait())
 
-            done, pending = await asyncio.wait(
-                {completion_task, interrupt_task},
-                return_when=asyncio.FIRST_COMPLETED,
+            (hash_object, completion), interrupted = await coroutines.interruptible(
+                completion_coro, self.interrupt_event
             )
-
-            if interrupt_task in done:
-                completion_task.cancel()
-                try:
-                    await completion_task
-                except asyncio.CancelledError:
-                    pass
+            if interrupted:
                 raise KeyboardInterrupt
-
-            hash_object, completion = completion_task.result()
             self.chat_completion_call_hashes.append(hash_object.hexdigest())
 
             if not isinstance(completion, ModelResponse):
@@ -3087,7 +3108,7 @@ class Coder:
                 self.token_profiler.on_error()
                 self.calculate_and_show_tokens_and_cost(messages, completion)
             raise
-        except KeyboardInterrupt as kbi:
+        except (KeyboardInterrupt, asyncio.CancelledError) as kbi:
             self.keyboard_interrupt()
             raise kbi
         finally:
@@ -3496,10 +3517,13 @@ class Coder:
         if completion and hasattr(completion, "usage") and completion.usage is not None:
             prompt_tokens = completion.usage.prompt_tokens
             completion_tokens = completion.usage.completion_tokens
-            cache_hit_tokens = getattr(completion.usage, "prompt_cache_hit_tokens", 0) or getattr(
-                completion.usage, "cache_read_input_tokens", 0
+            cache_hit_tokens = (
+                getattr(completion.usage, "prompt_cache_hit_tokens", 0)
+                or getattr(completion.usage, "cache_read_input_tokens", 0)
+                or 0
             )
-            cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0)
+            cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0
+            self.message_cached_tokens += cache_hit_tokens
 
             if hasattr(completion.usage, "cache_read_input_tokens") or hasattr(
                 completion.usage, "cache_creation_input_tokens"
@@ -3532,8 +3556,22 @@ class Coder:
             tokens_report, self.message_tokens_sent, self.message_tokens_received
         )
 
+        total_combined_tokens = (
+            self.total_tokens_sent
+            + self.total_tokens_received
+            + self.message_tokens_sent
+            + self.message_tokens_received
+        )
+        total_combined_cached = self.total_cached_tokens + self.message_cached_tokens
+
+        total_stats = f"{format_tokens(total_combined_tokens)}"
+        if total_combined_cached:
+            total_stats += f"/{format_tokens(total_combined_cached)}"
+
+        total_stats += " ↑↓"
+
         if not self.get_active_model().info.get("input_cost_per_token"):
-            self.usage_report = tokens_report
+            self.usage_report = tokens_report + "\n" + total_stats
             return
 
         try:
@@ -3550,11 +3588,8 @@ 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"${self.format_cost(self.message_cost)} • {format_tokens(total_combined_tokens)} ↑↓"
+            f"${self.format_cost(self.message_cost)} • {total_stats}"
             f" ${self.format_cost(self.total_cost)}"
         )
 
@@ -3612,6 +3647,7 @@ class Coder:
 
         self.total_tokens_sent += self.message_tokens_sent
         self.total_tokens_received += self.message_tokens_received
+        self.total_cached_tokens += self.message_cached_tokens
 
         if self.tui and self.tui():
             self.tui().update_cost(self.usage_report.replace("\n", " "))
@@ -3622,6 +3658,7 @@ class Coder:
         self.message_cost = 0.0
         self.message_tokens_sent = 0
         self.message_tokens_received = 0
+        self.message_cached_tokens = 0
 
     def get_multi_response_content_in_progress(self, final=False):
         cur = self.multi_response_content or ""
@@ -3723,7 +3760,7 @@ class Coder:
             self.check_for_dirty_commit(path)
             return True
 
-        if self.repo and self.repo.git_ignored_file(path):
+        if self.repo and self.repo.git_ignored_file(path) and not self.add_gitignore_files:
             self.io.tool_warning(f"Skipping edits to {path} that matches gitignore spec.")
             return
 
@@ -3742,7 +3779,8 @@ class Coder:
                 # actually already part of the repo.
                 # But let's only add if we need to, just to be safe.
                 if need_to_add:
-                    self.repo.repo.git.add(full_path)
+                    if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                        self.repo.repo.git.add(full_path)
 
             self.abs_fnames.add(full_path)
             self.check_added_files()
@@ -3756,7 +3794,8 @@ class Coder:
             return
 
         if need_to_add:
-            self.repo.repo.git.add(full_path)
+            if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                self.repo.repo.git.add(full_path)
 
         self.abs_fnames.add(full_path)
         self.check_added_files()
@@ -4003,7 +4042,10 @@ class Coder:
         return edits
 
     def local_agent_folder(self, path):
-        os.makedirs(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}", exist_ok=True)
+        os.makedirs(
+            self.abs_root_path(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}"),
+            exist_ok=True,
+        )
 
         stripped = path.lstrip("/")
         return f".cecli/agents/{GLOBAL_DATE}/{self.uuid}/{stripped}"

{cecli_dev-0.99.8 → cecli_dev-0.99.10}/cecli/commands/__init__.py

@@ -25,14 +25,17 @@ from .diff import DiffCommand
 from .drop import DropCommand
 from .editor import EditCommand, EditorCommand
 from .editor_model import EditorModelCommand
+from .exclude_skill import ExcludeSkillCommand
 from .exit import ExitCommand
 from .git import GitCommand
 from .hashline import HashlineCommand
 from .help import HelpCommand
 from .history_search import HistorySearchCommand
 from .hooks import HooksCommand
+from .include_skill import IncludeSkillCommand
 from .lint import LintCommand
 from .list_sessions import ListSessionsCommand
+from .list_skills import ListSkillsCommand
 from .load import LoadCommand
 from .load_hook import LoadHookCommand
 from .load_mcp import LoadMcpCommand
@@ -102,14 +105,17 @@ CommandRegistry.register(DropCommand)
 CommandRegistry.register(EditCommand)
 CommandRegistry.register(EditorCommand)
 CommandRegistry.register(EditorModelCommand)
+CommandRegistry.register(ExcludeSkillCommand)
 CommandRegistry.register(ExitCommand)
 CommandRegistry.register(GitCommand)
 CommandRegistry.register(HashlineCommand)
 CommandRegistry.register(HelpCommand)
 CommandRegistry.register(HistorySearchCommand)
 CommandRegistry.register(HooksCommand)
+CommandRegistry.register(IncludeSkillCommand)
 CommandRegistry.register(LintCommand)
 CommandRegistry.register(ListSessionsCommand)
+CommandRegistry.register(ListSkillsCommand)
 CommandRegistry.register(LoadCommand)
 CommandRegistry.register(LoadHookCommand)
 CommandRegistry.register(LoadMcpCommand)
@@ -172,6 +178,7 @@ __all__ = [
     "EditCommand",
     "EditorCommand",
     "EditorModelCommand",
+    "ExcludeSkillCommand",
     "ExitCommand",
     "expand_subdir",
     "format_command_result",
@@ -182,8 +189,10 @@ __all__ = [
     "HelpCommand",
     "HistorySearchCommand",
     "HookCommand",
+    "IncludeSkillCommand",
     "LintCommand",
     "ListSessionsCommand",
+    "ListSkillsCommand",
     "LoadCommand",
     "LoadHookCommand",
     "LoadMcpCommand",

cecli_dev-0.99.10/cecli/commands/exclude_skill.py

@@ -0,0 +1,72 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class ExcludeSkillCommand(BaseCommand):
+    NORM_NAME = "exclude-skill"
+    DESCRIPTION = "Exclude a skill by name (agent mode only)"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the exclude-skill command with given parameters."""
+        if not args.strip():
+            io.tool_output("Usage: /exclude-skill <skill-name>")
+            return format_command_result(io, "exclude-skill", "Usage: /exclude-skill <skill-name>")
+
+        skill_names = args.strip().split()
+
+        # Check if we're in agent mode
+        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+            io.tool_output("Skill exclusion is only available in agent mode.")
+            return format_command_result(
+                io, "exclude-skill", "Skill exclusion is only available in agent mode"
+            )
+
+        # Check if skills_manager is available
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            io.tool_output("Skills manager is not initialized. Skills may not be configured.")
+            # Check if skills directories are configured
+            if hasattr(coder, "skills_directory_paths") and not coder.skills_directory_paths:
+                io.tool_output(
+                    "No skills directories configured. Use --skills-paths to configure skill"
+                    " directories."
+                )
+            return format_command_result(io, "exclude-skill", "Skills manager is not initialized")
+
+        results = []
+        for skill_name in skill_names:
+            # Use the instance method on skills_manager
+            result = coder.skills_manager.exclude_skill(skill_name)
+            results.append(result)
+
+        return format_command_result(io, "exclude-skill", "\n".join(results))
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for exclude-skill command."""
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            return []
+
+        try:
+            skills = coder.skills_manager.find_skills()
+            return [skill.name for skill in skills]
+        except Exception:
+            return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the exclude-skill command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /exclude-skill <skill-name>...  # Exclude one or more skills by name\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /exclude-skill pdf  # Exclude (blacklist) the PDF skill\n"
+        help_text += "  /exclude-skill web pdf  # Exclude both web and PDF skills\n"
+        help_text += (
+            "\nThis command excludes one or more skills by name, adding them to the blacklist. "
+            "Skills are only available in agent mode.\n"
+        )
+        help_text += "Excluded skills will be hidden from discovery and unavailable for loading.\n"
+        return help_text

cecli_dev-0.99.10/cecli/commands/include_skill.py

@@ -0,0 +1,72 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class IncludeSkillCommand(BaseCommand):
+    NORM_NAME = "include-skill"
+    DESCRIPTION = "Include a skill by name (agent mode only)"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the include-skill command with given parameters."""
+        if not args.strip():
+            io.tool_output("Usage: /include-skill <skill-name>")
+            return format_command_result(io, "include-skill", "Usage: /include-skill <skill-name>")
+
+        skill_names = args.strip().split()
+
+        # Check if we're in agent mode
+        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+            io.tool_output("Skill inclusion is only available in agent mode.")
+            return format_command_result(
+                io, "include-skill", "Skill inclusion is only available in agent mode"
+            )
+
+        # Check if skills_manager is available
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            io.tool_output("Skills manager is not initialized. Skills may not be configured.")
+            # Check if skills directories are configured
+            if hasattr(coder, "skills_directory_paths") and not coder.skills_directory_paths:
+                io.tool_output(
+                    "No skills directories configured. Use --skills-paths to configure skill"
+                    " directories."
+                )
+            return format_command_result(io, "include-skill", "Skills manager is not initialized")
+
+        results = []
+        for skill_name in skill_names:
+            # Use the instance method on skills_manager
+            result = coder.skills_manager.include_skill(skill_name)
+            results.append(result)
+
+        return format_command_result(io, "include-skill", "\n".join(results))
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for include-skill command."""
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            return []
+
+        try:
+            skills = coder.skills_manager.find_skills()
+            return [skill.name for skill in skills]
+        except Exception:
+            return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the include-skill command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /include-skill <skill-name>...  # Include one or more skills by name\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /include-skill pdf  # Include (whitelist) the PDF skill\n"
+        help_text += "  /include-skill web pdf  # Include both web and PDF skills\n"
+        help_text += (
+            "\nThis command includes one or more skills by name, adding them to the whitelist. "
+            "Skills are only available in agent mode.\n"
+        )
+        help_text += "When a skill is included, only whitelisted skills will be discoverable.\n"
+        return help_text