agent-cli 0.98.5__tar.gz → 0.100.0__tar.gz

{agent_cli-0.98.5 → agent_cli-0.100.0}/.github/workflows/pytest.yml

@@ -43,6 +43,6 @@ jobs:
         run: uv run --extra audio --extra diarization --extra llm --extra rag --extra memory --extra vad --extra faster-whisper --extra piper --extra kokoro --extra server --extra speed --extra test pytest -vvv
       - name: Upload coverage reports to Codecov
         if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
-        uses: codecov/codecov-action@v6.0.1
+        uses: codecov/codecov-action@v7.0.0
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{agent_cli-0.98.5 → agent_cli-0.100.0}/.pre-commit-config.yaml

@@ -11,7 +11,7 @@ repos:
       - id: end-of-file-fixer
       - id: mixed-line-ending
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.15.15"
+    rev: "v0.15.16"
     hooks:
       - id: ruff
         args: ["--fix"]

{agent_cli-0.98.5 → agent_cli-0.100.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.98.5
+Version: 0.100.0
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>
@@ -1031,6 +1031,21 @@ the `[defaults]` section of your configuration file.
 │                                                                  provide context for   │
 │                                                                  LLM cleanup.          │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Live Preview ─────────────────────────────────────────────────────────────────────────╮
+│ --live-preview-log                          PATH   Write rolling live transcription    │
+│                                                    preview events to JSONL while       │
+│                                                    recording.                          │
+│ --live-preview-interval                     FLOAT  Seconds between live preview        │
+│                                                    retranscriptions.                   │
+│                                                    [default: 2.0]                      │
+│ --live-preview-window                       FLOAT  Seconds of recent audio to include  │
+│                                                    in each live preview                │
+│                                                    retranscription.                    │
+│                                                    [default: 15.0]                     │
+│ --live-preview-console,--live-previ…               Print rolling live transcription    │
+│                                                    preview updates to the terminal     │
+│                                                    while recording.                    │
+╰────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Diarization ──────────────────────────────────────────────────────────────────────────╮
 │ --diarize               --no-diarize                               Enable speaker      │
 │                                                                    diarization         │

{agent_cli-0.98.5 → agent_cli-0.100.0}/README.md

@@ -923,6 +923,21 @@ the `[defaults]` section of your configuration file.
 │                                                                  provide context for   │
 │                                                                  LLM cleanup.          │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Live Preview ─────────────────────────────────────────────────────────────────────────╮
+│ --live-preview-log                          PATH   Write rolling live transcription    │
+│                                                    preview events to JSONL while       │
+│                                                    recording.                          │
+│ --live-preview-interval                     FLOAT  Seconds between live preview        │
+│                                                    retranscriptions.                   │
+│                                                    [default: 2.0]                      │
+│ --live-preview-window                       FLOAT  Seconds of recent audio to include  │
+│                                                    in each live preview                │
+│                                                    retranscription.                    │
+│                                                    [default: 15.0]                     │
+│ --live-preview-console,--live-previ…               Print rolling live transcription    │
+│                                                    preview updates to the terminal     │
+│                                                    while recording.                    │
+╰────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Diarization ──────────────────────────────────────────────────────────────────────────╮
 │ --diarize               --no-diarize                               Enable speaker      │
 │                                                                    diarization         │

{agent_cli-0.98.5 → agent_cli-0.100.0}/agent_cli/agents/transcribe.py

@@ -365,13 +365,20 @@ async def _async_main(  # noqa: PLR0912, PLR0915, C901
     emit_output: bool = True,
     raise_diarization_errors: bool = False,
     audio_level_callback: Callable[[bytes], None] | None = None,
+    live_preview_log: Path | None = None,
+    live_preview_interval: float = 2.0,
+    live_preview_window: float = 15.0,
+    live_preview_console: bool = False,
 ) -> TranscriptResult:
     """Unified async entry point for both live and file-based transcription."""
     start_time = time.monotonic()
     transcript: str | None
     saved_recording_path: Path | None = None
+    live_preview_console_active = (
+        live_preview_console and audio_file_path is None and provider_cfg.asr_provider == "wyoming"
+    )
 
-    with maybe_live(not general_cfg.quiet) as live:
+    with maybe_live(not general_cfg.quiet and not live_preview_console_active) as live:
         if audio_file_path:
             # File-based transcription
             # Determine if we can use native format support (skip PCM conversion)
@@ -447,6 +454,17 @@ async def _async_main(  # noqa: PLR0912, PLR0915, C901
                     openai_asr_cfg,
                     gemini_asr_cfg,
                 )
+                live_preview_config = (
+                    asr.LivePreviewConfig(
+                        log_file=live_preview_log,
+                        interval_seconds=live_preview_interval,
+                        window_seconds=live_preview_window,
+                        console=live_preview_console,
+                    )
+                    if (live_preview_log or live_preview_console)
+                    and provider_cfg.asr_provider == "wyoming"
+                    else None
+                )
                 transcript = await live_transcriber(
                     logger=LOGGER,
                     stop_event=stop_event,
@@ -456,6 +474,7 @@ async def _async_main(  # noqa: PLR0912, PLR0915, C901
                     extra_instructions=extra_instructions,
                     recording_path_callback=_set_saved_recording_path,
                     audio_level_callback=audio_level_callback,
+                    live_preview_config=live_preview_config,
                 )
 
         elapsed = time.monotonic() - start_time
@@ -650,6 +669,10 @@ def transcribe(  # noqa: PLR0912, PLR0911, PLR0915, C901
     print_args: bool = opts.PRINT_ARGS,
     transcription_log: Path | None = opts.TRANSCRIPTION_LOG,
     voice_level_log: Path | None = opts.VOICE_LEVEL_LOG,
+    live_preview_log: Path | None = opts.LIVE_PREVIEW_LOG,
+    live_preview_interval: float = opts.LIVE_PREVIEW_INTERVAL,
+    live_preview_window: float = opts.LIVE_PREVIEW_WINDOW,
+    live_preview_console: bool = opts.LIVE_PREVIEW_CONSOLE,
     # --- Diarization Options ---
     diarize: bool = opts.DIARIZE,
     diarize_format: opts.DiarizeFormat = opts.DIARIZE_FORMAT,
@@ -697,18 +720,24 @@ def transcribe(  # noqa: PLR0912, PLR0911, PLR0915, C901
 
     setup_logging(log_level, log_file, quiet=effective_quiet)
 
+    enroll_speakers = _option_default(enroll_speakers)
+    identify_speakers = _option_default(identify_speakers)
+    remember_unknown_speakers = _option_default(remember_unknown_speakers)
+    speaker_profiles_file = _option_default(speaker_profiles_file)
+    speaker_match_threshold = _option_default(speaker_match_threshold)
+    live_preview_log = _option_default(live_preview_log)
+    live_preview_interval = _option_default(live_preview_interval)
+    live_preview_window = _option_default(live_preview_window)
+    live_preview_console = _option_default(live_preview_console)
+
     # Expand user path for transcription log
     if transcription_log:
         transcription_log = transcription_log.expanduser()
     voice_level_log = _option_default(voice_level_log)
     if voice_level_log:
         voice_level_log = voice_level_log.expanduser()
-
-    enroll_speakers = _option_default(enroll_speakers)
-    identify_speakers = _option_default(identify_speakers)
-    remember_unknown_speakers = _option_default(remember_unknown_speakers)
-    speaker_profiles_file = _option_default(speaker_profiles_file)
-    speaker_match_threshold = _option_default(speaker_match_threshold)
+    if live_preview_log:
+        live_preview_log = live_preview_log.expanduser()
 
     # Validate diarization options
     if not diarize and (enroll_speakers or remember_unknown_speakers):
@@ -850,6 +879,10 @@ def transcribe(  # noqa: PLR0912, PLR0911, PLR0915, C901
                     diarization_cfg=diarization_cfg,
                     emit_output=not json_output,
                     raise_diarization_errors=diarize,
+                    live_preview_log=live_preview_log,
+                    live_preview_interval=live_preview_interval,
+                    live_preview_window=live_preview_window,
+                    live_preview_console=live_preview_console,
                 ),
             )
         except ImportError as exc:
@@ -942,6 +975,10 @@ def transcribe(  # noqa: PLR0912, PLR0911, PLR0915, C901
                     audio_level_callback=audio_level_writer.write_chunk
                     if audio_level_writer
                     else None,
+                    live_preview_log=live_preview_log,
+                    live_preview_interval=live_preview_interval,
+                    live_preview_window=live_preview_window,
+                    live_preview_console=live_preview_console,
                 ),
             )
     except ImportError as exc:

{agent_cli-0.98.5 → agent_cli-0.100.0}/agent_cli/dev/cli.py

@@ -618,11 +618,13 @@ def new(
         summary_lines.append(
             f"[bold]Agent Handle:[/bold] {agent_handle.handle} ({agent_handle.terminal_name})",
         )
-        if agent_handle.session_name:
+        if agent_handle.session_name and agent_handle.terminal_name == "tmux":
             summary_lines.append(f"[bold]tmux Session:[/bold] {agent_handle.session_name}")
             summary_lines.append(
                 f"[bold]Attach:[/bold] tmux attach -t {shlex.quote(agent_handle.session_name)}",
             )
+        elif agent_handle.session_name and agent_handle.terminal_name == "cmux":
+            summary_lines.append(f"[bold]cmux Workspace:[/bold] {agent_handle.session_name}")
 
     console.print()
     console.print(
@@ -1146,7 +1148,7 @@ def start_agent(
                 f"{handle.terminal_name} handle: {handle.handle}"
                 + (
                     f" (attach with: tmux attach -t {shlex.quote(handle.session_name)})"
-                    if handle.session_name
+                    if handle.session_name and handle.terminal_name == "tmux"
                     else ""
                 ),
             )
@@ -1280,7 +1282,7 @@ def list_terminals_cmd(
 ) -> None:
     """List available terminal multiplexers and their status.
 
-    Shows supported terminals: tmux, zellij, kitty, iTerm2, Terminal.app,
+    Shows supported terminals: tmux, zellij, cmux, kitty, iTerm2, Terminal.app,
     Warp, GNOME Terminal.
 
     These are used to open new tabs when launching AI agents with `dev new --start-agent`.

{agent_cli-0.98.5 → agent_cli-0.100.0}/agent_cli/dev/launch.py

@@ -321,6 +321,36 @@ def _launch_in_tmux(
     return handle
 
 
+def _launch_in_cmux(
+    path: Path,
+    agent: CodingAgent,
+    terminal: terminals.Terminal,
+    full_cmd: str,
+    tab_name: str,
+    repo_root: Path | None,
+) -> TerminalHandle | None:
+    """Launch an agent in a cmux tab inside a workspace named after the repo."""
+    from .terminals.cmux import Cmux  # noqa: PLC0415
+
+    if not isinstance(terminal, Cmux):
+        warn("Could not open new tab in cmux")
+        return None
+
+    workspace_name = (repo_root or path).name
+    handle = terminal.open_in_workspace(
+        path,
+        full_cmd,
+        tab_name=tab_name,
+        workspace_name=workspace_name,
+    )
+    if handle is None:
+        warn("Could not open new tab in cmux")
+        return None
+
+    success(f"Started {agent.name} in cmux workspace {workspace_name!r}")
+    return handle
+
+
 def _launch_in_terminal(
     path: Path,
     agent: CodingAgent,
@@ -332,6 +362,10 @@ def _launch_in_terminal(
     tmux_session: str | None,
 ) -> tuple[bool, TerminalHandle | None]:
     """Launch an agent in the resolved terminal."""
+    if terminal.name == "cmux":
+        handle = _launch_in_cmux(path, agent, terminal, full_cmd, tab_name, repo_root)
+        return handle is not None, handle
+
     if terminal.name == "tmux":
         handle = _launch_in_tmux(
             path,

agent_cli-0.100.0/agent_cli/dev/terminals/cmux.py

@@ -0,0 +1,247 @@
+"""cmux terminal adapter.
+
+cmux (https://cmux.dev) is a Ghostty-based macOS terminal organized as
+windows > workspaces > panes > surfaces (tabs), controlled via a Unix
+socket through the bundled ``cmux`` CLI.
+
+agent-cli maps repos to workspaces: each repo gets a workspace named after
+it, and each worktree launch opens a new tab inside that workspace.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shlex
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from agent_cli.dev.worktree import get_main_repo_root
+
+from .base import Terminal, TerminalHandle
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# Named colors accepted by `cmux workspace-action --action set-color`.
+_WORKSPACE_COLORS = (
+    "Red",
+    "Crimson",
+    "Orange",
+    "Amber",
+    "Olive",
+    "Green",
+    "Teal",
+    "Aqua",
+    "Blue",
+    "Navy",
+    "Indigo",
+    "Purple",
+    "Magenta",
+    "Rose",
+    "Brown",
+    "Charcoal",
+)
+
+
+class Cmux(Terminal):
+    """cmux - Ghostty-based terminal with workspaces for AI coding agents."""
+
+    name = "cmux"
+
+    def detect(self) -> bool:
+        """Detect if running inside cmux via its auto-set environment variables."""
+        return bool(
+            os.environ.get("CMUX_WORKSPACE_ID") or os.environ.get("CMUX_SURFACE_ID"),
+        )
+
+    def is_available(self) -> bool:
+        """Check if the cmux CLI is available."""
+        return shutil.which("cmux") is not None
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in a workspace named after the repo containing ``path``."""
+        repo_root = get_main_repo_root(path)
+        workspace_name = (repo_root or path).name
+        handle = self.open_in_workspace(path, command, tab_name, workspace_name=workspace_name)
+        return handle is not None
+
+    def open_in_workspace(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+        *,
+        workspace_name: str,
+    ) -> TerminalHandle | None:
+        """Open a tab in the named cmux workspace, creating the workspace if needed.
+
+        Workspace targets are always passed explicitly because the cmux CLI
+        otherwise defaults to the caller's workspace (``CMUX_WORKSPACE_ID``).
+        """
+        if not self.is_available():
+            return None
+        workspaces = self._list_workspaces()
+        if workspaces is None:
+            # The cmux CLI itself failed (e.g. app not running); creating a
+            # workspace would fail too, or duplicate one we could not see.
+            return None
+        workspace_ref = next(
+            (w.get("ref") for w in workspaces if w.get("title") == workspace_name),
+            None,
+        )
+        if workspace_ref is None:
+            return self._create_workspace(path, command, tab_name, workspace_name=workspace_name)
+        return self._open_tab(
+            path,
+            command,
+            tab_name,
+            workspace_ref=workspace_ref,
+            workspace_name=workspace_name,
+        )
+
+    def _list_workspaces(self) -> list[dict] | None:
+        """List workspace dicts via the cmux CLI, or None when the CLI call fails."""
+        stdout = self._run(["workspace", "list", "--json"])
+        if stdout is None:
+            return None
+        try:
+            data = json.loads(stdout)
+        except json.JSONDecodeError:
+            return None
+        workspaces = data.get("workspaces", [])
+        return workspaces if isinstance(workspaces, list) else None
+
+    def _create_workspace(
+        self,
+        path: Path,
+        command: str | None,
+        tab_name: str | None,
+        *,
+        workspace_name: str,
+    ) -> TerminalHandle | None:
+        """Create a workspace whose initial tab starts in ``path`` running ``command``."""
+        cmd = ["workspace", "create", "--name", workspace_name, "--cwd", str(path)]
+        if command:
+            cmd.extend(["--command", command])
+        workspace_ref = self._parse_ok_ref(self._run(cmd), "workspace:")
+        if workspace_ref is None:
+            return None
+        self._run(
+            [
+                "workspace-action",
+                "--action",
+                "set-color",
+                "--workspace",
+                workspace_ref,
+                "--color",
+                self._workspace_color(workspace_name),
+            ],
+        )
+        if tab_name:
+            # The freshly created workspace has a single tab, which is its
+            # focused tab, so rename-tab needs no explicit surface target.
+            self._run(["rename-tab", "--workspace", workspace_ref, "--title", tab_name])
+        return TerminalHandle(
+            terminal_name=self.name,
+            handle=workspace_ref,
+            session_name=workspace_name,
+        )
+
+    def _open_tab(
+        self,
+        path: Path,
+        command: str | None,
+        tab_name: str | None,
+        *,
+        workspace_ref: str,
+        workspace_name: str,
+    ) -> TerminalHandle | None:
+        """Open a new tab in an existing workspace and run ``command`` in ``path``."""
+        surface_ref = self._parse_ok_ref(
+            self._run(["new-surface", "--workspace", workspace_ref]),
+            "surface:",
+        )
+        if surface_ref is None:
+            return None
+        if tab_name:
+            self._run(
+                [
+                    "rename-tab",
+                    "--workspace",
+                    workspace_ref,
+                    "--surface",
+                    surface_ref,
+                    "--title",
+                    tab_name,
+                ],
+            )
+        # New surfaces don't accept a cwd/command, so type it into the shell.
+        # The terminal buffers the input until the shell is ready, and cmux
+        # turns the literal \n escape sequence into Enter.
+        shell_cmd = f"cd {shlex.quote(str(path))}"
+        if command:
+            shell_cmd += f" && {command}"
+        sent = self._run(
+            [
+                "send",
+                "--workspace",
+                workspace_ref,
+                "--surface",
+                surface_ref,
+                "--",
+                shell_cmd + "\\n",
+            ],
+        )
+        if sent is None:
+            # The command never reached the tab, so the agent is not running;
+            # remove the idle tab and report failure instead of a dead handle.
+            self._run(["close-surface", "--workspace", workspace_ref, "--surface", surface_ref])
+            return None
+        return TerminalHandle(
+            terminal_name=self.name,
+            handle=surface_ref,
+            session_name=workspace_name,
+        )
+
+    @staticmethod
+    def _workspace_color(workspace_name: str) -> str:
+        """Pick a deterministic cmux named color for a workspace."""
+        digest = hashlib.sha256(workspace_name.encode()).hexdigest()
+        return _WORKSPACE_COLORS[int(digest[:8], 16) % len(_WORKSPACE_COLORS)]
+
+    @staticmethod
+    def _run(args: list[str]) -> str | None:
+        """Run a cmux CLI command and return its stdout, or None on failure."""
+        env = {**os.environ, "CMUX_QUIET": "1"}
+        try:
+            result = subprocess.run(
+                ["cmux", *args],  # noqa: S607
+                check=True,
+                capture_output=True,
+                text=True,
+                env=env,
+            )
+        except (subprocess.CalledProcessError, OSError):
+            return None
+        return result.stdout
+
+    @staticmethod
+    def _parse_ok_ref(stdout: str | None, prefix: str) -> str | None:
+        """Extract the first ``<prefix>N`` ref from an ``OK ...`` response line."""
+        if not stdout:
+            return None
+        for line in stdout.splitlines():
+            if not line.startswith("OK"):
+                continue
+            for token in line.split():
+                if token.startswith(prefix):
+                    return token
+        return None

{agent_cli-0.98.5 → agent_cli-0.100.0}/agent_cli/dev/terminals/registry.py

@@ -6,6 +6,7 @@ from agent_cli.dev.registry import Registry
 
 from .apple_terminal import AppleTerminal
 from .base import Terminal  # noqa: TC001
+from .cmux import Cmux
 from .gnome import GnomeTerminal
 from .iterm2 import ITerm2
 from .kitty import Kitty
@@ -18,6 +19,7 @@ from .zellij import Zellij
 _TERMINALS: list[type[Terminal]] = [
     Tmux,
     Zellij,
+    Cmux,
     ITerm2,
     Kitty,
     Warp,

{agent_cli-0.98.5 → agent_cli-0.100.0}/agent_cli/opts.py

@@ -436,6 +436,31 @@ VOICE_LEVEL_LOG: Path | None = typer.Option(
     hidden=True,
     rich_help_panel="General Options",
 )
+LIVE_PREVIEW_LOG: Path | None = typer.Option(
+    None,
+    "--live-preview-log",
+    help="Write rolling live transcription preview events to JSONL while recording.",
+    rich_help_panel="Live Preview",
+)
+LIVE_PREVIEW_INTERVAL: float = typer.Option(
+    2.0,
+    "--live-preview-interval",
+    help="Seconds between live preview retranscriptions.",
+    rich_help_panel="Live Preview",
+)
+LIVE_PREVIEW_WINDOW: float = typer.Option(
+    15.0,
+    "--live-preview-window",
+    help="Seconds of recent audio to include in each live preview retranscription.",
+    rich_help_panel="Live Preview",
+)
+LIVE_PREVIEW_CONSOLE: bool = typer.Option(
+    False,  # noqa: FBT003
+    "--live-preview-console",
+    "--live-preview-stdout",
+    help="Print rolling live transcription preview updates to the terminal while recording.",
+    rich_help_panel="Live Preview",
+)
 
 # --- Server Options ---
 SERVER_HOST: str = typer.Option(