agent-cli 0.84.0__tar.gz → 0.84.2__tar.gz

{agent_cli-0.84.0 → agent_cli-0.84.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.84.0
+Version: 0.84.2
 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>

{agent_cli-0.84.0 → agent_cli-0.84.2}/agent_cli/dev/cli.py

@@ -111,6 +111,47 @@ def _ensure_git_repo() -> Path:
     return repo_root
 
 
+def _require_available_agent(
+    agent: coding_agents.CodingAgent | None,
+    *,
+    requested_name: str | None = None,
+) -> coding_agents.CodingAgent:
+    """Fail fast when an explicit agent launch was requested but cannot happen."""
+    if agent is None:
+        if requested_name:
+            error(f"Agent not found: {requested_name}")
+        available_names = ", ".join(candidate.name for candidate in coding_agents.get_all_agents())
+        if available_names:
+            error(f"No AI coding agents found. Install one of: {available_names}")
+        error("No AI coding agents found")
+
+    if not agent.is_available():
+        msg = f"{agent.name} is not installed"
+        if agent.install_url:
+            msg += f". Install from: {agent.install_url}"
+        error(msg)
+
+    return agent
+
+
+def _resolve_prompt_text(
+    prompt: str | None,
+    *,
+    prompt_file: Path | None = None,
+) -> str | None:
+    """Resolve prompt text from CLI input and reject empty explicit prompts."""
+    if prompt_file is not None:
+        prompt = prompt_file.read_text().strip()
+        if not prompt:
+            error(f"Prompt file is empty: {prompt_file}")
+        return prompt
+
+    if prompt is not None and not prompt.strip():
+        error("--prompt cannot be empty")
+
+    return prompt
+
+
 def _resolve_branch_name(
     branch: str | None,
     branch_name_mode: str,
@@ -383,9 +424,7 @@ def new(
     - `dev new feature-x --from origin/develop` — Branch from develop instead
     - `dev new feature-x --with-agent aider --with-editor cursor` — Specific tools
     """
-    # Handle prompt-file option (takes precedence over --prompt)
-    if prompt_file is not None:
-        prompt = prompt_file.read_text().strip()
+    prompt = _resolve_prompt_text(prompt, prompt_file=prompt_file)
 
     # If a prompt is provided, automatically enable agent mode
     if prompt:
@@ -404,6 +443,10 @@ def new(
         from_ref,
     )
 
+    resolved_agent = resolve_agent(agent, agent_name, default_agent)
+    if agent:
+        resolved_agent = _require_available_agent(resolved_agent, requested_name=agent_name)
+
     # Create the worktree
     info(f"Creating worktree for branch '{branch}'...")
     result = worktree.create_worktree(
@@ -440,7 +483,6 @@ def new(
 
     # Resolve and launch editor/agent
     resolved_editor = resolve_editor(editor, editor_name, default_editor)
-    resolved_agent = resolve_agent(agent, agent_name, default_agent)
 
     if resolved_editor and resolved_editor.is_available():
         launch_editor(result.path, resolved_editor)
@@ -902,9 +944,7 @@ def start_agent(
     - `dev agent my-feature -a claude` — Start Claude specifically
     - `dev agent my-feature -p "Continue the auth refactor"` — Start with a task
     """
-    # Handle prompt-file option (takes precedence over --prompt)
-    if prompt_file is not None:
-        prompt = prompt_file.read_text().strip()
+    prompt = _resolve_prompt_text(prompt, prompt_file=prompt_file)
 
     repo_root = _ensure_git_repo()
 
@@ -914,18 +954,13 @@ def start_agent(
 
     if agent_name:
         agent = coding_agents.get_agent(agent_name)
-        if agent is None:
-            error(f"Agent not found: {agent_name}")
     else:
         agent = coding_agents.detect_current_agent()
         if agent is None:
             available = coding_agents.get_available_agents()
-            if not available:
-                error("No AI coding agents available")
-            agent = available[0]
+            agent = available[0] if available else None
 
-    if not agent.is_available():
-        error(f"{agent.name} is not installed. Install from: {agent.install_url}")
+    agent = _require_available_agent(agent, requested_name=agent_name)
 
     # Write prompt to worktree (makes task available to the agent)
     task_file = None

{agent_cli-0.84.0 → agent_cli-0.84.2}/agent_cli/dev/terminals/tmux.py

@@ -49,19 +49,6 @@ class Tmux(Terminal):
         session_name = result.stdout.strip()
         return session_name or None
 
-    def session_exists(self, session_name: str) -> bool:
-        """Check if a tmux session exists."""
-        try:
-            subprocess.run(
-                ["tmux", "has-session", "-t", session_name],  # noqa: S607
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-            return True
-        except subprocess.CalledProcessError:
-            return False
-
     def open_in_session(
         self,
         path: Path,
@@ -84,9 +71,18 @@ class Tmux(Terminal):
                 return None
             return self._open_window(path, command, tab_name, session_name=session_name)
 
-        if self.session_exists(session_name):
-            return self._open_window(path, command, tab_name, session_name=session_name)
-        return self._create_session(path, command, tab_name, session_name=session_name)
+        # Avoid a has-session/new-session race when several launches try to create the
+        # same repo-scoped session concurrently: try new-window first, then create,
+        # then retry new-window in case another launcher created the session first.
+        handle = self._open_window(path, command, tab_name, session_name=session_name)
+        if handle is not None:
+            return handle
+
+        handle = self._create_session(path, command, tab_name, session_name=session_name)
+        if handle is not None:
+            return handle
+
+        return self._open_window(path, command, tab_name, session_name=session_name)
 
     def open_new_tab(
         self,

{agent_cli-0.84.0 → agent_cli-0.84.2}/tests/dev/test_cli.py

@@ -19,6 +19,7 @@ from agent_cli.dev._branch_name import (
     generate_random_branch_name,
 )
 from agent_cli.dev.cli import _clean_no_commits_worktrees
+from agent_cli.dev.cli import app as dev_app
 from agent_cli.dev.coding_agents.base import CodingAgent
 from agent_cli.dev.launch import (
     _format_env_prefix,
@@ -300,8 +301,13 @@ class TestDevNewBranchNaming:
                 return_value=wt_path / ".claude/TASK.md",
             ),
             patch("agent_cli.dev.cli.resolve_editor", return_value=None),
-            patch("agent_cli.dev.cli.resolve_agent", return_value=None),
+            patch("agent_cli.dev.cli.resolve_agent") as mock_resolve_agent,
+            patch("agent_cli.dev.cli.merge_agent_args", return_value=None),
+            patch("agent_cli.dev.cli.get_agent_env", return_value={}),
+            patch("agent_cli.dev.cli.launch_agent", return_value=None),
         ):
+            mock_agent = mock_resolve_agent.return_value
+            mock_agent.is_available.return_value = True
             result = runner.invoke(
                 app,
                 [
@@ -559,6 +565,99 @@ direnv = false
         assert "%42" in result.output
         assert "tmux attach -t agent-cli-repo-1234" in result.output
 
+    def test_new_fails_before_creating_worktree_when_no_agent_is_available(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        """Explicit agent launches should fail fast before creating side effects."""
+        prompt_file = tmp_path / "task.md"
+        prompt_file.write_text("Fix login retries")
+
+        with (
+            patch("agent_cli.dev.cli._ensure_git_repo", return_value=Path("/repo")),
+            patch("agent_cli.dev.cli.resolve_agent", return_value=None),
+            patch("agent_cli.dev.worktree.create_worktree") as mock_create,
+        ):
+            result = runner.invoke(
+                app,
+                [
+                    "dev",
+                    "new",
+                    "my-feature",
+                    "--agent",
+                    "--multiplexer",
+                    "tmux",
+                    "--prompt-file",
+                    str(prompt_file),
+                    "--no-setup",
+                    "--no-copy-env",
+                    "--no-fetch",
+                    "--no-direnv",
+                ],
+            )
+
+        assert result.exit_code == 1
+        assert "No AI coding agents found" in result.output
+        assert "Success" not in result.output
+        mock_create.assert_not_called()
+
+    def test_new_fails_before_creating_worktree_when_requested_agent_is_unavailable(self) -> None:
+        """Unavailable explicit agents should abort before worktree creation."""
+        with (
+            patch("agent_cli.dev.cli._ensure_git_repo", return_value=Path("/repo")),
+            patch("agent_cli.dev.cli.resolve_agent") as mock_resolve_agent,
+            patch("agent_cli.dev.worktree.create_worktree") as mock_create,
+        ):
+            mock_agent = mock_resolve_agent.return_value
+            mock_agent.name = "codex"
+            mock_agent.install_url = "https://example.com/codex"
+            mock_agent.is_available.return_value = False
+
+            result = runner.invoke(
+                app,
+                [
+                    "dev",
+                    "new",
+                    "my-feature",
+                    "--agent",
+                    "--with-agent",
+                    "codex",
+                    "--no-setup",
+                    "--no-copy-env",
+                    "--no-fetch",
+                    "--no-direnv",
+                ],
+            )
+
+        assert result.exit_code == 1
+        assert "codex is not installed. Install from: https://example.com/codex" in result.output
+        assert "Success" not in result.output
+        mock_create.assert_not_called()
+
+    def test_new_rejects_empty_prompt(self) -> None:
+        """Explicit empty prompts should error instead of silently becoming no-op."""
+        with patch("agent_cli.dev.cli._ensure_git_repo") as mock_ensure_repo:
+            result = runner.invoke(app, ["dev", "new", "my-feature", "--prompt", "   "])
+
+        assert result.exit_code == 1
+        assert "--prompt cannot be empty" in result.output
+        mock_ensure_repo.assert_not_called()
+
+    def test_new_rejects_empty_prompt_file(self, tmp_path: Path) -> None:
+        """Empty prompt files should fail before any worktree setup starts."""
+        prompt_file = tmp_path / "empty.md"
+        prompt_file.write_text(" \n")
+
+        with patch("agent_cli.dev.cli._ensure_git_repo") as mock_ensure_repo:
+            result = runner.invoke(
+                app,
+                ["dev", "new", "my-feature", "--prompt-file", str(prompt_file)],
+            )
+
+        assert result.exit_code == 1
+        assert f"Prompt file is empty: {prompt_file}" in result.output
+        mock_ensure_repo.assert_not_called()
+
 
 class TestDevHelp:
     """Tests for dev command help."""
@@ -639,13 +738,28 @@ class TestDevAgent:
         assert result.exit_code == 0
         assert "tmux attach -t 'my session'" in result.output
 
+    def test_agent_rejects_empty_prompt_file(self, tmp_path: Path) -> None:
+        """Empty prompt files should fail before repo/worktree resolution."""
+        prompt_file = tmp_path / "empty.md"
+        prompt_file.write_text("\n")
+
+        with patch("agent_cli.dev.cli._ensure_git_repo") as mock_ensure_repo:
+            result = runner.invoke(
+                app,
+                ["dev", "agent", "feature", "--prompt-file", str(prompt_file)],
+            )
+
+        assert result.exit_code == 1
+        assert f"Prompt file is empty: {prompt_file}" in result.output
+        mock_ensure_repo.assert_not_called()
+
 
 class TestDevAgents:
     """Tests for dev agents command."""
 
     def test_list_agents(self) -> None:
         """List all agents."""
-        result = runner.invoke(app, ["dev", "agents"])
+        result = runner.invoke(dev_app, ["agents"])
         assert result.exit_code == 0
         assert "claude" in result.output.lower()
         assert "aider" in result.output.lower()
@@ -656,7 +770,7 @@ class TestDevEditors:
 
     def test_list_editors(self) -> None:
         """List all editors."""
-        result = runner.invoke(app, ["dev", "editors"])
+        result = runner.invoke(dev_app, ["editors"])
         assert result.exit_code == 0
         assert "vscode" in result.output.lower()
         assert "neovim" in result.output.lower()
@@ -667,7 +781,7 @@ class TestDevTerminals:
 
     def test_list_terminals(self) -> None:
         """List all terminals."""
-        result = runner.invoke(app, ["dev", "terminals"])
+        result = runner.invoke(dev_app, ["terminals"])
         assert result.exit_code == 0
         assert "tmux" in result.output.lower()
         assert "zellij" in result.output.lower()

{agent_cli-0.84.0 → agent_cli-0.84.2}/tests/dev/test_terminals.py

@@ -65,11 +65,14 @@ class TestTmux:
     def test_open_in_session_creates_detached_session_when_missing(self) -> None:
         """Outside tmux, a named session is created in detached mode if absent."""
         terminal = Tmux()
-        mock_run = MagicMock(return_value=MagicMock(stdout="%42\n"))
         with (
-            patch("subprocess.run", mock_run),
-            patch.object(terminal, "session_exists", return_value=False),
-            patch("shutil.which", return_value="/usr/bin/tmux"),
+            patch.object(terminal, "is_available", return_value=True),
+            patch.object(terminal, "_open_window", return_value=None) as mock_open,
+            patch.object(
+                terminal,
+                "_create_session",
+                return_value=MagicMock(handle="%42", session_name="repo-session"),
+            ) as mock_create,
         ):
             handle = terminal.open_in_session(
                 Path("/some/path"),
@@ -81,23 +84,30 @@ class TestTmux:
         assert handle is not None
         assert handle.handle == "%42"
         assert handle.session_name == "repo-session"
-        cmd = mock_run.call_args[0][0]
-        assert "new-session" in cmd
-        assert "-d" in cmd
-        assert "-P" in cmd
-        assert "-F" in cmd
-        assert "#{pane_id}" in cmd
-        assert "-s" in cmd
-        assert "repo-session" in cmd
+        mock_open.assert_called_once_with(
+            Path("/some/path"),
+            "echo hello",
+            "test",
+            session_name="repo-session",
+        )
+        mock_create.assert_called_once_with(
+            Path("/some/path"),
+            "echo hello",
+            "test",
+            session_name="repo-session",
+        )
 
     def test_open_in_session_reuses_existing_session(self) -> None:
         """Outside tmux, a named session gets a new window when it already exists."""
         terminal = Tmux()
-        mock_run = MagicMock(return_value=MagicMock(stdout="%5\n"))
         with (
-            patch("subprocess.run", mock_run),
-            patch.object(terminal, "session_exists", return_value=True),
-            patch("shutil.which", return_value="/usr/bin/tmux"),
+            patch.object(terminal, "is_available", return_value=True),
+            patch.object(
+                terminal,
+                "_open_window",
+                return_value=MagicMock(handle="%5", session_name="repo-session"),
+            ) as mock_open,
+            patch.object(terminal, "_create_session") as mock_create,
         ):
             handle = terminal.open_in_session(
                 Path("/some/path"),
@@ -109,10 +119,46 @@ class TestTmux:
         assert handle is not None
         assert handle.handle == "%5"
         assert handle.session_name == "repo-session"
-        cmd = mock_run.call_args[0][0]
-        assert "new-window" in cmd
-        assert "-t" in cmd
-        assert "repo-session" in cmd
+        mock_open.assert_called_once_with(
+            Path("/some/path"),
+            "echo hello",
+            "test",
+            session_name="repo-session",
+        )
+        mock_create.assert_not_called()
+
+    def test_open_in_session_retries_when_session_appears_during_race(self) -> None:
+        """Concurrent creators should fall back to opening a new window."""
+        terminal = Tmux()
+        with (
+            patch.object(terminal, "is_available", return_value=True),
+            patch.object(
+                terminal,
+                "_open_window",
+                side_effect=[
+                    None,
+                    MagicMock(handle="%7", session_name="repo-session"),
+                ],
+            ) as mock_open,
+            patch.object(terminal, "_create_session", return_value=None) as mock_create,
+        ):
+            handle = terminal.open_in_session(
+                Path("/some/path"),
+                "echo hello",
+                tab_name="test",
+                session_name="repo-session",
+            )
+
+        assert handle is not None
+        assert handle.handle == "%7"
+        assert handle.session_name == "repo-session"
+        assert mock_open.call_count == 2
+        mock_create.assert_called_once_with(
+            Path("/some/path"),
+            "echo hello",
+            "test",
+            session_name="repo-session",
+        )
 
 
 class TestZellij:

{agent_cli-0.84.0 → agent_cli-0.84.2}/tests/memory/test_client.py

@@ -53,6 +53,9 @@ class _DummyReranker:
 def client(tmp_path: Path) -> MemoryClient:
     """Create a memory client with stubs."""
     with ExitStack() as stack:
+        stack.enter_context(
+            patch("agent_cli.memory.client.init_repo"),
+        )
         stack.enter_context(
             patch("agent_cli.memory.client.watch_memory_store"),
         )
@@ -150,6 +153,9 @@ async def test_client_startup_manual(tmp_path: Path) -> None:
             pass
 
     with ExitStack() as stack:
+        stack.enter_context(
+            patch("agent_cli.memory.client.init_repo"),
+        )
         mock_watch = stack.enter_context(patch("agent_cli.memory.client.watch_memory_store"))
         mock_watch.side_effect = _fake_watch
 
@@ -195,6 +201,9 @@ async def test_client_context_manager(tmp_path: Path) -> None:
             pass
 
     with ExitStack() as stack:
+        stack.enter_context(
+            patch("agent_cli.memory.client.init_repo"),
+        )
         mock_watch = stack.enter_context(patch("agent_cli.memory.client.watch_memory_store"))
         mock_watch.side_effect = _fake_watch