agent-cli 0.70.5__py3-none-any.whl

agent_cli/dev/coding_agents/__init__.py

@@ -0,0 +1,19 @@
+"""AI coding agent adapters for the dev module."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+from .registry import (
+    detect_current_agent,
+    get_agent,
+    get_all_agents,
+    get_available_agents,
+)
+
+__all__ = [
+    "CodingAgent",
+    "detect_current_agent",
+    "get_agent",
+    "get_all_agents",
+    "get_available_agents",
+]

agent_cli/dev/coding_agents/aider.py

@@ -0,0 +1,24 @@
+"""Aider AI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class Aider(CodingAgent):
+    """Aider - AI pair programming in your terminal."""
+
+    name = "aider"
+    command = "aider"
+    install_url = "https://aider.chat"
+    detect_process_name = "aider"
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return prompt using --message flag.
+
+        Aider uses -m/--message for initial prompts:
+        `aider --message "your prompt here"`
+
+        See: https://aider.chat/docs/scripting.html
+        """
+        return ["--message", prompt]

agent_cli/dev/coding_agents/base.py

@@ -0,0 +1,167 @@
+"""Base class for AI coding agent adapters."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from abc import ABC
+from pathlib import PurePath
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class CodingAgent(ABC):
+    """Abstract base class for AI coding agent adapters."""
+
+    # Display name for the agent
+    name: str
+
+    # CLI command to invoke the agent
+    command: str
+
+    # Alternative command names (for detection)
+    alt_commands: tuple[str, ...] = ()
+
+    # URL for installation instructions
+    install_url: str = ""
+
+    # Declarative detection: env var that indicates running inside this agent
+    # e.g., "CLAUDECODE" for Claude Code (checks if env var is set to "1")
+    detect_env_var: str | None = None
+
+    # Declarative detection: process name to look for in parent processes
+    # e.g., "aider" will match any parent process containing "aider"
+    detect_process_name: str | None = None
+
+    def detect(self) -> bool:
+        """Check if this agent is currently running/active in the environment.
+
+        Default implementation uses declarative detection attributes.
+        Override for custom detection logic.
+        """
+        # Check env var first (faster) - checks for "1" specifically
+        if self.detect_env_var and os.environ.get(self.detect_env_var) == "1":
+            return True
+
+        # Fall back to parent process detection
+        if self.detect_process_name:
+            parent_names = _get_parent_process_names()
+            return any(self.detect_process_name in name for name in parent_names)
+
+        return False
+
+    def is_available(self) -> bool:
+        """Check if this agent is installed and available."""
+        if shutil.which(self.command):
+            return True
+        return any(shutil.which(cmd) for cmd in self.alt_commands)
+
+    def get_executable(self) -> str | None:
+        """Get the path to the executable."""
+        if exe := shutil.which(self.command):
+            return exe
+        for cmd in self.alt_commands:
+            if exe := shutil.which(cmd):
+                return exe
+        return None
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return the CLI arguments to pass an initial prompt to the agent.
+
+        Override this method in subclasses for agents that support initial prompts.
+        Default implementation returns empty list (prompt not supported).
+
+        Args:
+            prompt: The initial prompt to pass to the agent
+
+        Returns:
+            List of CLI arguments (e.g., ["prompt text"] or ["-m", "prompt text"])
+
+        """
+        del prompt  # unused in base implementation
+        return []
+
+    def launch_command(
+        self,
+        path: Path,  # noqa: ARG002
+        extra_args: list[str] | None = None,
+        prompt: str | None = None,
+    ) -> list[str]:
+        """Return the command to launch this agent in a directory.
+
+        Args:
+            path: The directory to launch the agent in
+            extra_args: Additional arguments to pass to the agent
+            prompt: Optional initial prompt to pass to the agent
+
+        Returns:
+            List of command arguments
+
+        """
+        exe = self.get_executable()
+        if exe is None:
+            msg = f"{self.name} is not installed"
+            if self.install_url:
+                msg += f". Install from {self.install_url}"
+            raise RuntimeError(msg)
+        cmd = [exe]
+        if extra_args:
+            cmd.extend(extra_args)
+        if prompt:
+            cmd.extend(self.prompt_args(prompt))
+        return cmd
+
+    def get_env(self) -> dict[str, str]:
+        """Get any additional environment variables needed."""
+        return {}
+
+    def __repr__(self) -> str:  # noqa: D105
+        status = "available" if self.is_available() else "not installed"
+        return f"<{self.__class__.__name__} {self.name!r} ({status})>"
+
+
+def _get_parent_process_names() -> list[str]:
+    """Get names of parent processes (for detecting current agent).
+
+    Extracts names from both process.name() and cmdline.
+    This handles Node.js CLIs that don't set process.title:
+    - process.name() returns 'node' for most Node.js CLI tools
+    - cmdline contains the actual script path like '/path/to/cn'
+    - CLI tools that set process.title (like Claude) show their name directly
+    """
+    try:
+        import psutil  # noqa: PLC0415
+
+        process = psutil.Process(os.getpid())
+        names = []
+        for _ in range(10):  # Limit depth
+            process = process.parent()
+            if process is None:
+                break
+            # Add the process name (works for native binaries and tools that set process.title)
+            names.append(process.name().lower())
+
+            # Also check cmdline for the actual command (handles Node.js/Python CLIs)
+            # e.g., cmdline=['node', '/path/to/cn', '--version'] → extract 'cn'
+            try:
+                cmdline = process.cmdline()
+                if len(cmdline) >= 2:  # noqa: PLR2004
+                    # Get the script/command from cmdline[1] (the actual CLI tool)
+                    cmd_name = PurePath(cmdline[1]).name.lower()
+                    # Remove common extensions
+                    for ext in (".js", ".py", ".sh", ".exe"):
+                        if cmd_name.endswith(ext):
+                            cmd_name = cmd_name[: -len(ext)]
+                            break
+                    if cmd_name and cmd_name not in names:
+                        names.append(cmd_name)
+            except (psutil.AccessDenied, psutil.ZombieProcess, IndexError):
+                pass
+        return names
+    except ImportError:
+        # psutil not available, return empty list
+        return []
+    except Exception:
+        return []

agent_cli/dev/coding_agents/claude.py

@@ -0,0 +1,39 @@
+"""Claude Code AI coding agent adapter."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .base import CodingAgent
+
+
+class ClaudeCode(CodingAgent):
+    """Claude Code (Anthropic's CLI coding agent)."""
+
+    name = "claude"
+    command = "claude"
+    alt_commands = ("claude-code",)
+    install_url = "https://code.claude.com/docs/en/overview"
+    detect_env_var = "CLAUDECODE"
+    detect_process_name = "claude"
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return prompt as positional argument.
+
+        Claude Code accepts prompt as a positional argument:
+        `claude "your prompt here"`
+
+        See: claude --help
+        """
+        return [prompt]
+
+    def get_executable(self) -> str | None:
+        """Get the Claude executable path."""
+        # Check common installation path first
+        local_claude = Path.home() / ".claude" / "local" / "claude"
+        if local_claude.exists() and os.access(local_claude, os.X_OK):
+            return str(local_claude)
+
+        # Fall back to PATH lookup
+        return super().get_executable()

agent_cli/dev/coding_agents/codex.py

@@ -0,0 +1,24 @@
+"""OpenAI Codex CLI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class Codex(CodingAgent):
+    """OpenAI Codex CLI coding agent."""
+
+    name = "codex"
+    command = "codex"
+    install_url = "https://github.com/openai/codex"
+    detect_process_name = "codex"
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return prompt as positional argument.
+
+        Codex accepts prompt as a positional argument:
+        `codex "your prompt here"`
+
+        See: codex --help
+        """
+        return [prompt]

agent_cli/dev/coding_agents/continue_dev.py

@@ -0,0 +1,15 @@
+"""Continue Dev CLI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class ContinueDev(CodingAgent):
+    """Continue Dev - AI code assistant."""
+
+    name = "continue"
+    command = "cn"
+    install_url = "https://continue.dev"
+    # Detection via cmdline extraction (cn runs as 'node' but cmdline contains '/path/to/cn')
+    detect_process_name = "cn"

agent_cli/dev/coding_agents/copilot.py

@@ -0,0 +1,24 @@
+"""GitHub Copilot CLI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class Copilot(CodingAgent):
+    """GitHub Copilot CLI coding agent."""
+
+    name = "copilot"
+    command = "copilot"
+    install_url = "https://github.com/github/copilot-cli"
+    detect_process_name = "copilot"
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return prompt using --prompt flag.
+
+        Copilot CLI uses -p/--prompt for initial prompts:
+        `copilot --prompt "your prompt here"`
+
+        See: https://github.com/github/copilot-cli
+        """
+        return ["--prompt", prompt]

agent_cli/dev/coding_agents/cursor_agent.py

@@ -0,0 +1,48 @@
+"""Cursor Agent CLI coding agent adapter."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from .base import CodingAgent
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class CursorAgent(CodingAgent):
+    """Cursor Agent - AI agent mode for Cursor editor."""
+
+    name = "cursor-agent"
+    command = "cursor-agent"
+    alt_commands = ("cursor",)
+    install_url = "https://cursor.com"
+
+    def detect(self) -> bool:
+        """Detect if running inside Cursor Agent.
+
+        CURSOR_AGENT uses presence check (not == "1"), so custom detection needed.
+        """
+        return os.environ.get("CURSOR_AGENT") is not None
+
+    def launch_command(
+        self,
+        path: Path,  # noqa: ARG002
+        extra_args: list[str] | None = None,
+        prompt: str | None = None,
+    ) -> list[str]:
+        """Return the command to launch Cursor Agent."""
+        exe = self.get_executable()
+        if exe is None:
+            msg = f"{self.name} is not installed"
+            if self.install_url:
+                msg += f". Install from {self.install_url}"
+            raise RuntimeError(msg)
+        # Try cursor-agent first, fall back to cursor cli
+        cmd = [exe] if exe.endswith("cursor-agent") else [exe, "cli"]
+        if extra_args:
+            cmd.extend(extra_args)
+        if prompt:
+            cmd.extend(self.prompt_args(prompt))
+        return cmd

agent_cli/dev/coding_agents/gemini.py

@@ -0,0 +1,28 @@
+"""Google Gemini CLI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class Gemini(CodingAgent):
+    """Google Gemini CLI coding agent."""
+
+    name = "gemini"
+    command = "gemini"
+    install_url = "https://github.com/google-gemini/gemini-cli"
+    detect_process_name = "gemini"
+
+    def prompt_args(self, prompt: str) -> list[str]:
+        """Return prompt using -i/--prompt-interactive flag.
+
+        Gemini CLI uses -i for interactive mode with initial prompt:
+        `gemini -i "your prompt here"`
+
+        Note: -p/--prompt is non-interactive (exits after response).
+
+        Evidence: `gemini --help` shows:
+          -i, --prompt-interactive  Execute the provided prompt and continue
+                                    in interactive mode
+        """
+        return ["-i", prompt]

agent_cli/dev/coding_agents/opencode.py

@@ -0,0 +1,15 @@
+"""OpenCode CLI coding agent adapter."""
+
+from __future__ import annotations
+
+from .base import CodingAgent
+
+
+class OpenCode(CodingAgent):
+    """OpenCode - AI coding assistant."""
+
+    name = "opencode"
+    command = "opencode"
+    install_url = "https://opencode.ai"
+    detect_env_var = "OPENCODE"
+    detect_process_name = "opencode"

agent_cli/dev/coding_agents/registry.py

@@ -0,0 +1,49 @@
+"""Registry for AI coding agent adapters."""
+
+from __future__ import annotations
+
+from agent_cli.dev.registry import Registry
+
+from .aider import Aider
+from .base import CodingAgent  # noqa: TC001
+from .claude import ClaudeCode
+from .codex import Codex
+from .continue_dev import ContinueDev
+from .copilot import Copilot
+from .cursor_agent import CursorAgent
+from .gemini import Gemini
+from .opencode import OpenCode
+
+# All available coding agents (in priority order for detection)
+_AGENTS: list[type[CodingAgent]] = [
+    ClaudeCode,
+    Codex,
+    Gemini,
+    Aider,
+    Copilot,
+    ContinueDev,
+    OpenCode,
+    CursorAgent,
+]
+
+_registry: Registry[CodingAgent] = Registry(_AGENTS)
+
+
+def get_all_agents() -> list[CodingAgent]:
+    """Get instances of all registered coding agents."""
+    return _registry.get_all()
+
+
+def get_available_agents() -> list[CodingAgent]:
+    """Get all installed/available coding agents."""
+    return _registry.get_available()
+
+
+def detect_current_agent() -> CodingAgent | None:
+    """Detect which coding agent we're currently running in."""
+    return _registry.detect_current()
+
+
+def get_agent(name: str) -> CodingAgent | None:
+    """Get a coding agent by name."""
+    return _registry.get_by_name(name)

agent_cli/dev/editors/__init__.py

@@ -0,0 +1,19 @@
+"""Editor adapters for the dev module."""
+
+from __future__ import annotations
+
+from .base import Editor
+from .registry import (
+    detect_current_editor,
+    get_all_editors,
+    get_available_editors,
+    get_editor,
+)
+
+__all__ = [
+    "Editor",
+    "detect_current_editor",
+    "get_all_editors",
+    "get_available_editors",
+    "get_editor",
+]

agent_cli/dev/editors/base.py

@@ -0,0 +1,89 @@
+"""Base class for editor adapters."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from abc import ABC
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Editor(ABC):
+    """Abstract base class for editor adapters."""
+
+    # Display name for the editor
+    name: str
+
+    # CLI command to invoke the editor
+    command: str
+
+    # Alternative command names
+    alt_commands: tuple[str, ...] = ()
+
+    # URL for installation instructions
+    install_url: str = ""
+
+    # Declarative detection: env vars that indicate running inside this editor
+    # e.g., ("NVIM", "NVIM_LISTEN_ADDRESS") for Neovim
+    detect_env_vars: tuple[str, ...] = ()
+
+    # Declarative detection: value to look for in TERM_PROGRAM
+    # e.g., "vscode" will match if TERM_PROGRAM contains "vscode" (case-insensitive)
+    detect_term_program: str | None = None
+
+    def detect(self) -> bool:
+        """Check if currently running inside this editor's terminal.
+
+        Default implementation uses declarative detection attributes.
+        Override for custom detection logic.
+        """
+        # Check env vars first
+        for env_var in self.detect_env_vars:
+            if os.environ.get(env_var):
+                return True
+
+        # Check TERM_PROGRAM
+        if self.detect_term_program:
+            term_program = os.environ.get("TERM_PROGRAM")
+            if term_program and self.detect_term_program.lower() in term_program.lower():
+                return True
+
+        return False
+
+    def is_available(self) -> bool:
+        """Check if this editor is installed and available."""
+        if shutil.which(self.command):
+            return True
+        return any(shutil.which(cmd) for cmd in self.alt_commands)
+
+    def get_executable(self) -> str | None:
+        """Get the path to the executable."""
+        if exe := shutil.which(self.command):
+            return exe
+        for cmd in self.alt_commands:
+            if exe := shutil.which(cmd):
+                return exe
+        return None
+
+    def open_command(self, path: Path) -> list[str]:
+        """Return the command to open a directory in this editor.
+
+        Args:
+            path: The directory to open
+
+        Returns:
+            List of command arguments
+
+        """
+        exe = self.get_executable()
+        if exe is None:
+            msg = f"{self.name} is not installed"
+            raise RuntimeError(msg)
+        return [exe, path.as_posix()]
+
+    def __repr__(self) -> str:  # noqa: D105
+        status = "available" if self.is_available() else "not installed"
+        return f"<{self.__class__.__name__} {self.name!r} ({status})>"

agent_cli/dev/editors/cursor.py

@@ -0,0 +1,15 @@
+"""Cursor editor adapter."""
+
+from __future__ import annotations
+
+from .base import Editor
+
+
+class Cursor(Editor):
+    """Cursor - AI-first code editor."""
+
+    name = "cursor"
+    command = "cursor"
+    install_url = "https://cursor.com"
+    detect_env_vars = ("CURSOR_AGENT",)
+    # No detect_term_program - not verified (Cursor is proprietary)

agent_cli/dev/editors/emacs.py

@@ -0,0 +1,46 @@
+"""Emacs editor adapter."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .base import Editor
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Emacs(Editor):
+    """Emacs - An extensible, customizable text editor.
+
+    Detection via INSIDE_EMACS only. The legacy EMACS env var is deprecated.
+
+    Evidence: https://github.com/emacs-mirror/emacs/blob/master/etc/NEWS.25
+    Quote: "'M-x shell' and 'M-x compile' no longer set the EMACS environment
+           variable. This avoids clashing when other programs use the variable
+           for other purposes. [...] Use the INSIDE_EMACS environment variable
+           instead."
+    """
+
+    name = "emacs"
+    command = "emacs"
+    alt_commands = ("emacsclient",)
+    install_url = "https://www.gnu.org/software/emacs/"
+    detect_env_vars = ("INSIDE_EMACS",)  # EMACS is deprecated since Emacs 25
+    # No detect_term_program - Emacs doesn't set TERM_PROGRAM
+
+    def open_command(self, path: Path) -> list[str]:
+        """Return the command to open a directory in Emacs.
+
+        Uses background mode (&) for standalone emacs to match GTR behavior.
+        emacsclient uses -n flag which already runs in background.
+        """
+        exe = self.get_executable()
+        if exe is None:
+            msg = f"{self.name} is not installed"
+            raise RuntimeError(msg)
+        # Use emacsclient if available for faster opening (-n = don't wait)
+        if "emacsclient" in exe:
+            return [exe, "-n", path.as_posix()]
+        # Run standalone emacs in background like GTR does
+        return ["sh", "-c", f'{exe} "{path.as_posix()}" &']