yaicli 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.0.11"
+version = "0.0.13"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"

{yaicli-0.0.11.dist-info → yaicli-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.0.11
+Version: 0.0.13
 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
@@ -329,14 +329,17 @@ MAX_TOKENS=1024
 
 Below are the available configuration options and override environment variables:
 
-- **BASE_URL**: API endpoint URL (default: OpenAI API), env: AI_BASE_URL
-- **API_KEY**: Your API key for the LLM provider, env: AI_API_KEY
-- **MODEL**: The model to use (e.g., gpt-4o, gpt-3.5-turbo), default: gpt-4o, env: AI_MODEL
-- **SHELL_NAME**: Shell to use (auto for automatic detection), default: auto, env: AI_SHELL_NAME
-- **OS_NAME**: OS to use (auto for automatic detection), default: auto, env: AI_OS_NAME
-- **COMPLETION_PATH**: Path for completions endpoint, default: /chat/completions, env: AI_COMPLETION_PATH
-- **ANSWER_PATH**: Json path expression to extract answer from response, default: choices[0].message.content, env: AI_ANSWER_PATH
-- **STREAM**: Enable/disable streaming responses, default: true, env: AI_STREAM
+- **BASE_URL**: API endpoint URL (default: OpenAI API), env: YAI_BASE_URL
+- **API_KEY**: Your API key for the LLM provider, env: YAI_API_KEY
+- **MODEL**: The model to use (e.g., gpt-4o, gpt-3.5-turbo), default: gpt-4o, env: YAI_MODEL
+- **SHELL_NAME**: Shell to use (auto for automatic detection), default: auto, env: YAI_SHELL_NAME
+- **OS_NAME**: OS to use (auto for automatic detection), default: auto, env: YAI_OS_NAME
+- **COMPLETION_PATH**: Path for completions endpoint, default: /chat/completions, env: YAI_COMPLETION_PATH
+- **ANSWER_PATH**: Json path expression to extract answer from response, default: choices[0].message.content, env: YAI_ANSWER_PATH
+- **STREAM**: Enable/disable streaming responses, default: true, env: YAI_STREAM
+- **TEMPERATURE**: Temperature for response generation (default: 0.7), env: YAI_TEMPERATURE
+- **TOP_P**: Top-p sampling for response generation (default: 1.0), env: YAI_TOP_P
+- **MAX_TOKENS**: Maximum number of tokens for response generation (default: 1024), env: YAI_MAX_TOKENS
 
 Default config of `COMPLETION_PATH` and `ANSWER_PATH` is OpenAI compatible. If you are using OpenAI or other OpenAI compatible LLM provider, you can use the default config.
 
@@ -410,33 +413,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                                                                                                                           │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 
 ```
 
@@ -459,10 +470,45 @@ In Execute mode:
 
 ## Examples
 
+### Have a Chat
+
+```bash
+$ ai "What is the capital of France?"
+Assistant:
+The capital of France is Paris.
+```
+
+### Command Gen and Run
+
+```bash
+$ ai -s 'Check the current directory size'
+Assistant:
+du -sh .
+
+Generated command: du -sh .
+Execute this command? [y/n/e] (n): e
+Edit command, press enter to execute:
+du -sh ./
+Output:
+109M    ./
+```
+
 ### Chat Mode Example
 
 ```bash
 $ ai --chat
+
+██    ██  █████  ██  ██████ ██      ██
+ ██  ██  ██   ██ ██ ██      ██      ██
+  ████   ███████ ██ ██      ██      ██
+   ██    ██   ██ ██ ██      ██      ██
+   ██    ██   ██ ██  ██████ ███████ ██
+
+Press TAB to change in chat and exec mode
+Type /clear to clear chat history
+Type /his to see chat history
+Press Ctrl+C or type /exit to exit
+
 💬 > Tell me about the solar system
 
 Assistant:
@@ -481,7 +527,17 @@ Certainly! Here’s a brief overview of the solar system:
  • Dwarf Planets:
     • Pluto: Once considered the ninth planet, now classified as
 
-💬 >
+🚀 > Check the current directory size
+Assistant:
+du -sh .
+
+Generated command: du -sh .
+Execute this command? [y/n/e] (n): e
+Edit command, press enter to execute:
+du -sh ./
+Output:
+109M    ./
+🚀 >
 ```
 
 ### Execute Mode Example

yaicli-0.0.13.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyproject.toml,sha256=15od1R0Bb-b7YKSSlz1SmzGoaNNbfHgv8y5Zr0gXfBU,1452
+yaicli.py,sha256=Cby2e0HHoh7sAOIvAxEKoZA0TRS3A3ikkfZ6o3bem0o,20955
+yaicli-0.0.13.dist-info/METADATA,sha256=5Yc9O8k_N66OpBTqKG9kVGUvXzj2-L3UrXaiZziWfVU,29445
+yaicli-0.0.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+yaicli-0.0.13.dist-info/entry_points.txt,sha256=gdduQwAuu_LeDqnDU81Fv3NPmD2tRQ1FffvolIP3S1Q,34
+yaicli-0.0.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+yaicli-0.0.13.dist-info/RECORD,,

yaicli.py

@@ -12,12 +12,14 @@ import jmespath
 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
 from rich.live import Live
 from rich.markdown import Markdown
-from rich.prompt import Confirm
+from rich.prompt import Prompt
 
 SHELL_PROMPT = """Your are a Shell Command Generator.
 Generate a command EXCLUSIVELY for {_os} OS with {_shell} shell.
@@ -37,20 +39,24 @@ DEFAULT_PROMPT = (
 
 CMD_CLEAR = "/clear"
 CMD_EXIT = "/exit"
+CMD_HISTORY = "/his"
 
 EXEC_MODE = "exec"
 CHAT_MODE = "chat"
 TEMP_MODE = "temp"
 
 DEFAULT_CONFIG_MAP = {
-    "BASE_URL": {"value": "https://api.openai.com/v1", "env_key": "AI_BASE_URL"},
-    "API_KEY": {"value": "", "env_key": "AI_API_KEY"},
-    "MODEL": {"value": "gpt-4o", "env_key": "AI_MODEL"},
-    "SHELL_NAME": {"value": "auto", "env_key": "AI_SHELL_NAME"},
-    "OS_NAME": {"value": "auto", "env_key": "AI_OS_NAME"},
-    "COMPLETION_PATH": {"value": "chat/completions", "env_key": "AI_COMPLETION_PATH"},
-    "ANSWER_PATH": {"value": "choices[0].message.content", "env_key": "AI_ANSWER_PATH"},
-    "STREAM": {"value": "true", "env_key": "AI_STREAM"},
+    "BASE_URL": {"value": "https://api.openai.com/v1", "env_key": "YAI_BASE_URL"},
+    "API_KEY": {"value": "", "env_key": "YAI_API_KEY"},
+    "MODEL": {"value": "gpt-4o", "env_key": "YAI_MODEL"},
+    "SHELL_NAME": {"value": "auto", "env_key": "YAI_SHELL_NAME"},
+    "OS_NAME": {"value": "auto", "env_key": "YAI_OS_NAME"},
+    "COMPLETION_PATH": {"value": "chat/completions", "env_key": "YAI_COMPLETION_PATH"},
+    "ANSWER_PATH": {"value": "choices[0].message.content", "env_key": "YAI_ANSWER_PATH"},
+    "STREAM": {"value": "true", "env_key": "YAI_STREAM"},
+    "TEMPERATURE": {"value": "0.7", "env_key": "YAI_TEMPERATURE"},
+    "TOP_P": {"value": "1.0", "env_key": "YAI_TOP_P"},
+    "MAX_TOKENS": {"value": "1024", "env_key": "YAI_MAX_TOKENS"},
 }
 
 DEFAULT_CONFIG_INI = """[core]
@@ -99,10 +105,27 @@ class CLI:
         self.bindings = KeyBindings()
         self.session = PromptSession(key_bindings=self.bindings)
         self.config = {}
-        self.history = []
+        self.history: list[dict[str, str]] = []
         self.max_history_length = 25
         self.current_mode = TEMP_MODE
 
+    def is_stream(self) -> bool:
+        """Check if streaming is enabled"""
+        return self.config["STREAM"] == "true"
+
+    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"""
 
@@ -216,7 +239,7 @@ class CLI:
             # Join the remaining lines and strip any extra whitespace
             return "\n".join(line.strip() for line in content_lines if line.strip())
 
-    def _get_type_number(self, key, _type: type, default=None):
+    def _get_number_with_type(self, key, _type: type, default=None):
         """Get number with type from config"""
         try:
             return _type(self.config.get(key, default))
@@ -229,10 +252,10 @@ class CLI:
         body = {
             "messages": message,
             "model": self.config.get("MODEL", "gpt-4o"),
-            "stream": self.config.get("STREAM", "true") == "true",
-            "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"),
+            "stream": self.is_stream(),
+            "temperature": self._get_number_with_type(key="TEMPERATURE", _type=float, default="0.7"),
+            "top_p": self._get_number_with_type(key="TOP_P", _type=float, default="1.0"),
+            "max_tokens": self._get_number_with_type(key="MAX_TOKENS", _type=int, default="1024"),
         }
         with httpx.Client(timeout=120.0) as client:
             response = client.post(
@@ -243,8 +266,7 @@ class CLI:
         except httpx.HTTPStatusError as e:
             self.console.print(f"[red]Error calling API: {e}[/red]")
             if self.verbose:
-                self.console.print(f"Reason: {e}")
-                self.console.print(f"Response: {response.text}")
+                self.console.print(f"Reason: {e}\nResponse: {response.text}")
             raise e
         return response
 
@@ -300,6 +322,7 @@ class CLI:
 
     def _print_stream(self, response: httpx.Response) -> str:
         """Print response from LLM in streaming mode"""
+        self.console.print("Assistant:", style="bold green")
         full_completion = ""
         in_reasoning = False
 
@@ -317,40 +340,24 @@ class CLI:
                         reason, full_completion, in_reasoning
                     )
                 else:
-                    content = delta.get("content", "") or ""
                     full_completion, in_reasoning = self._process_regular_content(
-                        content, full_completion, in_reasoning
+                        delta.get("content", "") or "", full_completion, in_reasoning
                     )
 
                 live.update(Markdown(markup=full_completion), refresh=True)
-
+        # self.console.print()
         return full_completion
 
-    def _print_non_stream(self, response: httpx.Response) -> str:
+    def _print_normal(self, response: httpx.Response) -> str:
         """Print response from LLM in non-streaming mode"""
+        self.console.print("Assistant:", style="bold green")
         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: httpx.Response, stream: bool = True) -> str:
-        """Print response from LLM and return full completion"""
-        if stream:
-            # Streaming response
-            full_completion = self._print_stream(response)
-        else:
-            # Non-streaming response
-            full_completion = self._print_non_stream(response)
-        self.console.print()  # Add a newline after the response to separate from the next input
+        self.console.print(Markdown(full_completion + '\n'))
         return full_completion
 
     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:
@@ -358,10 +365,69 @@ class CLI:
         if len(self.history) > self.max_history_length:
             self.history = self.history[-self.max_history_length :]
 
+    def _handle_special_commands(self, user_input: str) -> Optional[bool]:
+        """Handle special command return: True-continue loop, False-exit loop, None-non-special command"""
+        if user_input.lower() == CMD_EXIT:
+            return False
+        if user_input.lower() == CMD_CLEAR and self.current_mode == CHAT_MODE:
+            self.history.clear()
+            self.console.print("Chat history cleared\n", style="bold yellow")
+            return True
+        if user_input.lower() == CMD_HISTORY:
+            self.console.print(self.history)
+            return True
+        return None
+
+    def _confirm_and_execute(self, content: str) -> None:
+        """Review, edit and execute the command"""
+        cmd = self._filter_command(content)
+        if not cmd:
+            self.console.print("No command generated", style="bold red")
+            return
+        self.console.print(f"\n[bold magenta]Generated command:[/bold magenta] {cmd}")
+        _input = Prompt.ask("Execute this command?", choices=['y', 'n', 'e'], default="n", case_sensitive=False)
+        if _input == 'y':  # execute cmd
+            self.console.print("Output:", style="bold green")
+            subprocess.call(cmd, shell=True)
+        elif _input == 'e':  # edit cmd
+            cmd = self.session.prompt("Edit command, press enter to execute:\n", key_bindings=None, default=cmd)
+            self.console.print("Output:", style="bold green")
+            subprocess.call(cmd, shell=True)
+
+    def _build_messages(self, user_input: str) -> list[dict[str, str]]:
+        return [
+            {"role": "system", "content": self.get_system_prompt()},
+            *self.history,
+            {"role": "user", "content": user_input}
+        ]
+
+    def _handle_llm_response(self, response: httpx.Response, user_input: str) -> str:
+        """Print LLM response and update history"""
+        content = self._print_stream(response) if self.is_stream() else self._print_normal(response)
+        self.history.extend([{"role": "user", "content": user_input}, {"role": "assistant", "content": content}])
+        self._check_history_len()
+        return content
+
+    def _process_user_input(self, user_input: str) -> bool:
+        """Process user input and generate response"""
+        try:
+            response = self.post(self._build_messages(user_input))
+            content = self._handle_llm_response(response, user_input)
+            if self.current_mode == EXEC_MODE:
+                self._confirm_and_execute(content)
+            return True
+        except Exception as e:
+            self.console.print(f"Error: {e}", style="red")
+            return False
+
+    def get_system_prompt(self) -> str:
+        """Return system prompt for current mode"""
+        prompt = SHELL_PROMPT if self.current_mode == EXEC_MODE else DEFAULT_PROMPT
+        return prompt.format(_os=self.detect_os(), _shell=self.detect_shell())
+
     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("""
 ██    ██  █████  ██  ██████ ██      ██
  ██  ██  ██   ██ ██ ██      ██      ██
@@ -369,13 +435,13 @@ class CLI:
    ██    ██   ██ ██ ██      ██      ██
    ██    ██   ██ ██  ██████ ███████ ██
 """)
-        self.console.print("[bold]Press TAB to change in chat and exec mode[/bold]")
-        self.console.print("[bold]Type /clear to clear chat history[/bold]")
-        self.console.print("[bold]Type /his to see chat history[/bold]")
-        self.console.print("[bold]Press Ctrl+C or type /exit to exit[/bold]\n")
+        self.console.print("Press TAB to change in chat and exec mode", style="bold")
+        self.console.print("Type /clear to clear chat history", style="bold")
+        self.console.print("Type /his to see chat history", style="bold")
+        self.console.print("Press Ctrl+C or type /exit to exit\n", style="bold")
 
         while True:
-            # Get user input
+            self.console.print(Markdown("---"))
             user_input = self.session.prompt(self.get_prompt_tokens).strip()
             if not user_input:
                 continue
@@ -389,110 +455,38 @@ class CLI:
                 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
-            system_prompt = SHELL_PROMPT if self.current_mode == EXEC_MODE else DEFAULT_PROMPT
-            system_content = system_prompt.format(_os=self.detect_os(), _shell=self.detect_shell())
-
-            # Create message with system prompt and history
-            message = [{"role": "system", "content": system_content}]
-            message.extend(self.history)
-
-            # Add current user message
-            message.append({"role": "user", "content": user_input})
-
-            # Get response from LLM
-            try:
-                response = self.post(message)
-            except ValueError as e:
-                self.console.print(f"[red]Error: {e}[/red]")
-                return
-            except httpx.ConnectError as e:
-                self.console.print(f"[red]Error: {e}[/red]")
-                continue
-            except httpx.HTTPStatusError:
-                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]Unknown Error: {e}[/red]")
+            if not self._process_user_input(user_input):
                 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
-            if self.current_mode == EXEC_MODE:
-                content = self._filter_command(content)
-                if not content:
-                    self.console.print("[bold red]No command generated[/bold red]")
-                    continue
-                self.console.print(f"\n[bold magenta]Generated command:[/bold magenta] {content}")
-                if Confirm.ask("Execute this command?", default=False):
-                    subprocess.call(content, shell=True)
-
         self.console.print("[bold green]Exiting...[/bold green]")
 
     def _run_once(self, prompt: str, shell: bool = False) -> None:
         """Run once with given prompt"""
-        _os = self.detect_os()
-        _shell = self.detect_shell()
-        # Create appropriate system prompt based on mode
-        system_prompt = SHELL_PROMPT if shell else DEFAULT_PROMPT
-        system_content = system_prompt.format(_os=_os, _shell=_shell)
-
-        # Create message with system prompt and user input
-        message = [
-            {"role": "system", "content": system_content},
-            {"role": "user", "content": prompt},
-        ]
 
-        # Get response from LLM
         try:
-            response = self.post(message)
-        except (ValueError, httpx.ConnectError, httpx.HTTPStatusError) as e:
-            self.console.print(f"[red]Error: {e}[/red]")
-            return
+            response = self.post(self._build_messages(prompt))
+            content = self._handle_llm_response(response, prompt)
+            if shell:
+                self._confirm_and_execute(content)
         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")
-
-        # Handle shell mode execution
-        if shell:
-            content = self._filter_command(content)
-            if not content:
-                self.console.print("[bold red]No command generated[/bold red]")
-                return
-            self.console.print(f"\n[bold magenta]Generated command:[/bold magenta] {content}")
-            if Confirm.ask("Execute this command?", default=False):
-                returncode = subprocess.call(content, shell=True)
-                if returncode != 0:
-                    self.console.print(f"[bold red]Command failed with return code {returncode}[/bold red]")
+            self.console.print(f"[red]Error: {e}[/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)
-
-        # Handle chat mode
         if chat:
             self.current_mode = CHAT_MODE
             self._run_repl()
         else:
+            self.current_mode = EXEC_MODE if shell else TEMP_MODE
             self._run_once(prompt, shell)
 
 
@@ -500,14 +494,24 @@ class CLI:
 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 Options")
+    ] = False,
+    shell: Annotated[
+        bool, typer.Option("--shell", "-s", help="Generate and execute shell command", rich_help_panel="Run Options")
+    ] = False,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-V", help="Show verbose information", rich_help_panel="Run Options")
+    ] = 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

yaicli-0.0.11.dist-info/RECORD

@@ -1,7 +0,0 @@
-pyproject.toml,sha256=X26aCrit45QBISeLMZi0zzjd4M3YOCK_fYA9L-gKmS8,1452
-yaicli.py,sha256=CEQlDJrQn7UEFLpAHbNFyo-chVoFi55P1fblealDhd8,20559
-yaicli-0.0.11.dist-info/METADATA,sha256=0ty4x5vHDyyVJsY5xk4yoII7I3d7d-PhoMWFSS_h-Yg,25934
-yaicli-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-yaicli-0.0.11.dist-info/entry_points.txt,sha256=gdduQwAuu_LeDqnDU81Fv3NPmD2tRQ1FffvolIP3S1Q,34
-yaicli-0.0.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-yaicli-0.0.11.dist-info/RECORD,,