bro-cli 0.1.1.4__py3-none-any.whl

bro_cli/__init__.py

@@ -0,0 +1,4 @@
+"""bro_cli package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

bro_cli/config.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+ENV_API_KEY = "BRO_GEMINI_KEY"
+_CONFIG_DIR_NAME = "bro"
+_CONFIG_FILE_NAME = "config.json"
+
+
+def get_config_path() -> Path:
+    """Return the Linux-friendly config path for bro."""
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        base_dir = Path(xdg_config_home)
+    else:
+        base_dir = Path.home() / ".config"
+    return base_dir / _CONFIG_DIR_NAME / _CONFIG_FILE_NAME
+
+
+def prompt_for_api_key() -> str:
+    """Prompt user for API key until a non-empty value is provided."""
+    while True:
+        value = input("Enter your Gemini API key: ").strip()
+        if value:
+            return value
+        print("API key cannot be empty.")
+
+
+def save_api_key(api_key: str) -> Path:
+    """Persist API key to config file with mode 0600."""
+    config_path = get_config_path()
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with config_path.open("w", encoding="utf-8") as f:
+        json.dump({"api_key": api_key}, f)
+
+    os.chmod(config_path, 0o600)
+    return config_path
+
+
+def load_api_key_from_file() -> Optional[str]:
+    """Read API key from config file when available and valid."""
+    config_path = get_config_path()
+    if not config_path.exists():
+        return None
+
+    try:
+        with config_path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+
+    value = data.get("api_key") if isinstance(data, dict) else None
+    if not value or not isinstance(value, str):
+        return None
+    return value.strip() or None
+
+
+def resolve_api_key() -> Optional[str]:
+    """Resolve key from env first, then config file."""
+    env_value = os.environ.get(ENV_API_KEY, "").strip()
+    if env_value:
+        return env_value
+    return load_api_key_from_file()

bro_cli/gemini_client.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+try:
+    from google import genai
+    from google.genai import types
+except ImportError:  # pragma: no cover - depends on local install state
+    genai = None
+    types = None
+
+
+SYSTEM_INSTRUCTION = (
+    "You are a Linux terminal assistant with a friendly, human-like personality. "
+    "Act like a smart, slightly witty buddy who helps efficiently. "
+    "Keep responses concise but not robotic. "
+    "You may use light humor, casual phrasing, and opinions when appropriate. "
+    "Avoid long explanations unless asked. "
+    "No markdown formatting. Plain text only. "
+    "Prioritize clarity and usefulness over strict brevity."
+    "Sound like a developer friend, not a documentation page."
+    "STRICT RULE: NEVER use Markdown symbols. NO asterisks (*), NO hashtags (#), "
+    "NO bold text, NO bullet points using *. "
+    "For lists, use plain dashes (-) or simple indentation. "
+    "Your output must be pure plain text that looks good in a raw terminal. "
+    "Sound like a developer friend chatting, not a documentation page."
+)
+
+
+
+@dataclass
+class ClientError(Exception):
+    message: str
+    exit_code: int = 1
+
+
+class GeminiClient:
+    def __init__(self, api_key: str, use_search: bool = False) -> None:
+        if genai is None or types is None:
+            raise ClientError(
+                "Missing dependency: google-genai. Install bro again with its Python dependencies.",
+                exit_code=1,
+            )
+        self._client = genai.Client(api_key=api_key)
+        self._use_search = use_search
+        # Use a model that supports search for search tasks, and lite for normal tasks.
+        self._model = "gemini-3-flash-preview" if use_search else "gemini-2.5-flash-lite"
+
+    def _get_config(self) -> types.GenerateContentConfig:
+        config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTION,
+            max_output_tokens=500,  # Enforce brevity at the API level
+        )
+        if self._use_search:
+            config.tools = [
+                types.Tool(
+                    google_search=types.GoogleSearch()
+                )
+            ]
+        return config
+
+    def ask(self, prompt: str) -> str:
+        response = self._client.models.generate_content(
+            model=self._model,
+            contents=prompt,
+            config=self._get_config(),
+        )
+        text = getattr(response, "text", None)
+        if text and text.strip():
+            return text.strip()
+        return "No response text returned by Gemini."
+
+    def start_chat(self) -> "GeminiChatSession":
+        return GeminiChatSession(
+            self._client.chats.create(
+                model=self._model,
+                history=[],
+                config=self._get_config(),
+            )
+        )
+
+
+class GeminiChatSession:
+    def __init__(self, chat_session) -> None:
+        self._chat_session = chat_session
+
+    def ask(self, prompt: str) -> str:
+        response = self._chat_session.send_message(prompt)
+        text = getattr(response, "text", None)
+        if text and text.strip():
+            return text.strip()
+        return "No response text returned by Gemini."
+
+
+def map_exception(exc: Exception) -> ClientError:
+    """Map Gemini SDK and transport errors to stable CLI messages."""
+    exc_name = exc.__class__.__name__.lower()
+    raw_message = str(exc).lower()
+
+    if "unauth" in exc_name or "permission" in exc_name or "api key" in raw_message:
+        return ClientError("API key rejected. Run 'bro config' to update it.", exit_code=1)
+
+    if "resourceexhausted" in exc_name or "ratelimit" in raw_message or "429" in raw_message:
+        return ClientError("Rate limited by Gemini. Please retry shortly.", exit_code=2)
+
+    if "serviceunavailable" in exc_name or "503" in raw_message:
+        return ClientError("Gemini service unavailable. Retry in a moment.", exit_code=2)
+
+    if "connection" in raw_message or "network" in raw_message or "timeout" in raw_message:
+        return ClientError("Network error while contacting Gemini.", exit_code=2)
+
+    return ClientError(f"Unexpected Gemini error: {exc}", exit_code=2)

bro_cli/main.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Sequence
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.theme import Theme
+
+from .config import get_config_path, prompt_for_api_key, resolve_api_key, save_api_key
+from .gemini_client import ClientError, GeminiClient, map_exception
+
+# Professional Cyberpunk Theme
+custom_theme = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "bold red",
+    "prompt": "bold green",
+    "ai_name": "bold magenta",
+})
+console = Console(theme=custom_theme)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bro",
+        description="Linux terminal client for chatting with Gemini",
+    )
+    parser.add_argument(
+        "-s",
+        "--search",
+        action="store_true",
+        help="Enable web search capability (grounding)",
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        help="Use config to set the API key, or provide a prompt to chat",
+    )
+    parser.add_argument(
+        "prompt",
+        nargs=argparse.REMAINDER,
+        help="Question to ask Gemini",
+    )
+    return parser
+
+
+def run_config() -> int:
+    existing = resolve_api_key()
+    if existing:
+        print("An API key is already configured. Saving will overwrite the stored key.")
+
+    api_key = prompt_for_api_key()
+    path = save_api_key(api_key)
+    print("API key saved.")
+    print(f"Config file: {path}")
+    return 0
+
+
+def _load_client(use_search: bool = False) -> GeminiClient:
+    api_key = resolve_api_key()
+    if not api_key:
+        raise ClientError(
+            "Gemini API key is missing. Run 'bro config' to set it.",
+            exit_code=1,
+        )
+    return GeminiClient(api_key=api_key, use_search=use_search)
+
+
+def run_single_prompt(prompt_text: str, use_search: bool = False) -> int:
+    try:
+        client = _load_client(use_search=use_search)
+        with console.status("[bold cyan]Bro is thinking...", spinner="dots"):
+            response = client.ask(prompt_text)
+        
+        console.print(Panel(
+            response,
+            title="[ai_name]Bro",
+            title_align="left",
+            border_style="magenta",
+            padding=(1, 2)
+        ))
+        return 0
+    except ClientError as exc:
+        console.print(f"[error]{exc.message}[/error]", style="red")
+        return exc.exit_code
+    except Exception as exc:  # pragma: no cover - defensive layer
+        err = map_exception(exc)
+        console.print(f"[error]{err.message}[/error]", style="red")
+        return err.exit_code
+
+
+def run_interactive_chat(use_search: bool = False) -> int:
+    try:
+        client = _load_client(use_search=use_search)
+        chat = client.start_chat()
+    except ClientError as exc:
+        console.print(f"[error]{exc.message}[/error]")
+        return exc.exit_code
+
+    mode_info = " [dim](Search enabled)[/dim]" if use_search else ""
+    console.print(f"[info]Interactive mode{mode_info}. Type 'exit' or 'quit' to leave.[/info]")
+    
+    while True:
+        try:
+            # Styled prompt using rich.prompt.Prompt or just console.print
+            user_input = Prompt.ask("[prompt]bro[/prompt]")
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[info]Exiting. Catch ya later![/info]")
+            return 0
+
+        if not user_input:
+            continue
+        if user_input.lower() in {"exit", "quit"}:
+            console.print("[info]Exiting. Catch ya later![/info]")
+            return 0
+
+        try:
+            with console.status("[bold cyan]Thinking...", spinner="dots"):
+                response = chat.ask(user_input)
+            
+            console.print(Panel(
+                response,
+                title="[ai_name]Bro",
+                title_align="left",
+                border_style="magenta",
+                padding=(1, 2)
+            ))
+        except Exception as exc:
+            err = map_exception(exc)
+            console.print(f"[error]{err.message}[/error]")
+            return err.exit_code
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "config" and not args.prompt:
+        return run_config()
+
+    if args.command == "config" and args.prompt:
+        parser.error("'config' does not accept a chat prompt")
+
+    if args.command is not None:
+        prompt_parts = [args.command, *args.prompt]
+        return run_single_prompt(" ".join(prompt_parts).strip(), use_search=args.search)
+
+    # No prompt and no subcommand means REPL mode.
+    return run_interactive_chat(use_search=args.search)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bro_cli-0.1.1.4.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: bro-cli
+Version: 0.1.1.4
+Summary: Linux terminal Gemini client with secure local API key config
+Author: Aether
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: google-genai>=1.20.0
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# Bro CLI
+
+A lightweight, fast, and secure Linux terminal client for Google's Gemini AI. 
+
+`bro` allows you to interact with Gemini directly from your command line, offering both single-prompt execution and a persistent interactive chat mode. It securely manages your API credentials using standard Linux XDG directories.
+
+## Features
+
+- **Interactive & Single-Prompt Modes:** Seamlessly switch between quick one-off questions and interactive conversational sessions.
+- **Secure Credential Management:** API keys are stored securely in `~/.config/bro/config.json` with strict user-only (`0600`) file permissions.
+- **Environment Variable Support:** Override stored configurations on the fly using the `BRO_GEMINI_KEY` environment variable.
+- **Terminal-Optimized Output:** Instructs Gemini to return direct, concise answers without unnecessary markdown formatting or conversational filler.
+
+## Requirements
+
+- Linux
+- Python 3.10 or higher
+- [pipx](https://pipx.pypa.io/) (Required for isolated global CLI installation)
+
+## Installation
+
+Install `bro-cli` globally as an isolated application using `pipx`. 
+
+To install directly from your Git repository:
+
+```bash
+pipx install git+https://github.com/PromitSarker/Bro-CLI.git
+```
+
+**Local Installation:**
+If you have cloned the repository to your local machine, you can navigate to the project folder and install it by running:
+```bash
+pipx install .
+```
+
+**Updating:**
+To upgrade to the latest version in the future:
+```bash
+pipx upgrade bro-cli
+```
+
+## Configuration
+
+Before using the client, you *must* configure your Google Gemini API key. Run the following command:
+
+```bash
+bro config
+```
+
+You will be prompted to paste your API key. It will be saved securely to your system.
+
+## Usage
+
+### Single Prompt
+
+Ask a direct question. The client will return the answer to your standard output and exit:
+
+```bash
+bro "Why life so hard ?"
+```
+
+*Note: You can also skip the quotes for simple queries:*
+```bash
+bro how to go and breathe ?
+```
+
+### Interactive Mode
+
+Start a multi-turn chat session by running the command without any arguments:
+
+```bash
+bro
+```
+
+*Inside the interactive prompt, type `exit`, `quit`, or press `Ctrl+C`/`Ctrl+D` to end the session.*
+
+## Technical Details
+
+- **Default Model:** `gemini-2.5-flash-lite`
+- **SDK:** Powered by the official `google-genai` Python SDK.

bro_cli-0.1.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+bro_cli/__init__.py,sha256=7DeUeTgAqNqa6i2BfRkpkEUciONNmkXMiKI7ByXqZ3Q,72
+bro_cli/config.py,sha256=PS8QvwCdgr9VqeTkzJ7JGet5Xl_t5EiXMY6Ip63LLzg,1914
+bro_cli/gemini_client.py,sha256=KfXLytL6F6uvGQZVfHrc5BKIftg1W53L8gRcZ4g_hI8,4184
+bro_cli/main.py,sha256=Ub2caZuoPceWKPxg-t7E5uwmKW2wV_e1f7XeQJGVap4,4754
+bro_cli-0.1.1.4.dist-info/METADATA,sha256=b1j1jEXr1Yy3yBNbghxg4bQLaqyVlr4f1EE1mMUEMRQ,2660
+bro_cli-0.1.1.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bro_cli-0.1.1.4.dist-info/entry_points.txt,sha256=7hwnDDXGBHdSQVZfuSoakeZxrTnv1uDgl7etJbOv1Uo,42
+bro_cli-0.1.1.4.dist-info/top_level.txt,sha256=KXV5cgSvg4V_kKTOPMjf8vTNq_6o0itjFcn-1GxygeI,8
+bro_cli-0.1.1.4.dist-info/RECORD,,

bro_cli-0.1.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bro_cli-0.1.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bro = bro_cli.main:main

bro_cli-0.1.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+bro_cli