V1.5.0

cecli/__init__.py

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

cecli/args.py

@@ -578,6 +578,18 @@ def get_parser(default_config_files, git_root):
         help="Number of times to ping at 5min intervals to keep prompt cache warm (default: 0)",
     )
 
+    ##########
+    group = parser.add_argument_group("Rate limiting")
+    group.add_argument(
+        "--tokens-per-minute",
+        type=int,
+        default=1000000,
+        help=(
+            "Set the maximum tokens sent per minute before rate limiting sleeps are"
+            " inserted before LLM API calls (default: 1000000, use 0 to disable)"
+        ),
+    )
+
     ##########
     group = parser.add_argument_group("Repomap settings")
     group.add_argument(
@@ -1062,8 +1074,11 @@ def get_parser(default_config_files, git_root):
     group.add_argument(
         "--voice-language",
         metavar="VOICE_LANGUAGE",
-        default="en",
-        help="Specify the language for voice using ISO 639-1 code (default: auto)",
+        default=None,
+        help=(
+            "Specify the language for voice using ISO 639-1 code "
+            "(default: resolve from the voice setting, then chat language)"
+        ),
     )
     group.add_argument(
         "--voice-input-device",

cecli/commands/__init__.py

@@ -37,7 +37,9 @@
 from .history_search import HistorySearchCommand
 from .hooks import HooksCommand
 from .hot_reload import HotReloadCommand
+from .import_skill import ImportSkillCommand
 from .include_skill import IncludeSkillCommand
+from .insert_queue import InsertQueueCommand
 from .lint import LintCommand
 from .list_mcp import ListMcpCommand
 from .list_queue import ListQueueCommand
@@ -130,10 +132,9 @@
 CommandRegistry.register(HistorySearchCommand)
 CommandRegistry.register(HooksCommand)
 CommandRegistry.register(HotReloadCommand)
-CommandRegistry.register(ReapAgentCommand)
-CommandRegistry.register(SpawnAgentCommand)
-CommandRegistry.register(SwitchAgentCommand)
+CommandRegistry.register(ImportSkillCommand)
 CommandRegistry.register(IncludeSkillCommand)
+CommandRegistry.register(InsertQueueCommand)
 CommandRegistry.register(LintCommand)
 CommandRegistry.register(ListMcpCommand)
 CommandRegistry.register(ListQueueCommand)
@@ -156,6 +157,7 @@
 CommandRegistry.register(QuitCommand)
 CommandRegistry.register(ReadOnlyCommand)
 CommandRegistry.register(ReadOnlyStubCommand)
+CommandRegistry.register(ReapAgentCommand)
 CommandRegistry.register(ReasoningEffortCommand)
 CommandRegistry.register(RemoveHookCommand)
 CommandRegistry.register(RemoveMcpCommand)
@@ -170,6 +172,8 @@
 CommandRegistry.register(SaveSessionCommand)
 CommandRegistry.register(SearchMemoryCommand)
 CommandRegistry.register(SettingsCommand)
+CommandRegistry.register(SpawnAgentCommand)
+CommandRegistry.register(SwitchAgentCommand)
 CommandRegistry.register(TerminalSetupCommand)
 CommandRegistry.register(TestCommand)
 CommandRegistry.register(ThinkTokensCommand)
@@ -220,17 +224,17 @@
     "HistorySearchCommand",
     "HooksCommand",
     "HotReloadCommand",
+    "ImportSkillCommand",
     "IncludeSkillCommand",
-    "ReapAgentCommand",
-    "SpawnAgentCommand",
-    "SwitchAgentCommand",
+    "InsertQueueCommand",
     "LintCommand",
+    "ListMcpCommand",
+    "ListQueueCommand",
     "ListSessionsCommand",
     "ListSkillsCommand",
     "LoadCommand",
     "LoadHookCommand",
     "LoadMcpCommand",
-    "ListMcpCommand",
     "LoadSessionCommand",
     "LoadSkillCommand",
     "LsCommand",
@@ -242,11 +246,12 @@
     "MultilineModeCommand",
     "parse_quoted_filenames",
     "PasteCommand",
-    "quote_filename",
     "QueueCommand",
     "QuitCommand",
+    "quote_filename",
     "ReadOnlyCommand",
     "ReadOnlyStubCommand",
+    "ReapAgentCommand",
     "ReasoningEffortCommand",
     "ReloadProgramSignal",
     "RemoveHookCommand",
@@ -262,6 +267,8 @@
     "SaveSessionCommand",
     "SearchMemoryCommand",
     "SettingsCommand",
+    "SpawnAgentCommand",
+    "SwitchAgentCommand",
     "SwitchCoderSignal",
     "TerminalSetupCommand",
     "TestCommand",

cecli/commands/core.py

@@ -107,6 +107,12 @@ def prompt_queue(self):
         coder = self.coder
         return coder.prompt_queue if coder is not None else []
 
+    def _insert_prompt(self, text: str, index: int) -> dict:
+        """Insert a prompt at the given index in the active coder's queue."""
+        from cecli.helpers import command_queue
+
+        return command_queue.insert_prompt(self._active_coder(), text, index)
+
     def _enqueue_prompt(self, text: str) -> dict:
         """Add a prompt to the owning coder's queue."""
         from cecli.helpers import command_queue

cecli/commands/import_skill.py

@@ -0,0 +1,95 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class ImportSkillCommand(BaseCommand):
+    NORM_NAME = "import-skill"
+    DESCRIPTION = "Import a skill from the community registry or skills.sh (agent mode only)"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the import-skill command with given parameters."""
+        tokens = args.strip().split()
+        global_install = "--global" in tokens or "-g" in tokens
+        tokens = [token for token in tokens if token not in ("--global", "-g")]
+
+        if not tokens:
+            io.tool_output("Usage: /import-skill [--global] <skill-name>")
+            return format_command_result(
+                io, "import-skill", "Usage: /import-skill [--global] <skill-name>"
+            )
+
+        skill_name = " ".join(tokens)
+
+        # Importing (and including) skills is only available in agent mode.
+        if not hasattr(coder, "edit_format") or coder.edit_format not in ("agent", "subagent"):
+            io.tool_output("Skill import is only available in agent mode.")
+            return format_command_result(
+                io, "import-skill", "Skill import is only available in agent mode"
+            )
+
+        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.")
+            return format_command_result(io, "import-skill", "Skills manager is not initialized")
+
+        from cecli.helpers.extensions.skills_importer import (
+            add_skill_to_config,
+            install_skill,
+        )
+
+        root = getattr(coder, "primary_root", None) or getattr(coder, "root", None)
+        result = install_skill(skill_name, global_install=global_install, root=root)
+
+        if not result["ok"]:
+            io.tool_output(result["message"])
+            return format_command_result(io, "import-skill", result["message"])
+
+        imported_name = result["name"]
+        include_result = coder.skills_manager.include_skill(imported_name)
+        config_result = add_skill_to_config(imported_name, root=root)
+
+        message = (
+            f"Imported skill '{imported_name}' from {result['source']} to {result['dest']}.\n\n"
+            f"{include_result}\n\n"
+            f"{config_result}"
+        )
+
+        return format_command_result(io, "import-skill", message)
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for import-skill command."""
+        candidates = ["--global"]
+
+        try:
+            from cecli.helpers.extensions.skills_importer import get_registry_skills
+
+            candidates.extend(get_registry_skills())
+        except Exception:
+            pass
+
+        return candidates
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the import-skill command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += (
+            "  /import-skill <skill-name>  # Import a skill into the project .cecli/skills\n"
+        )
+        help_text += (
+            "  /import-skill --global <skill-name>  # Import a skill into ~/.cecli/skills\n"
+        )
+        help_text += "\nExamples:\n"
+        help_text += (
+            "  /import-skill files/docx  # Import the docx skill from the community registry\n"
+        )
+        help_text += "  /import-skill --global pdf  # Import the PDF skill globally\n"
+        help_text += (
+            "\nSkills are looked up in the cecli community registry first, then on skills.sh.\n"
+        )
+        help_text += "The imported skill is added to the current session like /include-skill.\n"
+        return help_text

cecli/commands/insert_queue.py

@@ -0,0 +1,86 @@
+"""Insert-queue command for CLI-33: inserts a prompt at a specific queue position."""
+
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class InsertQueueCommand(BaseCommand):
+    NORM_NAME = "insert-queue"
+    DESCRIPTION = "Insert a prompt into the queue at a specific position"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the insert-queue command with given parameters.
+
+        Args:
+            io: InputOutput instance
+            coder: Coder instance (may be None for some commands)
+            args: Command arguments as string ("<index> <prompt text>")
+            **kwargs: Additional context
+
+        Returns:
+            Formatted result string
+        """
+        # Sad path: coder.commands is None
+        if not coder.commands:
+            return format_command_result(
+                io,
+                cls.NORM_NAME,
+                "",
+                error="Command system not available. Cannot insert into queue.",
+            )
+
+        # Sad path: missing index or prompt text
+        parts = (args or "").strip().split(maxsplit=1)
+        if len(parts) != 2:
+            return format_command_result(
+                io,
+                cls.NORM_NAME,
+                "",
+                error="Usage: /insert-queue <index> <prompt text>",
+            )
+
+        # Sad path: non-integer index
+        try:
+            index = int(parts[0])
+        except ValueError:
+            return format_command_result(
+                io,
+                cls.NORM_NAME,
+                "",
+                error=f"Invalid index: '{parts[0]}'. Please provide a number.",
+            )
+
+        prompt_text = parts[1].strip()
+
+        # Happy path: insert the prompt
+        try:
+            item = coder.commands._insert_prompt(prompt_text, index)
+            io.tool_output(f"Prompt inserted at position {index + 1} (id: {item['id']})")
+            return f"Successfully executed {cls.NORM_NAME}."
+        except ValueError as e:
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
+        except RuntimeError as e:
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for insert-queue command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the insert-queue command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /insert-queue <index> <prompt text>  # Insert at a specific position\n"
+        help_text += "\nDescription:\n"
+        help_text += "  Inserts a prompt into the queue at the given 1-based position.\n"
+        help_text += "  Existing items shift down. Index is clamped to the queue bounds.\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /insert-queue 1 Review the changes in src/main.py\n"
+        help_text += "  /insert-queue 3 Write unit tests for the new feature\n"
+        help_text += "\nSee also: /queue, /list-queue, /remove-queue\n"
+        return help_text

cecli/commands/list_queue.py

@@ -27,7 +27,7 @@ async def execute(cls, io, coder, args, **kwargs):
         # Sad path: coder.commands is None
         if not coder.commands:
             return format_command_result(
-                io, cls.NORM_NAME, error="Command system not available. Cannot list queue."
+                io, cls.NORM_NAME, "", error="Command system not available. Cannot list queue."
             )
 
         queue = coder.commands.prompt_queue

cecli/commands/queue.py

@@ -26,16 +26,19 @@ async def execute(cls, io, coder, args, **kwargs):
         # Sad path: coder.commands is None
         if not coder.commands:
             return format_command_result(
-                io, cls.NORM_NAME, error="Command system not available. Cannot queue prompts."
+                io, cls.NORM_NAME, "", error="Command system not available. Cannot queue prompts."
             )
 
         # Sad path: no args (empty prompt text)
         if not args or not args.strip():
             return format_command_result(
                 io,
                 cls.NORM_NAME,
-                "Usage: /queue <prompt text>\n"
-                "Add a prompt to the queue for processing after current tasks complete.",
+                "",
+                error=(
+                    "Usage: /queue <prompt text> - Add a prompt to the queue "
+                    "for processing after current tasks complete."
+                ),
             )
 
         prompt_text = args.strip()
@@ -45,6 +48,7 @@ async def execute(cls, io, coder, args, **kwargs):
             return format_command_result(
                 io,
                 cls.NORM_NAME,
+                "",
                 error=f"Prompt exceeds maximum length of 10000 characters "
                 f"(got {len(prompt_text)}).",
             )
@@ -56,9 +60,9 @@ async def execute(cls, io, coder, args, **kwargs):
             io.tool_output(f"Prompt queued at position {position} (id: {item['id']})")
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:
-            return format_command_result(io, cls.NORM_NAME, error=str(e))
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
         except RuntimeError as e:
-            return format_command_result(io, cls.NORM_NAME, error=str(e))
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]: