cecli-dev 1.4.1rc2__tar.gz → 1.5.0rc2__tar.gz

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.4.1rc2
+Version: 1.5.0rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -49,6 +49,7 @@ Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pydub>=0.25.1
 Requires-Dist: sounddevice>=0.5.2
 Requires-Dist: soundfile>=0.13.1
+Requires-Dist: moonshine-voice>=0.1.5
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: prompt_toolkit
 Requires-Dist: rich>=14.1.0

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/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_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.4.1rc2'
-__version_tuple__ = version_tuple = (1, 4, 1, 'rc2')
+__version__ = version = '1.5.0rc2'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc2')
 
-__commit_id__ = commit_id = 'g7e601aafa'
+__commit_id__ = commit_id = 'g12134c928'

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/args.py

@@ -1062,8 +1062,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_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/coders/agent_coder.py

@@ -463,7 +463,6 @@ class AgentCoder(Coder):
                 "skills",
                 "servers",
                 "sub_agents",
-                "loaded_skills",
                 "orchestration",
             ]
             for block_type in block_types:
@@ -499,8 +498,6 @@ class AgentCoder(Coder):
             content = self.get_skills_context()
         elif block_name == "servers":
             content = self.get_servers_context()
-        elif block_name == "loaded_skills":
-            content = self.get_skills_content()
         elif block_name == "orchestration":
             content = self.get_orchestration_context()
         elif block_name == "sub_agents" and (
@@ -643,6 +640,10 @@ class AgentCoder(Coder):
         # Add pre-message context blocks (priority 125 - between REPO and READONLY_FILES)
         ConversationService.get_chunks(self).add_pre_message_context_blocks()
 
+        ConversationService.get_chunks(self).add_active_skills_messages(
+            getattr(self, "skills_manager", None)
+        )
+
         ConversationService.get_chunks(self).add_readonly_files_messages()
         ConversationService.get_chunks(self).add_chat_files_messages()
 

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/coders/base_coder.py

@@ -2919,6 +2919,17 @@ class Coder(metaclass=UsageMeta):
 
         edited = await self.apply_updates()
 
+        # Run tests before committing so failing tests abort the commit and
+        # reflect the errors back for the model to fix first.
+        if edited and self.auto_test and self.test_cmd:
+            test_errors = await self.commands.execute("test", self.test_cmd)
+            self.test_outcome = not test_errors
+            if test_errors:
+                ok = await self.io.confirm_ask("Attempt to fix test errors?")
+                if ok:
+                    self.reflected_message = test_errors
+                    return
+
         if edited:
             self.coder_edited_files.update(edited)
             saved_message = await self.auto_commit(edited)
@@ -2991,15 +3002,6 @@ class Coder(metaclass=UsageMeta):
                 mark_for_demotion=1,
             )
 
-        if edited and self.auto_test and self.test_cmd:
-            test_errors = await self.commands.execute("test", self.test_cmd)
-            self.test_outcome = not test_errors
-            if test_errors:
-                ok = await self.io.confirm_ask("Attempt to fix test errors?")
-                if ok:
-                    self.reflected_message = test_errors
-                    return
-
         # Turn complete: drop the per-turn LLM stream buffers.  They are reset at
         # the start of the next send(), so holding on to them while idle only
         # wastes memory (chunks can be large for long streaming responses).

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/commands/__init__.py

@@ -37,6 +37,7 @@ from .help import HelpCommand
 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 .lint import LintCommand
 from .list_mcp import ListMcpCommand
@@ -134,6 +135,7 @@ CommandRegistry.register(ReapAgentCommand)
 CommandRegistry.register(SpawnAgentCommand)
 CommandRegistry.register(SwitchAgentCommand)
 CommandRegistry.register(IncludeSkillCommand)
+CommandRegistry.register(ImportSkillCommand)
 CommandRegistry.register(LintCommand)
 CommandRegistry.register(ListMcpCommand)
 CommandRegistry.register(ListQueueCommand)
@@ -221,6 +223,7 @@ __all__ = [
     "HooksCommand",
     "HotReloadCommand",
     "IncludeSkillCommand",
+    "ImportSkillCommand",
     "ReapAgentCommand",
     "SpawnAgentCommand",
     "SwitchAgentCommand",

cecli_dev-1.5.0rc2/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_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/commands/run.py

@@ -85,7 +85,7 @@ class RunCommand(BaseCommand):
                 io.placeholder = "What's wrong? Fix"
 
         if add_on_nonzero_exit and not exit_status:
-            return ""  # No test failures
+            return "Test command ran by user. All tests passed."  # No test failures
 
         # Return None if output wasn't added or command succeeded
         return format_command_result(io, "run", "Command executed successfully")

cecli_dev-1.5.0rc2/cecli/commands/voice.py

@@ -0,0 +1,121 @@
+from typing import List
+
+import cecli.voice as voice
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class VoiceCommand(BaseCommand):
+    NORM_NAME = "voice"
+    DESCRIPTION = "Record and transcribe voice input"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the voice command with given parameters."""
+        # Get voice parameters from kwargs or coder.
+        voice_language = kwargs.get("voice_language") or getattr(coder, "voice_language", None)
+        voice_format = kwargs.get("voice_format") or getattr(coder, "voice_format", None)
+        voice_input_device = kwargs.get("voice_input_device") or getattr(
+            coder, "voice_input_device", None
+        )
+
+        # Resolve the Moonshine model language: an explicit voice-language
+        # setting, then the detected user/chat language, finally English.
+        detected_language = None
+        get_user_language = getattr(coder, "get_user_language", None)
+        if get_user_language:
+            detected_language = get_user_language()
+
+        resolved_language = voice.resolve_moonshine_language(voice_language, detected_language)
+
+        # Get voice instance from kwargs or create new one.
+        voice_instance = kwargs.get("voice_instance")
+
+        if not voice_instance:
+            try:
+                import moonshine_voice  # noqa: F401
+            except ImportError:
+                io.tool_error(
+                    "To use /voice you must install `moonshine-voice` (pip install moonshine-voice)."
+                )
+                return format_command_result(io, "voice", "moonshine-voice not installed")
+
+            try:
+                voice_instance = voice.Voice(
+                    audio_format=voice_format or "wav", device_name=voice_input_device
+                )
+            except voice.SoundDeviceError:
+                io.tool_error(
+                    "Unable to import `sounddevice` and/or `soundfile`, is portaudio installed?"
+                )
+                return format_command_result(io, "voice", "Sound device error")
+
+        def on_text(partial):
+            # Stream partial transcripts into the input field as they are generated.
+            if coder.tui and coder.tui():
+                coder.tui().set_input_value(partial)
+                coder.tui().refresh()
+            else:
+                io.placeholder = partial
+
+        def on_status(message):
+            # Surface worker status messages (recording/transcribing) in the TUI.
+            if coder.tui and coder.tui():
+                if "Recording..." in str(message) or "Transcribing..." in str(message):
+                    io.update_spinner((message or "").strip())
+                else:
+                    io.tool_output((message or "").strip())
+            else:
+                io.tool_output(message or "")
+
+        stop_binding = None
+        if coder.tui and coder.tui():
+            try:
+                stop_binding = coder.tui().get_keys_for("submit")
+            except Exception:
+                stop_binding = None
+
+        try:
+            io.update_spinner("Recording...")
+            text = await voice_instance.record_and_transcribe(
+                None,
+                language=resolved_language,
+                on_text=on_text,
+                on_status=on_status,
+                stop_binding=stop_binding,
+            )
+        except Exception as err:
+            io.tool_error(f"Unable to transcribe: {err}")
+            return format_command_result(io, "voice", f"Transcription error: {err}")
+
+        if text:
+            io.placeholder = text
+
+            if coder.tui and coder.tui():
+                coder.tui().set_input_value(text)
+                coder.tui().refresh()
+                return ""  # For the TUI the result is already in the input field!
+
+        return format_command_result(io, "voice", "Voice recorded and transcribed")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for voice command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the voice command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /voice  # Record and transcribe voice input\n"
+        help_text += (
+            "\nThis command records audio from your microphone and transcribes it on-device"
+            " using the Moonshine on-device model. The language is resolved from your"
+            " /voice-language setting, falling back to your chat language, then English.\n"
+        )
+        help_text += "Requirements:\n"
+        help_text += "  - moonshine-voice, sounddevice, and soundfile Python packages\n"
+        help_text += "  - PortAudio library installed (for sounddevice)\n"
+        help_text += "\nThe transcribed text will be placed in the input prompt for editing.\n"
+        return help_text

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/helpers/conversation/integration.py

@@ -853,8 +853,7 @@ class ConversationChunks:
         """
         Add pre-message context blocks to conversation (priority 125).
 
-        Pre-message blocks include: symbol_outline, git_status, todo_list,
-        loaded_skills, context_summary
+        Pre-message blocks include: symbol_outline, git_status, todo_list, context_summary
         """
         coder = self.get_coder()
         if not coder:
@@ -878,10 +877,6 @@ class ConversationChunks:
                 block = coder.get_cached_context_block("git_status")
                 if block:
                     message_blocks["git_status"] = block
-            if "skills" in coder.allowed_context_blocks:
-                block = coder._generate_context_block("loaded_skills")
-                if block:
-                    message_blocks["loaded_skills"] = block
 
         # Process other blocks
         for block_type, block_content in message_blocks.items():
@@ -893,6 +888,58 @@ class ConversationChunks:
                 force=True,
             )
 
+    def add_active_skills_messages(self, skills_manager) -> None:
+        """Add a distinct message per active (loaded) skill.
+
+        Unlike the prior single ``loaded_skills`` context block, this emits one
+        message per loaded skill so the model can see each skill's content in
+        isolation. Replacement is driven by a stable per-skill hash key, and any
+        message for a skill that is no longer loaded is pruned.
+
+        Args:
+            skills_manager: The SkillsManager instance from which to source
+                active skills.
+        """
+        coder = self.get_coder()
+        if not coder:
+            return
+
+        if not skills_manager:
+            return
+
+        if not hasattr(coder, "use_enhanced_context") or not coder.use_enhanced_context:
+            return
+
+        loaded_skills = getattr(skills_manager, "_loaded_skills", set())
+
+        # Prune messages for skills that are no longer loaded.
+        def is_stale_skill(hash_key) -> bool:
+            if not hash_key or hash_key[0] != "active_skill":
+                return False
+            return hash_key[1] not in loaded_skills
+
+        ConversationService.get_manager(coder).remove_messages_by_hash_key_pattern(is_stale_skill)
+
+        if not loaded_skills:
+            return
+
+        for skill_name in sorted(loaded_skills):
+            skill_content = skills_manager.get_skill_content(skill_name)
+            if not skill_content:
+                continue
+
+            block = skills_manager.format_active_skill_message(skill_content)
+            if not block:
+                continue
+
+            ConversationService.get_manager(coder).add_message(
+                message_dict={"role": "user", "content": block},
+                tag=MessageTag.ACTIVE_SKILLS,
+                hash_key=("active_skill", skill_name),
+                force=True,
+                update_timestamp=False,
+            )
+
     def add_post_message_context_blocks(self) -> None:
         """
         Add post-message context blocks to conversation (priority 250).

{cecli_dev-1.4.1rc2 → cecli_dev-1.5.0rc2}/cecli/helpers/conversation/tags.py

@@ -21,6 +21,7 @@ class MessageTag(str, Enum):
     DIFFS = "diffs"
     LINT = "lint"
     FILE_CONTEXTS = "file_contexts"
+    ACTIVE_SKILLS = "active_skills"
     CUR = "cur"
     DONE = "done"
     REMINDER = "reminder"
@@ -42,6 +43,7 @@ DEFAULT_TAG_PRIORITY: Dict[MessageTag, int] = {
     MessageTag.FILE_CONTEXTS: 200,
     MessageTag.DONE: 200,
     MessageTag.CUR: 200,
+    MessageTag.ACTIVE_SKILLS: 200,
     MessageTag.REMINDER: 300,
 }
 
@@ -62,6 +64,7 @@ DEFAULT_TAG_TIMESTAMP_OFFSET: Dict[MessageTag, int] = {
     MessageTag.FILE_CONTEXTS: 0,
     MessageTag.DONE: 0,
     MessageTag.CUR: 0,
+    MessageTag.ACTIVE_SKILLS: 0,
     MessageTag.REMINDER: 0,
 }
 

cecli_dev-1.5.0rc2/cecli/helpers/extensions/__init__.py

@@ -0,0 +1 @@
+"""Skill ecosystem extensions package."""