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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc1
+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.5.0rc1 → 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.5.0rc1'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc1')
+__version__ = version = '1.5.0rc2'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc2')
 
-__commit_id__ = commit_id = 'gf0337a57c'
+__commit_id__ = commit_id = 'g12134c928'

{cecli_dev-1.5.0rc1 → 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.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.5.0rc1 → cecli_dev-1.5.0rc2}/cecli/tui/__init__.py

@@ -74,8 +74,10 @@ async def launch_tui(coder, output_queue, input_queue, args):
     Returns:
         Exit code from TUI
     """
-    # Pin tqdm's class lock before the TUI captures stdout/stderr (see _pin_tqdm_lock).
+    # Prepare tqdm and multiprocessing before the TUI captures stdout/stderr
+    # (fileno() == -1), so later subprocesses can still spawn (see helpers below).
     _pin_tqdm_lock()
+    _pre_start_resource_tracker()
 
     worker = None
     return_code = 0
@@ -122,3 +124,21 @@ def _pin_tqdm_lock():
         tqdm.std.tqdm.set_lock(threading.RLock())
     except Exception:
         pass
+
+
+def _pre_start_resource_tracker():
+    """Start multiprocessing's resource tracker before the TUI captures stdout/stderr.
+
+    The Textual TUI replaces ``sys.stdout``/``sys.stderr`` with capture streams whose
+    ``fileno()`` returns ``-1``. ``multiprocessing`` launches a resource tracker
+    subprocess through those fds, so starting it after the swap makes ``spawnv_passfds``
+    raise ``"ValueError: bad value(s) in fds_to_keep"``. Starting it while the real fds
+    are still present lets forked workers (e.g. the ``ProcessPoolExecutor`` behind /voice)
+    register locks and semaphores without re-launching the tracker.
+    """
+    try:
+        import multiprocessing.resource_tracker as resource_tracker
+
+        resource_tracker.ensure_running()
+    except Exception:
+        pass

{cecli_dev-1.5.0rc1 → cecli_dev-1.5.0rc2}/cecli/tui/app.py

@@ -192,6 +192,13 @@ class TUI(App):
             self._encode_keys(self.get_keys_for("quit")), "quit", description="Quit", show=True
         )
 
+        self.bind(
+            self._encode_keys(self.get_keys_for("voice")),
+            "start_voice",
+            description="Record Voice",
+            show=True,
+        )
+
         self.register_theme(BASE_THEME)
         self.theme = "cecli"
 
@@ -272,7 +279,8 @@ class TUI(App):
             "prev_agent": "alt+ctrl+left",
             "main_agent": "alt+ctrl+up",
             "editor": "ctrl+o",
-            "history": "ctrl+r",
+            "history": "alt+shift+h",
+            "voice": "ctrl+r",
             "focus": "ctrl+f",
             "cancel": "ctrl+c",
             "clear": "ctrl+l",
@@ -1215,6 +1223,36 @@ class TUI(App):
         input_area = self.query_one("#input", InputArea)
         input_area.post_message(input_area.Submit("/history-search"))
 
+    def action_start_voice(self):
+        """Start voice recording via the /voice command (keyboard shortcut)."""
+        from cecli.helpers.agents.service import AgentService
+
+        coder = self.worker.coder
+        foreground_coder = AgentService.get_instance(coder).foreground_coder
+        coder_uuid = (
+            str(foreground_coder.uuid)
+            if foreground_coder and hasattr(foreground_coder, "uuid")
+            else None
+        )
+        agent_name = self._resolve_agent_name(coder_uuid)
+
+        # Surface the recording state in the footer spinner (the /voice
+        # command updates it as it runs).
+        footer = self.query_one(MainFooter)
+        footer.start_spinner("Recording...", agent_name=agent_name or "")
+
+        if coder:
+            coder.io.start_spinner("Recording...", coder_uuid=coder_uuid)
+
+        # Forward "/voice" to the coder via the normal agent-loop queue so it
+        # is dispatched as a command, without echoing it or saving it to
+        # history.
+        if coder_uuid and coder_uuid in queues._per_coder_queues:
+            queues.push_coder_input(coder_uuid, {"text": "/voice", "coder_uuid": coder_uuid})
+        else:
+            self.input_queue.put({"text": "/voice", "coder_uuid": coder_uuid})
+            queues.wake_input_waiters()
+
     def action_open_editor(self):
         """Open an external editor to compose a prompt (keyboard shortcut)."""
         # Get current input text to use as initial content

{cecli_dev-1.5.0rc1 → cecli_dev-1.5.0rc2}/cecli/tui/widgets/input_area.py

@@ -239,6 +239,25 @@ class InputArea(TextArea):
         if self.disabled:
             return
 
+        # Route hotkey bindings directly and stop TextArea from inserting a
+        # printable character (e.g. alt+shift+h would otherwise type an "h").
+        if self.app.is_key_for("voice", event.key):
+            event.stop()
+            event.prevent_default()
+            self.app.action_start_voice()
+            return
+
+        if self.app.is_key_for("history", event.key):
+            event.stop()
+            event.prevent_default()
+            self.app.action_history_search()
+            return
+
+        # Reserve any other alt+shift combination for hotkeys (no character input).
+        if event.key and "alt+shift" in event.key:
+            event.stop()
+            event.prevent_default()
+            return
         # Reset cycling if not a cycle command
         is_cycle = self.app.is_key_for("cycle_forward", event.key) or self.app.is_key_for(
             "cycle_backward", event.key