yaicli 0.0.10__tar.gz → 0.0.12__tar.gz

{yaicli-0.0.10 → yaicli-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.0.10
+Version: 0.0.12
 Summary: A simple CLI tool to interact with LLM
 Project-URL: Homepage, https://github.com/belingud/yaicli
 Project-URL: Repository, https://github.com/belingud/yaicli
@@ -214,14 +214,15 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
 Requires-Dist: distro>=1.9.0
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: prompt-toolkit>=3.0.50
-Requires-Dist: requests>=2.32.3
 Requires-Dist: rich>=13.9.4
+Requires-Dist: socksio>=1.0.0
 Requires-Dist: typer>=0.15.2
 Description-Content-Type: text/markdown
 
-# YAICLI - Your AI Command Line Interface
+# YAICLI - Your AI Interface in Command Line
 
 [![PyPI version](https://img.shields.io/pypi/v/yaicli?style=for-the-badge)](https://pypi.org/project/yaicli/)
 ![GitHub License](https://img.shields.io/github/license/belingud/yaicli?style=for-the-badge)
@@ -318,6 +319,10 @@ ANSWER_PATH=choices[0].message.content
 # true: streaming response
 # false: non-streaming response
 STREAM=true
+
+TEMPERATURE=0.7
+TOP_P=1.0
+MAX_TOKENS=1024
 ```
 
 ### Configuration Options
@@ -405,33 +410,41 @@ ai --verbose "Explain quantum computing"
 
 ### Command Line Options
 
+Arguments:
 - `<PROMPT>`: Argument
-- `--verbose` or `-V`: Show verbose information
-- `--chat` or `-c`: Start in chat mode
-- `--shell` or `-s`: Generate and execute shell command
+
+Options:
 - `--install-completion`: Install completion for the current shell
 - `--show-completion`: Show completion for the current shell, to copy it or customize the installation
 - `--help` or `-h`: Show this message and exit
+- `--template`: Show the config template.
+
+Run Options:
+- `--verbose` or `-V`: Show verbose information
+- `--chat` or `-c`: Start in chat mode
+- `--shell` or `-s`: Generate and execute shell command
 
 ```bash
 ai -h
 
- Usage: ai [OPTIONS] [PROMPT]
-
- yaicli. Your AI interface in cli.
-
-╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│   prompt      [PROMPT]  The prompt send to the LLM                                                                                                       │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ --verbose             -V        Show verbose information                                                                                                 │
-│ --chat                -c        Start in chat mode                                                                                                       │
-│ --shell               -s        Generate and execute shell command                                                                                       │
-│ --install-completion            Install completion for the current shell.                                                                                │
-│ --show-completion               Show completion for the current shell, to copy it or customize the installation.                                         │
-│ --help                -h        Show this message and exit.                                                                                              │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-
+Usage: ai [OPTIONS] [PROMPT]                                                                                                                                              
+                                                                                                                                                                           
+ yaicli - Your AI interface in cli.                                                                                                                                        
+                                                                                                                                                                           
+╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│   prompt      [PROMPT]  The prompt send to the LLM                                                                                                                      │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --template                      Show the config template.                                                                                                               │
+│ --install-completion            Install completion for the current shell.                                                                                               │
+│ --show-completion               Show completion for the current shell, to copy it or customize the installation.                                                        │
+│ --help                -h        Show this message and exit.                                                                                                             │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Run Option ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --chat     -c        Start in chat mode                                                                                                                                 │
+│ --shell    -s        Generate and execute shell command                                                                                                                 │
+│ --verbose  -V        Show verbose information                                                                                                                           │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 
 ```
 
@@ -514,4 +527,4 @@ Contributions of code, issue reports, or feature suggestions are welcome.
 
 ---
 
-*YAICLI - Making your terminal smarter*
+*YAICLI - Making your terminal smarter*

{yaicli-0.0.10 → yaicli-0.0.12}/README.md

@@ -1,4 +1,4 @@
-# YAICLI - Your AI Command Line Interface
+# YAICLI - Your AI Interface in Command Line
 
 [![PyPI version](https://img.shields.io/pypi/v/yaicli?style=for-the-badge)](https://pypi.org/project/yaicli/)
 ![GitHub License](https://img.shields.io/github/license/belingud/yaicli?style=for-the-badge)
@@ -95,6 +95,10 @@ ANSWER_PATH=choices[0].message.content
 # true: streaming response
 # false: non-streaming response
 STREAM=true
+
+TEMPERATURE=0.7
+TOP_P=1.0
+MAX_TOKENS=1024
 ```
 
 ### Configuration Options
@@ -182,33 +186,41 @@ ai --verbose "Explain quantum computing"
 
 ### Command Line Options
 
+Arguments:
 - `<PROMPT>`: Argument
-- `--verbose` or `-V`: Show verbose information
-- `--chat` or `-c`: Start in chat mode
-- `--shell` or `-s`: Generate and execute shell command
+
+Options:
 - `--install-completion`: Install completion for the current shell
 - `--show-completion`: Show completion for the current shell, to copy it or customize the installation
 - `--help` or `-h`: Show this message and exit
+- `--template`: Show the config template.
+
+Run Options:
+- `--verbose` or `-V`: Show verbose information
+- `--chat` or `-c`: Start in chat mode
+- `--shell` or `-s`: Generate and execute shell command
 
 ```bash
 ai -h
 
- Usage: ai [OPTIONS] [PROMPT]
-
- yaicli. Your AI interface in cli.
-
-╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│   prompt      [PROMPT]  The prompt send to the LLM                                                                                                       │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ --verbose             -V        Show verbose information                                                                                                 │
-│ --chat                -c        Start in chat mode                                                                                                       │
-│ --shell               -s        Generate and execute shell command                                                                                       │
-│ --install-completion            Install completion for the current shell.                                                                                │
-│ --show-completion               Show completion for the current shell, to copy it or customize the installation.                                         │
-│ --help                -h        Show this message and exit.                                                                                              │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-
+Usage: ai [OPTIONS] [PROMPT]                                                                                                                                              
+                                                                                                                                                                           
+ yaicli - Your AI interface in cli.                                                                                                                                        
+                                                                                                                                                                           
+╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│   prompt      [PROMPT]  The prompt send to the LLM                                                                                                                      │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --template                      Show the config template.                                                                                                               │
+│ --install-completion            Install completion for the current shell.                                                                                               │
+│ --show-completion               Show completion for the current shell, to copy it or customize the installation.                                                        │
+│ --help                -h        Show this message and exit.                                                                                                             │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Run Option ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --chat     -c        Start in chat mode                                                                                                                                 │
+│ --shell    -s        Generate and execute shell command                                                                                                                 │
+│ --verbose  -V        Show verbose information                                                                                                                           │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 
 ```
 
@@ -291,4 +303,4 @@ Contributions of code, issue reports, or feature suggestions are welcome.
 
 ---
 
-*YAICLI - Making your terminal smarter*
+*YAICLI - Making your terminal smarter*

{yaicli-0.0.10 → yaicli-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.0.10"
+version = "0.0.12"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"
@@ -31,10 +31,11 @@ keywords = [
 ]
 dependencies = [
     "distro>=1.9.0",
+    "httpx>=0.28.1",
     "jmespath>=1.0.1",
     "prompt-toolkit>=3.0.50",
-    "requests>=2.32.3",
     "rich>=13.9.4",
+    "socksio>=1.0.0",
     "typer>=0.15.2",
 ]
 [project.urls]
@@ -45,17 +46,22 @@ Documentation = "https://github.com/belingud/yaicli"
 [project.scripts]
 ai = "yaicli:app"
 
+[tool.pdm.scripts]
+bump = "bump2version {args}"
+changelog = "just changelog"
+
 [tool.uv]
 resolution = "highest"
 
 [dependency-groups]
 dev = ["bump2version>=1.0.1", "pytest>=8.3.5", "ruff>=0.11.2"]
 
+[tool.isort]
+profile = "black"
+
 [tool.ruff]
 line-length = 120
-select = ["E", "F", "W", "I", "B", "C90"]
-ignore = ["E501"]
-
+fix = true
 
 [build-system]
 requires = ["hatchling>=1.18.0"]

{yaicli-0.0.10 → yaicli-0.0.12}/yaicli.py

@@ -5,13 +5,15 @@ import subprocess
 from os import getenv
 from os.path import basename, pathsep
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated, Optional, Union
 
+import httpx
 import jmespath
-import requests
 import typer
 from distro import name as distro_name
 from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.keys import Keys
 from rich.console import Console
@@ -37,6 +39,7 @@ DEFAULT_PROMPT = (
 
 CMD_CLEAR = "/clear"
 CMD_EXIT = "/exit"
+CMD_HISTORY = "/his"
 
 EXEC_MODE = "exec"
 CHAT_MODE = "chat"
@@ -53,23 +56,7 @@ DEFAULT_CONFIG_MAP = {
     "STREAM": {"value": "true", "env_key": "AI_STREAM"},
 }
 
-app = typer.Typer(
-    name="yaicli",
-    context_settings={"help_option_names": ["-h", "--help"]},
-    pretty_exceptions_enable=False,
-)
-
-
-class CasePreservingConfigParser(configparser.RawConfigParser):
-    """Case preserving config parser"""
-
-    def optionxform(self, optionstr):
-        return optionstr
-
-
-class CLI:
-    CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
-    DEFAULT_CONFIG_INI = """[core]
+DEFAULT_CONFIG_INI = """[core]
 PROVIDER=openai
 BASE_URL=https://api.openai.com/v1
 API_KEY=
@@ -86,7 +73,28 @@ ANSWER_PATH=choices[0].message.content
 
 # true: streaming response
 # false: non-streaming response
-STREAM=true"""
+STREAM=true
+
+TEMPERATURE=0.7
+TOP_P=1.0
+MAX_TOKENS=1024"""
+
+app = typer.Typer(
+    name="yaicli",
+    context_settings={"help_option_names": ["-h", "--help"]},
+    pretty_exceptions_enable=False,
+)
+
+
+class CasePreservingConfigParser(configparser.RawConfigParser):
+    """Case preserving config parser"""
+
+    def optionxform(self, optionstr):
+        return optionstr
+
+
+class CLI:
+    CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
 
     def __init__(self, verbose: bool = False) -> None:
         self.verbose = verbose
@@ -98,6 +106,19 @@ STREAM=true"""
         self.max_history_length = 25
         self.current_mode = TEMP_MODE
 
+    def prepare_chat_loop(self) -> None:
+        """Setup key bindings and history for chat mode"""
+        self._setup_key_bindings()
+        # Initialize history
+        Path("~/.yaicli_history").expanduser().touch(exist_ok=True)
+        self.session = PromptSession(
+            key_bindings=self.bindings,
+            completer=WordCompleter(["/clear", "/exit", "/his"]),
+            complete_while_typing=True,
+            history=FileHistory(Path("~/.yaicli_history").expanduser()),
+            enable_history_search=True,
+        )
+
     def _setup_key_bindings(self) -> None:
         """Setup keyboard shortcuts"""
 
@@ -122,7 +143,7 @@ STREAM=true"""
             self.console.print("[bold yellow]Creating default configuration file.[/bold yellow]")
             self.CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
             with open(self.CONFIG_PATH, "w") as f:
-                f.write(self.DEFAULT_CONFIG_INI)
+                f.write(DEFAULT_CONFIG_INI)
         else:
             # Load from configuration file (middle priority)
             config_parser = CasePreservingConfigParser()
@@ -179,10 +200,11 @@ STREAM=true"""
         example:
         ```bash\nls -la\n``` ==> ls -al
         ```zsh\nls -la\n``` ==> ls -al
-        ```ls -al``` ==> ls -al
-        ls -al ==> ls -al
+        ```ls -la``` ==> ls -la
+        ls -la ==> ls -la
         ```\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
         ```bash\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
+        ```plaintext\nls -la\n``` ==> ls -la
         """
         if not command or not command.strip():
             return ""
@@ -210,25 +232,35 @@ STREAM=true"""
             # Join the remaining lines and strip any extra whitespace
             return "\n".join(line.strip() for line in content_lines if line.strip())
 
-    def post(self, message: list[dict[str, str]]) -> requests.Response:
+    def _get_type_number(self, key, _type: type, default=None):
+        """Get number with type from config"""
+        try:
+            return _type(self.config.get(key, default))
+        except ValueError:
+            raise ValueError(f"[red]{key} should be {_type} type.[/red]")
+
+    def post(self, message: list[dict[str, str]]) -> httpx.Response:
         """Post message to LLM API and return response"""
         url = self.config.get("BASE_URL", "").rstrip("/") + "/" + self.config.get("COMPLETION_PATH", "").lstrip("/")
         body = {
             "messages": message,
             "model": self.config.get("MODEL", "gpt-4o"),
             "stream": self.config.get("STREAM", "true") == "true",
-            "temperature": 0.7,
-            "top_p": 1,
+            "temperature": self._get_type_number(key="TEMPERATURE", _type=float, default="0.7"),
+            "top_p": self._get_type_number(key="TOP_P", _type=float, default="1.0"),
+            "max_tokens": self._get_type_number(key="MAX_TOKENS", _type=int, default="1024"),
         }
-        response = requests.post(url, json=body, headers={"Authorization": f"Bearer {self.config.get('API_KEY', '')}"})
+        with httpx.Client(timeout=120.0) as client:
+            response = client.post(
+                url, json=body, headers={"Authorization": f"Bearer {self.config.get('API_KEY', '')}"}
+            )
         try:
             response.raise_for_status()
-        except requests.exceptions.HTTPError as e:
+        except httpx.HTTPStatusError as e:
             self.console.print(f"[red]Error calling API: {e}[/red]")
             if self.verbose:
-                self.console.print(f"Reason: {e.response.reason}")
-                self.console.print(f"Response: {response.text}")
-            raise typer.Exit(code=1) from None
+                self.console.print(f"Reason: {e}\nResponse: {response.text}")
+            raise e
         return response
 
     def get_reasoning_content(self, delta: dict) -> Optional[str]:
@@ -239,60 +271,83 @@ STREAM=true"""
                 return delta[k]
         return None
 
-    def _print_stream(self, response: requests.Response) -> str:
+    def _parse_stream_line(self, line: Union[bytes, str]) -> Optional[dict]:
+        """Parse a single line from the stream response"""
+        if not line:
+            return None
+
+        if isinstance(line, bytes):
+            line = line.decode("utf-8")
+        if not line.startswith("data: "):
+            return None
+
+        line = line[6:]
+        if line == "[DONE]":
+            return None
+
+        try:
+            json_data = json.loads(line)
+            if not json_data.get("choices"):
+                return None
+
+            return json_data
+        except json.JSONDecodeError:
+            self.console.print("[red]Error decoding response JSON[/red]")
+            if self.verbose:
+                self.console.print(f"[red]Error JSON data: {line}[/red]")
+            return None
+
+    def _process_reasoning_content(self, reason: str, full_completion: str, in_reasoning: bool) -> tuple[str, bool]:
+        """Process reasoning content in the response"""
+        if not in_reasoning:
+            in_reasoning = True
+            full_completion = "> Reasoning:\n> "
+        full_completion += reason.replace("\n", "\n> ")
+        return full_completion, in_reasoning
+
+    def _process_regular_content(self, content: str, full_completion: str, in_reasoning: bool) -> tuple[str, bool]:
+        """Process regular content in the response"""
+        if in_reasoning:
+            in_reasoning = False
+            full_completion += "\n\n"
+        full_completion += content
+        return full_completion, in_reasoning
+
+    def _print_stream(self, response: httpx.Response) -> str:
         """Print response from LLM in streaming mode"""
         full_completion = ""
         in_reasoning = False
 
         with Live() as live:
             for line in response.iter_lines():
-                if not line:
+                json_data = self._parse_stream_line(line)
+                if not json_data:
                     continue
 
-                data = line.decode("utf-8")
-                if not data.startswith("data: "):
-                    continue
+                delta = json_data["choices"][0]["delta"]
+                reason = self.get_reasoning_content(delta)
+
+                if reason is not None:
+                    full_completion, in_reasoning = self._process_reasoning_content(
+                        reason, full_completion, in_reasoning
+                    )
+                else:
+                    content = delta.get("content", "") or ""
+                    full_completion, in_reasoning = self._process_regular_content(
+                        content, full_completion, in_reasoning
+                    )
 
-                data = data[6:]
-                if data == "[DONE]":
-                    break
-
-                try:
-                    json_data = json.loads(data)
-                    if not json_data.get("choices"):
-                        continue
-
-                    delta = json_data["choices"][0]["delta"]
-                    reason = self.get_reasoning_content(delta)
-
-                    if reason is not None:
-                        # reasoning started
-                        if not in_reasoning:
-                            in_reasoning = True
-                            full_completion = "> Reasoning:\n> "
-                        full_completion += reason.replace("\n", "\n> ")
-                    else:
-                        # reasoning stoped
-                        if in_reasoning:
-                            in_reasoning = False
-                            full_completion += "\n\n"
-                        content = delta.get("content", "") or ""
-                        full_completion += content
-                    live.update(Markdown(markup=full_completion), refresh=True)
-                except json.JSONDecodeError:
-                    self.console.print("[red]Error decoding response JSON[/red]")
-                    if self.verbose:
-                        self.console.print(f"[red]Error: {data}[/red]")
+                live.update(Markdown(markup=full_completion), refresh=True)
 
         return full_completion
 
-    def _print_non_stream(self, response: requests.Response) -> str:
+    def _print_non_stream(self, response: httpx.Response) -> str:
         """Print response from LLM in non-streaming mode"""
         full_completion = jmespath.search(self.config.get("ANSWER_PATH", "choices[0].message.content"), response.json())
         self.console.print(Markdown(full_completion))
         return full_completion
 
-    def _print(self, response: requests.Response, stream: bool = True) -> str:
+    def _print(self, response: httpx.Response, stream: bool = True) -> str:
         """Print response from LLM and return full completion"""
         if stream:
             # Streaming response
@@ -305,12 +360,7 @@ STREAM=true"""
 
     def get_prompt_tokens(self) -> list[tuple[str, str]]:
         """Return prompt tokens for current mode"""
-        if self.current_mode == CHAT_MODE:
-            qmark = "💬"
-        elif self.current_mode == EXEC_MODE:
-            qmark = "🚀"
-        else:
-            qmark = ""
+        qmark = "💬" if self.current_mode == CHAT_MODE else "🚀" if self.current_mode == EXEC_MODE else ""
         return [("class:qmark", qmark), ("class:question", " {} ".format(">"))]
 
     def _check_history_len(self) -> None:
@@ -321,7 +371,7 @@ STREAM=true"""
     def _run_repl(self) -> None:
         """Run REPL loop, handling user input and generating responses, saving history, and executing commands"""
         # Show REPL instructions
-        self._setup_key_bindings()
+        self.prepare_chat_loop()
         self.console.print("""
 ██    ██  █████  ██  ██████ ██      ██
  ██  ██  ██   ██ ██ ██      ██      ██
@@ -349,7 +399,7 @@ STREAM=true"""
                 self.history = []
                 self.console.print("[bold yellow]Chat history cleared[/bold yellow]\n")
                 continue
-            elif user_input.lower() == "/his":
+            elif user_input.lower() == CMD_HISTORY:
                 self.console.print(self.history)
                 continue
             # Create appropriate system prompt based on mode
@@ -364,19 +414,25 @@ STREAM=true"""
             message.append({"role": "user", "content": user_input})
 
             # Get response from LLM
-            response = self.post(message)
+            try:
+                response = self.post(message)
+            except ValueError as e:
+                self.console.print(f"[red]Error: {e}[/red]")
+                return
+            except (httpx.ConnectError, httpx.HTTPStatusError) as e:
+                self.console.print(f"[red]Error: {e}[/red]")
+                continue
             self.console.print("\n[bold green]Assistant:[/bold green]")
             try:
                 content = self._print(response, stream=self.config["STREAM"] == "true")
             except Exception as e:
-                self.console.print(f"[red]Error: {e}[/red]")
+                self.console.print(f"[red]Unknown Error: {e}[/red]")
                 continue
 
             # Add user input and assistant response to history
             self.history.append({"role": "user", "content": user_input})
             self.history.append({"role": "assistant", "content": content})
 
-            # Trim history if needed
             self._check_history_len()
 
             # Handle command execution in exec mode
@@ -406,7 +462,14 @@ STREAM=true"""
         ]
 
         # Get response from LLM
-        response = self.post(message)
+        try:
+            response = self.post(message)
+        except (ValueError, httpx.ConnectError, httpx.HTTPStatusError) as e:
+            self.console.print(f"[red]Error: {e}[/red]")
+            return
+        except Exception as e:
+            self.console.print(f"[red]Unknown Error: {e}[/red]")
+            return
         self.console.print("\n[bold green]Assistant:[/bold green]")
         content = self._print(response, stream=self.config["STREAM"] == "true")
 
@@ -422,14 +485,12 @@ STREAM=true"""
                 if returncode != 0:
                     self.console.print(f"[bold red]Command failed with return code {returncode}[/bold red]")
 
-
     def run(self, chat: bool, shell: bool, prompt: str) -> None:
         """Run the CLI"""
         self.load_config()
         if not self.config.get("API_KEY"):
-            self.console.print("[bold red]API key not set[/bold red]")
             self.console.print(
-                "[bold red]Please set API key in ~/.config/yaicli/config.ini or environment variable[/bold red]"
+                "[yellow]API key not set. Please set in ~/.config/yaicli/config.ini or AI_API_KEY env[/]"
             )
             raise typer.Exit(code=1)
 
@@ -445,14 +506,24 @@ STREAM=true"""
 def main(
     ctx: typer.Context,
     prompt: Annotated[Optional[str], typer.Argument(show_default=False, help="The prompt send to the LLM")] = None,
-    verbose: Annotated[bool, typer.Option("--verbose", "-V", help="Show verbose information")] = False,
-    chat: Annotated[bool, typer.Option("--chat", "-c", help="Start in chat mode")] = False,
-    shell: Annotated[bool, typer.Option("--shell", "-s", help="Generate and execute shell command")] = False,
+    chat: Annotated[
+        bool, typer.Option("--chat", "-c", help="Start in chat mode", rich_help_panel="Run Option")
+    ] = False,
+    shell: Annotated[
+        bool, typer.Option("--shell", "-s", help="Generate and execute shell command", rich_help_panel="Run Option")
+    ] = False,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-V", help="Show verbose information", rich_help_panel="Run Option")
+    ] = False,
+    template: Annotated[bool, typer.Option("--template", help="Show the config template.")] = False,
 ):
     """yaicli - Your AI interface in cli."""
     if prompt == "":
         typer.echo("Empty prompt, ignored")
         return
+    if template:
+        typer.echo(DEFAULT_CONFIG_INI)
+        return
     if not prompt and not chat:
         typer.echo(ctx.get_help())
         return