agent-cli 0.80.0__tar.gz → 0.81.0__tar.gz

{agent_cli-0.80.0 → agent_cli-0.81.0}/.pre-commit-config.yaml

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

{agent_cli-0.80.0 → agent_cli-0.81.0}/PKG-INFO

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

{agent_cli-0.80.0 → agent_cli-0.81.0}/agent_cli/_tools.py

@@ -130,7 +130,7 @@ def execute_code(code: str) -> str:
     except subprocess.CalledProcessError as e:
         return f"Error executing code: {e.stderr}"
     except FileNotFoundError:
-        return f"Error: Command not found: {code.split()[0]}"
+        return f"Error: Command not found: {code.split(maxsplit=1)[0]}"
 
 
 def add_memory(content: str, category: str = "general", tags: str = "") -> str:

{agent_cli-0.80.0 → agent_cli-0.81.0}/agent_cli/agents/transcribe_live.py

@@ -188,7 +188,7 @@ async def _process_segment(  # noqa: PLR0912
     if cfg.clipboard:
         import pyperclip  # noqa: PLC0415
 
-        text_to_copy = processed if processed else transcript
+        text_to_copy = processed or transcript
         pyperclip.copy(text_to_copy)
 
     # Log

{agent_cli-0.80.0 → agent_cli-0.81.0}/agent_cli/config.py

@@ -264,6 +264,9 @@ class Dev(BaseModel):
 
     default_agent: str | None = None
     default_editor: str | None = None
+    branch_name_mode: Literal["random", "auto", "ai"] = "random"
+    branch_name_agent: Literal["claude", "codex", "gemini"] | None = None
+    branch_name_timeout: float = 20.0  # seconds
     agent_args: dict[str, list[str]] | None = (
         None  # Per-agent args, e.g. {"claude": ["--dangerously-skip-permissions"]}
     )
@@ -319,16 +322,28 @@ def normalize_provider_defaults(cfg: dict[str, Any]) -> dict[str, Any]:
     return normalized
 
 
-def _replace_dashed_keys(cfg: dict[str, Any]) -> dict[str, Any]:
-    return {k.replace("-", "_"): v for k, v in cfg.items()}
+def _replace_dashed_keys(cfg: Any) -> Any:
+    """Recursively replace dashed keys in dictionaries."""
+    if isinstance(cfg, dict):
+        return {k.replace("-", "_"): _replace_dashed_keys(v) for k, v in cfg.items()}
+    return cfg
 
 
 def _flatten_nested_sections(cfg: dict[str, Any], prefix: str = "") -> dict[str, Any]:
-    """Flatten nested TOML sections: {"a": {"b": {"x": 1}}} -> {"a.b": {"x": 1}}."""
-    result = {}
+    """Flatten nested TOML sections while preserving scalar parent options.
+
+    Example:
+        {"a": {"x": 1, "b": {"y": 2}}} -> {"a": {"x": 1}, "a.b": {"y": 2}}
+        {"a": {"b": {"x": 1}}} -> {"a.b": {"x": 1}}
+
+    """
+    result: dict[str, Any] = {}
     for key, value in cfg.items():
         full_key = f"{prefix}.{key}" if prefix else key
         if isinstance(value, dict) and any(isinstance(v, dict) for v in value.values()):
+            scalar_items = {k: v for k, v in value.items() if not isinstance(v, dict)}
+            if scalar_items:
+                result[full_key] = scalar_items
             result.update(_flatten_nested_sections(value, full_key))
         else:
             result[full_key] = value

{agent_cli-0.80.0 → agent_cli-0.81.0}/agent_cli/core/deps.py

@@ -61,7 +61,7 @@ EXTRAS: dict[str, tuple[str, list[str]]] = {
 
 def _check_package_installed(pkg: str) -> bool:
     """Check if a single package is installed."""
-    top_module = pkg.split(".")[0]
+    top_module = pkg.split(".", maxsplit=1)[0]
     try:
         return find_spec(top_module) is not None
     except (ValueError, ModuleNotFoundError):

agent_cli-0.81.0/agent_cli/dev/_branch_name.py

@@ -0,0 +1,371 @@
+"""Branch name generation for dev worktrees."""
+
+from __future__ import annotations
+
+import json
+import random
+import re
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from agent_cli.core.utils import err_console
+
+from . import worktree
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pathlib import Path
+
+AGENTS: tuple[str, ...] = ("claude", "codex", "gemini")
+
+_ADJECTIVES = [
+    "happy",
+    "clever",
+    "swift",
+    "bright",
+    "calm",
+    "eager",
+    "fancy",
+    "gentle",
+    "jolly",
+    "keen",
+    "lively",
+    "merry",
+    "nice",
+    "proud",
+    "quick",
+    "sharp",
+    "smart",
+    "sunny",
+    "witty",
+    "zesty",
+    "bold",
+    "cool",
+    "fresh",
+    "grand",
+]
+_NOUNS = [
+    "fox",
+    "owl",
+    "bear",
+    "wolf",
+    "hawk",
+    "lion",
+    "tiger",
+    "eagle",
+    "falcon",
+    "otter",
+    "panda",
+    "raven",
+    "shark",
+    "whale",
+    "zebra",
+    "bison",
+    "crane",
+    "dolphin",
+    "gecko",
+    "heron",
+    "koala",
+    "lemur",
+    "moose",
+    "newt",
+    "oriole",
+]
+
+_MAX_BRANCH_NAME_LEN = 80
+_MAX_BRANCH_TASK_LEN = 1200
+_CLAUDE_BRANCH_SCHEMA = json.dumps(
+    {
+        "type": "object",
+        "properties": {
+            "branch": {
+                "type": "string",
+                "pattern": r"^[a-z0-9][a-z0-9._/-]{1,79}$",
+            },
+        },
+        "required": ["branch"],
+        "additionalProperties": False,
+    },
+    separators=(",", ":"),
+)
+
+
+def _branch_exists_in_repo(repo_root: Path, branch_name: str) -> bool:
+    """Check whether a branch already exists locally or on origin."""
+    return any(worktree.check_branch_exists(branch_name, repo_root))
+
+
+def _ensure_unique_branch_name(
+    base_name: str,
+    existing_branches: set[str] | None = None,
+    *,
+    repo_root: Path | None = None,
+) -> str:
+    """Add a numeric suffix when a branch name collides."""
+    existing = existing_branches or set()
+
+    def is_available(candidate: str) -> bool:
+        if candidate in existing:
+            return False
+        return repo_root is None or not _branch_exists_in_repo(repo_root, candidate)
+
+    if is_available(base_name):
+        return base_name
+
+    for i in range(2, 100):
+        candidate = f"{base_name}-{i}"
+        if is_available(candidate):
+            return candidate
+
+    for _ in range(20):
+        candidate = f"{base_name}-{random.randint(100, 999)}"  # noqa: S311
+        if is_available(candidate):
+            return candidate
+
+    # Last resort: large range, unchecked (98 sequential + 20 random exhausted)
+    return f"{base_name}-{random.randint(1000, 9999)}"  # noqa: S311
+
+
+def _parse_json_lines(output: str) -> list[dict[str, object]]:
+    """Parse JSONL output and ignore non-JSON lines."""
+    parsed: list[dict[str, object]] = []
+    for raw_line in output.splitlines():
+        stripped_line = raw_line.strip()
+        if not stripped_line:
+            continue
+        try:
+            item = json.loads(stripped_line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(item, dict):
+            parsed.append(item)
+    return parsed
+
+
+def _extract_branch_from_claude_output(output: str) -> str | None:
+    """Extract branch name from `claude -p --output-format json` output."""
+    for event in reversed(_parse_json_lines(output)):
+        structured = event.get("structured_output")
+        if isinstance(structured, dict):
+            branch = structured.get("branch")
+            if isinstance(branch, str) and branch.strip():
+                return branch
+        result = event.get("result")
+        if isinstance(result, str) and result.strip():
+            return result
+    return None
+
+
+def _extract_branch_from_codex_output(output: str) -> str | None:
+    """Extract branch name from `codex exec --json` output."""
+    branch: str | None = None
+    for event in _parse_json_lines(output):
+        if event.get("type") != "item.completed":
+            continue
+        item = event.get("item")
+        if not isinstance(item, dict):
+            continue
+        if item.get("type") != "agent_message":
+            continue
+        text = item.get("text")
+        if isinstance(text, str) and text.strip():
+            branch = text
+    return branch
+
+
+def _extract_branch_from_gemini_output(output: str) -> str | None:
+    """Extract branch name from `gemini -p -o json` output."""
+    for raw_line in output.splitlines():
+        stripped = raw_line.strip()
+        if not stripped:
+            continue
+        try:
+            item = json.loads(stripped)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(item, dict):
+            response = item.get("response")
+            if isinstance(response, str) and response.strip():
+                return response
+    return None
+
+
+def _normalize_ai_branch_candidate(candidate: str, repo_root: Path) -> str | None:
+    """Normalize model output into a safe branch slug."""
+    lines = [line.strip() for line in candidate.replace("`", "").splitlines() if line.strip()]
+    if not lines:
+        return None
+
+    branch = lines[0].strip().strip("'\"")
+    branch = re.sub(r"^(branch|name)\s*:\s*", "", branch, flags=re.IGNORECASE)
+    branch = branch.lower()
+    branch = re.sub(r"\s+", "-", branch)
+    branch = re.sub(r"[^a-z0-9._/-]", "-", branch)
+    branch = re.sub(r"/{2,}", "/", branch)
+    branch = re.sub(r"-{2,}", "-", branch)
+    branch = branch.strip("./-")
+    if len(branch) > _MAX_BRANCH_NAME_LEN:
+        branch = branch[:_MAX_BRANCH_NAME_LEN].rstrip("./-")
+    if not branch:
+        return None
+
+    try:
+        result = subprocess.run(
+            ["git", "check-ref-format", "--branch", branch],  # noqa: S607
+            cwd=repo_root,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except OSError:
+        return None
+    return branch if result.returncode == 0 else None
+
+
+def _build_branch_naming_prompt(
+    repo_root: Path,
+    prompt: str | None,
+    from_ref: str | None,
+) -> str:
+    """Build a constrained prompt for branch name generation."""
+    task = (prompt or "").strip()
+    if not task:
+        task = "General maintenance task."
+    if len(task) > _MAX_BRANCH_TASK_LEN:
+        task = task[:_MAX_BRANCH_TASK_LEN] + "..."
+
+    base_ref = from_ref or "default branch"
+    return (
+        "Generate exactly one git branch name.\n"
+        "Return only the branch name and nothing else.\n"
+        "Do not use tools, do not inspect files, and do not ask follow-up questions.\n"
+        "Rules:\n"
+        "- lowercase ascii only\n"
+        "- allowed characters: a-z 0-9 / - _ .\n"
+        "- no spaces, no backticks, no explanation\n"
+        "- max 80 characters\n"
+        f"Repository: {repo_root.name}\n"
+        f"Base ref: {base_ref}\n"
+        f"Task: {task}\n"
+    )
+
+
+def _generate_branch_name_with_agent(
+    agent_name: str,
+    repo_root: Path,
+    prompt: str | None,
+    from_ref: str | None,
+    timeout_seconds: float,
+) -> str | None:
+    """Run a headless agent to generate a branch name."""
+    naming_prompt = _build_branch_naming_prompt(repo_root, prompt, from_ref)
+
+    agent_commands: dict[str, tuple[list[str], Callable[[str], str | None]]] = {
+        "claude": (
+            [
+                "claude",
+                "-p",
+                "--output-format",
+                "json",
+                "--permission-mode",
+                "plan",
+                "--no-session-persistence",
+                "--json-schema",
+                _CLAUDE_BRANCH_SCHEMA,
+                naming_prompt,
+            ],
+            _extract_branch_from_claude_output,
+        ),
+        "codex": (
+            [
+                "codex",
+                "-a",
+                "never",
+                "exec",
+                "-s",
+                "read-only",
+                "--json",
+                naming_prompt,
+            ],
+            _extract_branch_from_codex_output,
+        ),
+        "gemini": (
+            ["gemini", "-p", naming_prompt, "-o", "json"],
+            _extract_branch_from_gemini_output,
+        ),
+    }
+
+    entry = agent_commands.get(agent_name)
+    if entry is None:
+        return None
+    command, extractor = entry
+
+    try:
+        result = subprocess.run(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            cwd=repo_root,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+
+    raw_branch = extractor(result.stdout)
+    if not raw_branch:
+        return None
+    return _normalize_ai_branch_candidate(raw_branch, repo_root)
+
+
+def generate_ai_branch_name(
+    repo_root: Path,
+    existing_branches: set[str],
+    prompt: str | None,
+    from_ref: str | None,
+    preferred_agent: str | None,
+    timeout_seconds: float,
+) -> str | None:
+    """Generate an AI branch name, trying available agents in order."""
+    if preferred_agent:
+        agent = preferred_agent.lower().strip()
+        if agent not in AGENTS or shutil.which(agent) is None:
+            return None
+        agents = [agent]
+    else:
+        agents = [a for a in AGENTS if shutil.which(a)]
+
+    for agent_name in agents:
+        with err_console.status(f"Generating branch name with {agent_name}..."):
+            branch = _generate_branch_name_with_agent(
+                agent_name,
+                repo_root,
+                prompt,
+                from_ref,
+                timeout_seconds,
+            )
+        if branch:
+            return _ensure_unique_branch_name(
+                branch,
+                existing_branches,
+                repo_root=repo_root,
+            )
+
+    return None
+
+
+def generate_random_branch_name(
+    existing_branches: set[str] | None = None,
+    *,
+    repo_root: Path | None = None,
+) -> str:
+    """Generate a unique random branch name like 'clever-fox'.
+
+    If the name already exists, adds a numeric suffix (clever-fox-2).
+    """
+    existing = existing_branches or set()
+    base = f"{random.choice(_ADJECTIVES)}-{random.choice(_NOUNS)}"  # noqa: S311
+    return _ensure_unique_branch_name(base, existing, repo_root=repo_root)

{agent_cli-0.80.0 → agent_cli-0.81.0}/agent_cli/dev/cli.py

@@ -4,13 +4,12 @@ from __future__ import annotations
 
 import json
 import os
-import random
 import shlex
 import shutil
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, NoReturn
+from typing import TYPE_CHECKING, Annotated, Literal, NoReturn
 
 import typer
 from rich.panel import Panel
@@ -22,85 +21,11 @@ from agent_cli.config import load_config
 from agent_cli.core.process import set_process_title
 from agent_cli.core.utils import console, err_console
 
-# Word lists for generating random branch names (like Docker container names)
-_ADJECTIVES = [
-    "happy",
-    "clever",
-    "swift",
-    "bright",
-    "calm",
-    "eager",
-    "fancy",
-    "gentle",
-    "jolly",
-    "keen",
-    "lively",
-    "merry",
-    "nice",
-    "proud",
-    "quick",
-    "sharp",
-    "smart",
-    "sunny",
-    "witty",
-    "zesty",
-    "bold",
-    "cool",
-    "fresh",
-    "grand",
-]
-_NOUNS = [
-    "fox",
-    "owl",
-    "bear",
-    "wolf",
-    "hawk",
-    "lion",
-    "tiger",
-    "eagle",
-    "falcon",
-    "otter",
-    "panda",
-    "raven",
-    "shark",
-    "whale",
-    "zebra",
-    "bison",
-    "crane",
-    "dolphin",
-    "gecko",
-    "heron",
-    "koala",
-    "lemur",
-    "moose",
-    "newt",
-    "oriole",
-]
-
-
-def _generate_branch_name(existing_branches: set[str] | None = None) -> str:
-    """Generate a unique random branch name like 'clever-fox'.
-
-    If the name already exists, adds a numeric suffix (clever-fox-2).
-    """
-    existing = existing_branches or set()
-    base = f"{random.choice(_ADJECTIVES)}-{random.choice(_NOUNS)}"  # noqa: S311
-
-    if base not in existing:
-        return base
-
-    # Add numeric suffix to avoid collision
-    for i in range(2, 100):
-        candidate = f"{base}-{i}"
-        if candidate not in existing:
-            return candidate
-
-    # Fallback: add random digits
-    return f"{base}-{random.randint(100, 999)}"  # noqa: S311
-
-
-from . import coding_agents, editors, terminals, worktree  # noqa: E402
-from .project import (  # noqa: E402
+from . import coding_agents, editors, terminals, worktree
+from ._branch_name import AGENTS as _BRANCH_NAME_AGENTS
+from ._branch_name import generate_ai_branch_name as _generate_ai_branch_name
+from ._branch_name import generate_random_branch_name as _generate_branch_name
+from .project import (
     copy_env_files,
     detect_project_type,
     is_direnv_available,
@@ -156,6 +81,17 @@ def dev_callback(
     has its own branch, allowing parallel development without stashing changes.
     """
     set_config_defaults(ctx, config_file)
+
+    # The [dev] section config is intended for `dev new` options.
+    # Click expects subcommand defaults under ctx.default_map["new"].
+    if isinstance(ctx.default_map, dict):
+        flat_defaults = {k: v for k, v in ctx.default_map.items() if not isinstance(v, dict)}
+        nested_defaults = {k: dict(v) for k, v in ctx.default_map.items() if isinstance(v, dict)}
+
+        if flat_defaults:
+            nested_defaults["new"] = {**flat_defaults, **nested_defaults.get("new", {})}
+            ctx.default_map = nested_defaults
+
     if ctx.invoked_subcommand is not None:
         set_process_title(f"dev-{ctx.invoked_subcommand}")
 
@@ -311,7 +247,7 @@ def _get_config_agent_env() -> dict[str, dict[str, str]] | None:
             agent_name = key[len(prefix) :]
             result[agent_name] = value
 
-    return result if result else None
+    return result or None
 
 
 def _get_agent_env(agent: CodingAgent) -> dict[str, str]:
@@ -350,7 +286,7 @@ def _merge_agent_args(
     if cli_args:
         result.extend(cli_args)
 
-    return result if result else None
+    return result or None
 
 
 def _is_ssh_session() -> bool:
@@ -488,7 +424,7 @@ def new(  # noqa: C901, PLR0912, PLR0915
     branch: Annotated[
         str | None,
         typer.Argument(
-            help="Branch name for the worktree. If omitted, generates a random name like 'clever-fox'",
+            help="Branch name for the worktree. If omitted, auto-generates one (random by default, AI with --branch-name-mode)",
         ),
     ] = None,
     from_ref: Annotated[
@@ -558,6 +494,29 @@ def new(  # noqa: C901, PLR0912, PLR0915
             help="Run 'git fetch' before creating the worktree to ensure refs are up-to-date",
         ),
     ] = True,
+    branch_name_mode: Annotated[
+        Literal["random", "auto", "ai"],
+        typer.Option(
+            "--branch-name-mode",
+            case_sensitive=False,
+            help="How to auto-name branches when BRANCH is omitted: random (default), auto (AI only when --prompt/--prompt-file is set), or ai (always try AI first)",
+        ),
+    ] = "random",
+    branch_name_agent: Annotated[
+        str | None,
+        typer.Option(
+            "--branch-name-agent",
+            help="Headless agent for AI branch naming: claude, codex, or gemini. If omitted, uses --with-agent when supported, otherwise tries available agents in that order",
+        ),
+    ] = None,
+    branch_name_timeout: Annotated[
+        float,
+        typer.Option(
+            "--branch-name-timeout",
+            min=1.0,
+            help="Timeout in seconds for AI branch naming command",
+        ),
+    ] = 20.0,
     direnv: Annotated[
         bool | None,
         typer.Option(
@@ -619,6 +578,7 @@ def new(  # noqa: C901, PLR0912, PLR0915
     - `dev new feature-x -a` — Create + start Claude/detected agent
     - `dev new feature-x -e -a` — Create + open editor + start agent
     - `dev new -a --prompt "Fix auth bug"` — Auto-named branch + agent with task
+    - `dev new --branch-name-mode ai -a --prompt "Refactor auth flow"` — AI-generated branch name
     - `dev new hotfix --from v1.2.3` — Branch from a tag instead of main
     - `dev new feature-x --from origin/develop` — Branch from develop instead
     - `dev new feature-x --with-agent aider --with-editor cursor` — Specific tools
@@ -637,8 +597,36 @@ def new(  # noqa: C901, PLR0912, PLR0915
     if branch is None:
         # Get existing branches to avoid collisions
         existing = {wt.branch for wt in worktree.list_worktrees() if wt.branch}
-        branch = _generate_branch_name(existing)
-        _info(f"Generated branch name: {branch}")
+        # In auto mode, only use AI naming when we have task context.
+        if branch_name_mode == "auto" and not prompt:
+            use_ai = False
+        else:
+            use_ai = branch_name_mode != "random"
+
+        if not use_ai:
+            branch = _generate_branch_name(existing, repo_root=repo_root)
+            _info(f"Generated branch name: {branch}")
+        else:
+            effective_branch_name_agent = branch_name_agent
+            if effective_branch_name_agent is None and agent_name:
+                candidate = agent_name.lower().strip()
+                if candidate in _BRANCH_NAME_AGENTS:
+                    effective_branch_name_agent = candidate
+
+            branch = _generate_ai_branch_name(
+                repo_root,
+                existing,
+                prompt,
+                from_ref,
+                effective_branch_name_agent,
+                branch_name_timeout,
+            )
+            if branch:
+                _info(f"AI-generated branch name: {branch}")
+            else:
+                _warn("Could not generate branch name with AI. Falling back to random naming.")
+                branch = _generate_branch_name(existing, repo_root=repo_root)
+                _info(f"Generated branch name: {branch}")
 
     # Create the worktree
     _info(f"Creating worktree for branch '{branch}'...")