codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/cli.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from rich import print as rprint
+
+from vibe.cli.textual_ui.app import run_textual_ui
+from vibe.core.agent_loop import AgentLoop
+from vibe.core.agents.models import BuiltinAgentName
+from vibe.core.config import (
+    MissingAPIKeyError,
+    MissingPromptFileError,
+    VibeConfig,
+    load_dotenv_values,
+)
+from vibe.core.paths.config_paths import CONFIG_FILE, HISTORY_FILE
+from vibe.core.programmatic import run_programmatic
+from vibe.core.session.session_loader import SessionLoader
+from vibe.core.types import LLMMessage, OutputFormat, Role
+from vibe.core.utils import ConversationLimitException, logger
+from vibe.setup.onboarding import run_onboarding
+
+
+def get_initial_agent_name(args: argparse.Namespace) -> str:
+    if args.prompt is not None and args.agent == BuiltinAgentName.DEFAULT:
+        return BuiltinAgentName.AUTO_APPROVE
+    return args.agent
+
+
+def get_prompt_from_stdin() -> str | None:
+    if sys.stdin.isatty():
+        return None
+    try:
+        if content := sys.stdin.read().strip():
+            sys.stdin = sys.__stdin__ = open("/dev/tty")
+            return content
+    except KeyboardInterrupt:
+        pass
+    except OSError:
+        return None
+
+    return None
+
+
+def load_config_or_exit() -> VibeConfig:
+    try:
+        return VibeConfig.load()
+    except MissingAPIKeyError:
+        run_onboarding()
+        return VibeConfig.load()
+    except MissingPromptFileError as e:
+        rprint(f"[yellow]Invalid system prompt id: {e}[/]")
+        sys.exit(1)
+    except ValueError as e:
+        rprint(f"[yellow]{e}[/]")
+        sys.exit(1)
+
+
+def bootstrap_config_files() -> None:
+    if not CONFIG_FILE.path.exists():
+        try:
+            VibeConfig.save_updates(VibeConfig.create_default())
+        except Exception as e:
+            rprint(f"[yellow]Could not create default config file: {e}[/]")
+
+    if not HISTORY_FILE.path.exists():
+        try:
+            HISTORY_FILE.path.parent.mkdir(parents=True, exist_ok=True)
+            HISTORY_FILE.path.write_text("Hello Vibe!\n", "utf-8")
+        except Exception as e:
+            rprint(f"[yellow]Could not create history file: {e}[/]")
+
+
+def load_session(
+    args: argparse.Namespace, config: VibeConfig
+) -> list[LLMMessage] | None:
+    if not args.continue_session and not args.resume:
+        return None
+
+    if not config.session_logging.enabled:
+        rprint(
+            "[red]Session logging is disabled. "
+            "Enable it in config to use --continue or --resume[/]"
+        )
+        sys.exit(1)
+
+    session_to_load = None
+    if args.continue_session:
+        session_to_load = SessionLoader.find_latest_session(config.session_logging)
+        if not session_to_load:
+            rprint(
+                f"[red]No previous sessions found in "
+                f"{config.session_logging.save_dir}[/]"
+            )
+            sys.exit(1)
+    else:
+        session_to_load = SessionLoader.find_session_by_id(
+            args.resume, config.session_logging
+        )
+        if not session_to_load:
+            rprint(
+                f"[red]Session '{args.resume}' not found in "
+                f"{config.session_logging.save_dir}[/]"
+            )
+            sys.exit(1)
+
+    try:
+        loaded_messages, _ = SessionLoader.load_session(session_to_load)
+        return loaded_messages
+    except Exception as e:
+        rprint(f"[red]Failed to load session: {e}[/]")
+        sys.exit(1)
+
+
+def _load_messages_from_previous_session(
+    agent_loop: AgentLoop, loaded_messages: list[LLMMessage]
+) -> None:
+    non_system_messages = [msg for msg in loaded_messages if msg.role != Role.system]
+    agent_loop.messages.extend(non_system_messages)
+    logger.info("Loaded %d messages from previous session", len(non_system_messages))
+
+
+def run_cli(args: argparse.Namespace) -> None:
+    load_dotenv_values()
+    bootstrap_config_files()
+
+    if args.setup:
+        run_onboarding()
+        sys.exit(0)
+
+    try:
+        initial_agent_name = get_initial_agent_name(args)
+        config = load_config_or_exit()
+
+        if args.enabled_tools:
+            config.enabled_tools = args.enabled_tools
+
+        loaded_messages = load_session(args, config)
+
+        stdin_prompt = get_prompt_from_stdin()
+        if args.prompt is not None:
+            programmatic_prompt = args.prompt or stdin_prompt
+            if not programmatic_prompt:
+                print(
+                    "Error: No prompt provided for programmatic mode", file=sys.stderr
+                )
+                sys.exit(1)
+            output_format = OutputFormat(
+                args.output if hasattr(args, "output") else "text"
+            )
+
+            try:
+                final_response = run_programmatic(
+                    config=config,
+                    prompt=programmatic_prompt,
+                    max_turns=args.max_turns,
+                    max_price=args.max_price,
+                    output_format=output_format,
+                    previous_messages=loaded_messages,
+                    agent_name=initial_agent_name,
+                )
+                if final_response:
+                    print(final_response)
+                sys.exit(0)
+            except ConversationLimitException as e:
+                print(e, file=sys.stderr)
+                sys.exit(1)
+            except RuntimeError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            agent_loop = AgentLoop(
+                config, agent_name=initial_agent_name, enable_streaming=True
+            )
+
+            if loaded_messages:
+                _load_messages_from_previous_session(agent_loop, loaded_messages)
+
+            run_textual_ui(
+                agent_loop=agent_loop,
+                initial_prompt=args.initial_prompt or stdin_prompt,
+                teleport_on_start=args.teleport,
+            )
+
+    except (KeyboardInterrupt, EOFError):
+        rprint("\n[dim]Bye![/]")
+        sys.exit(0)

vibe/cli/clipboard.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import base64
+import os
+
+from textual.app import App
+
+_PREVIEW_MAX_LENGTH = 40
+
+
+def _copy_osc52(text: str) -> None:
+    encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+    osc52_seq = f"\033]52;c;{encoded}\a"
+    if os.environ.get("TMUX"):
+        osc52_seq = f"\033Ptmux;\033{osc52_seq}\033\\"
+
+    with open("/dev/tty", "w") as tty:
+        tty.write(osc52_seq)
+        tty.flush()
+
+
+def _shorten_preview(texts: list[str]) -> str:
+    dense_text = "⏎".join(texts).replace("\n", "⏎")
+    if len(dense_text) > _PREVIEW_MAX_LENGTH:
+        return f"{dense_text[: _PREVIEW_MAX_LENGTH - 1]}…"
+    return dense_text
+
+
+def copy_selection_to_clipboard(app: App, show_toast: bool = True) -> str | None:
+    selected_texts = []
+
+    for widget in app.query("*"):
+        if not hasattr(widget, "text_selection") or not widget.text_selection:
+            continue
+
+        selection = widget.text_selection
+
+        try:
+            result = widget.get_selection(selection)
+        except Exception:
+            continue
+
+        if not result:
+            continue
+
+        selected_text, _ = result
+        if selected_text.strip():
+            selected_texts.append(selected_text)
+
+    if not selected_texts:
+        return None
+
+    combined_text = "\n".join(selected_texts)
+
+    try:
+        _copy_osc52(combined_text)
+        if show_toast:
+            app.notify(
+                f'"{_shorten_preview(selected_texts)}" copied to clipboard',
+                severity="information",
+                timeout=2,
+                markup=False,
+            )
+        return combined_text
+    except Exception:
+        app.notify(
+            "Failed to copy - clipboard not available", severity="warning", timeout=3
+        )
+        return None

vibe/cli/commands.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Command:
+    aliases: frozenset[str]
+    description: str
+    handler: str
+    exits: bool = False
+
+
+class CommandRegistry:
+    def __init__(self, excluded_commands: list[str] | None = None) -> None:
+        if excluded_commands is None:
+            excluded_commands = []
+        self.commands = {
+            "help": Command(
+                aliases=frozenset(["/help"]),
+                description="Show help message",
+                handler="_show_help",
+            ),
+            "config": Command(
+                aliases=frozenset(["/config", "/model"]),
+                description="Edit config settings",
+                handler="_show_config",
+            ),
+            "reload": Command(
+                aliases=frozenset(["/reload"]),
+                description="Reload configuration from disk",
+                handler="_reload_config",
+            ),
+            "clear": Command(
+                aliases=frozenset(["/clear"]),
+                description="Clear conversation history",
+                handler="_clear_history",
+            ),
+            "log": Command(
+                aliases=frozenset(["/log"]),
+                description="Show path to current interaction log file",
+                handler="_show_log_path",
+            ),
+            "compact": Command(
+                aliases=frozenset(["/compact"]),
+                description="Compact conversation history by summarizing",
+                handler="_compact_history",
+            ),
+            "exit": Command(
+                aliases=frozenset(["/exit"]),
+                description="Exit the application",
+                handler="_exit_app",
+                exits=True,
+            ),
+            "terminal-setup": Command(
+                aliases=frozenset(["/terminal-setup"]),
+                description="Configure Shift+Enter for newlines",
+                handler="_setup_terminal",
+            ),
+            "status": Command(
+                aliases=frozenset(["/status"]),
+                description="Display agent statistics",
+                handler="_show_status",
+            ),
+            "teleport": Command(
+                aliases=frozenset(["/teleport"]),
+                description="Teleport session to Vibe Nuage",
+                handler="_teleport_command",
+            ),
+            "proxy-setup": Command(
+                aliases=frozenset(["/proxy-setup"]),
+                description="Configure proxy and SSL certificate settings",
+                handler="_show_proxy_setup",
+            ),
+        }
+
+        for command in excluded_commands:
+            self.commands.pop(command, None)
+
+        self._alias_map = {}
+        for cmd_name, cmd in self.commands.items():
+            for alias in cmd.aliases:
+                self._alias_map[alias] = cmd_name
+
+    def find_command(self, user_input: str) -> Command | None:
+        cmd_name = self.get_command_name(user_input)
+        return self.commands.get(cmd_name) if cmd_name else None
+
+    def get_command_name(self, user_input: str) -> str | None:
+        return self._alias_map.get(user_input.lower().strip())
+
+    def get_help_text(self) -> str:
+        lines: list[str] = [
+            "### Keyboard Shortcuts",
+            "",
+            "- `Enter` Submit message",
+            "- `Ctrl+J` / `Shift+Enter` Insert newline",
+            "- `Escape` Interrupt agent or close dialogs",
+            "- `Ctrl+C` Quit (or clear input if text present)",
+            "- `Ctrl+G` Edit input in external editor",
+            "- `Ctrl+O` Toggle tool output view",
+            "- `Shift+Tab` Toggle auto-approve mode",
+            "",
+            "### Special Features",
+            "",
+            "- `!<command>` Execute bash command directly",
+            "- `@path/to/file/` Autocompletes file paths",
+            "",
+            "### Commands",
+            "",
+        ]
+
+        for cmd in self.commands.values():
+            aliases = ", ".join(f"`{alias}`" for alias in sorted(cmd.aliases))
+            lines.append(f"- {aliases}: {cmd.description}")
+        return "\n".join(lines)

vibe/cli/entrypoint.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+import sys
+
+from rich import print as rprint
+
+from vibe import __version__
+from vibe.core.agents.models import BuiltinAgentName
+from vibe.core.paths.config_paths import unlock_config_paths
+from vibe.core.trusted_folders import has_trustable_content, trusted_folders_manager
+from vibe.setup.trusted_folders.trust_folder_dialog import (
+    TrustDialogQuitException,
+    ask_trust_folder,
+)
+
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run the codeMaster interactive CLI")
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument(
+        "initial_prompt",
+        nargs="?",
+        metavar="PROMPT",
+        help="Initial prompt to start the interactive session with.",
+    )
+    parser.add_argument(
+        "-p",
+        "--prompt",
+        nargs="?",
+        const="",
+        metavar="TEXT",
+        help="Run in programmatic mode: send prompt, auto-approve all tools, "
+        "output response, and exit.",
+    )
+    parser.add_argument(
+        "--max-turns",
+        type=int,
+        metavar="N",
+        help="Maximum number of assistant turns "
+        "(only applies in programmatic mode with -p).",
+    )
+    parser.add_argument(
+        "--max-price",
+        type=float,
+        metavar="DOLLARS",
+        help="Maximum cost in dollars (only applies in programmatic mode with -p). "
+        "Session will be interrupted if cost exceeds this limit.",
+    )
+    parser.add_argument(
+        "--enabled-tools",
+        action="append",
+        metavar="TOOL",
+        help="Enable specific tools. In programmatic mode (-p), this disables "
+        "all other tools. "
+        "Can use exact names, glob patterns (e.g., 'bash*'), or "
+        "regex with 're:' prefix. Can be specified multiple times.",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        choices=["text", "json", "streaming"],
+        default="text",
+        help="Output format for programmatic mode (-p): 'text' "
+        "for human-readable (default), 'json' for all messages at end, "
+        "'streaming' for newline-delimited JSON per message.",
+    )
+    parser.add_argument(
+        "--agent",
+        metavar="NAME",
+        default=BuiltinAgentName.DEFAULT,
+        help="Agent to use (builtin: default, plan, accept-edits, auto-approve, "
+        "or custom from ~/.vibe/agents/NAME.toml)",
+    )
+    parser.add_argument("--setup", action="store_true", help="Setup API key and exit")
+    parser.add_argument(
+        "--workdir",
+        type=Path,
+        metavar="DIR",
+        help="Change to this directory before running",
+    )
+
+    # Feature flag for teleport, not exposed to the user yet
+    parser.add_argument("--teleport", action="store_true", help=argparse.SUPPRESS)
+
+    continuation_group = parser.add_mutually_exclusive_group()
+    continuation_group.add_argument(
+        "-c",
+        "--continue",
+        action="store_true",
+        dest="continue_session",
+        help="Continue from the most recent saved session",
+    )
+    continuation_group.add_argument(
+        "--resume",
+        metavar="SESSION_ID",
+        help="Resume a specific session by its ID (supports partial matching)",
+    )
+    return parser.parse_args()
+
+
+def check_and_resolve_trusted_folder() -> None:
+    try:
+        cwd = Path.cwd()
+    except FileNotFoundError:
+        rprint(
+            "[red]Error: Current working directory no longer exists.[/]\n"
+            "[yellow]The directory you started vibe from has been deleted. "
+            "Please change to an existing directory and try again, "
+            "or use --workdir to specify a working directory.[/]"
+        )
+        sys.exit(1)
+
+    if not has_trustable_content(cwd) or cwd.resolve() == Path.home().resolve():
+        return
+
+    is_folder_trusted = trusted_folders_manager.is_trusted(cwd)
+
+    if is_folder_trusted is not None:
+        return
+
+    try:
+        is_folder_trusted = ask_trust_folder(cwd)
+    except (KeyboardInterrupt, EOFError, TrustDialogQuitException):
+        sys.exit(0)
+    except Exception as e:
+        rprint(f"[yellow]Error showing trust dialog: {e}[/]")
+        return
+
+    if is_folder_trusted is True:
+        trusted_folders_manager.add_trusted(cwd)
+    elif is_folder_trusted is False:
+        trusted_folders_manager.add_untrusted(cwd)
+
+
+def main() -> None:
+    args = parse_arguments()
+
+    if args.workdir:
+        workdir = args.workdir.expanduser().resolve()
+        if not workdir.is_dir():
+            rprint(
+                f"[red]Error: --workdir does not exist or is not a directory: {workdir}[/]"
+            )
+            sys.exit(1)
+        os.chdir(workdir)
+
+    is_interactive = args.prompt is None
+    if is_interactive:
+        check_and_resolve_trusted_folder()
+    unlock_config_paths()
+
+    from vibe.cli.cli import run_cli
+
+    run_cli(args)
+
+
+if __name__ == "__main__":
+    main()

vibe/cli/history_manager.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class HistoryManager:
+    def __init__(self, history_file: Path, max_entries: int = 100) -> None:
+        self.history_file = history_file
+        self.max_entries = max_entries
+        self._entries: list[str] = []
+        self._current_index: int = -1
+        self._temp_input: str = ""
+        self._load_history()
+
+    def _load_history(self) -> None:
+        if not self.history_file.exists():
+            return
+
+        try:
+            with self.history_file.open("r", encoding="utf-8") as f:
+                entries = []
+                for raw_line in f:
+                    raw_line = raw_line.rstrip("\n\r")
+                    if not raw_line:
+                        continue
+                    try:
+                        entry = json.loads(raw_line)
+                    except json.JSONDecodeError:
+                        entry = raw_line
+                    entries.append(entry if isinstance(entry, str) else str(entry))
+                self._entries = entries[-self.max_entries :]
+        except (OSError, UnicodeDecodeError):
+            self._entries = []
+
+    def _save_history(self) -> None:
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("w", encoding="utf-8") as f:
+                for entry in self._entries:
+                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        except OSError:
+            pass
+
+    def add(self, text: str) -> None:
+        text = text.strip()
+        if not text or text.startswith("/"):
+            return
+
+        if self._entries and self._entries[-1] == text:
+            return
+
+        self._entries.append(text)
+
+        if len(self._entries) > self.max_entries:
+            self._entries = self._entries[-self.max_entries :]
+
+        self._save_history()
+        self.reset_navigation()
+
+    def get_previous(self, current_input: str, prefix: str = "") -> str | None:
+        if not self._entries:
+            return None
+
+        if self._current_index == -1:
+            self._temp_input = current_input
+            self._current_index = len(self._entries)
+
+        for i in range(self._current_index - 1, -1, -1):
+            if self._entries[i].startswith(prefix):
+                self._current_index = i
+                return self._entries[i]
+
+        return None
+
+    def get_next(self, prefix: str = "") -> str | None:
+        if self._current_index == -1:
+            return None
+
+        for i in range(self._current_index + 1, len(self._entries)):
+            if self._entries[i].startswith(prefix):
+                self._current_index = i
+                return self._entries[i]
+
+        result = self._temp_input
+        self.reset_navigation()
+        return result
+
+    def reset_navigation(self) -> None:
+        self._current_index = -1
+        self._temp_input = ""

vibe/cli/plan_offer/adapters/http_whoami_gateway.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+import httpx
+
+from vibe.cli.plan_offer.ports.whoami_gateway import (
+    WhoAmIGatewayError,
+    WhoAmIGatewayUnauthorized,
+    WhoAmIResponse,
+)
+
+BASE_URL = "https://console.mistral.ai"
+WHOAMI_PATH = "/api/vibe/whoami"
+
+
+class HttpWhoAmIGateway:
+    def __init__(self, base_url: str = BASE_URL) -> None:
+        self._base_url = base_url.rstrip("/")
+
+    async def whoami(self, api_key: str) -> WhoAmIResponse:
+        url = f"{self._base_url}{WHOAMI_PATH}"
+        headers = {"Authorization": f"Bearer {api_key}"}
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, headers=headers)
+        except httpx.RequestError as exc:
+            raise WhoAmIGatewayError() from exc
+
+        if response.status_code in {httpx.codes.UNAUTHORIZED, httpx.codes.FORBIDDEN}:
+            raise WhoAmIGatewayUnauthorized()
+        if not response.is_success:
+            raise WhoAmIGatewayError(f"Unexpected status {response.status_code}")
+
+        payload = _safe_json(response) or {}
+        return WhoAmIResponse(
+            is_pro_plan=_parse_bool(payload.get("is_pro_plan")),
+            advertise_pro_plan=_parse_bool(payload.get("advertise_pro_plan")),
+            prompt_switching_to_pro_plan=_parse_bool(
+                payload.get("prompt_switching_to_pro_plan")
+            ),
+        )
+
+
+def _safe_json(response: httpx.Response) -> Mapping[str, object] | None:
+    try:
+        data = response.json()
+    except ValueError:
+        return None
+    return cast(Mapping[str, object], data) if isinstance(data, dict) else None
+
+
+def _parse_bool(value: object | None) -> bool:
+    if value is None:
+        return False
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        match value.strip().lower():
+            case "true":
+                return True
+            case "false":
+                return False
+            case _:
+                raise WhoAmIGatewayError("Invalid boolean string in whoami response")
+    raise WhoAmIGatewayError("Invalid boolean value in whoami response")