yaicli 0.0.1__tar.gz → 0.0.3__tar.gz

{yaicli-0.0.1 → yaicli-0.0.3}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.1
+current_version = 0.0.3
 commit = True
 tag = True
 

yaicli-0.0.3/CHANGELOG.md

@@ -0,0 +1,33 @@
+
+---
+## [0.0.3](https://github.com/belingud/yaicli/compare/v0.0.2..v0.0.3) - 2025-04-02
+
+### 🚜 Refactor
+
+- **(changelog)** switch from git log to git cliff for changelog generation - ([242a51d](https://github.com/belingud/yaicli/commit/242a51d93a25675041a7fe19c4a0db1c7c12a663)) - Belingud
+- update CLI assistant description and error handling - ([1a8bcdc](https://github.com/belingud/yaicli/commit/1a8bcdc86c72a75259d266291bc9e5350fc81f61)) - Belingud
+- fix spacing in clean target and simplify build target - ([2a1050e](https://github.com/belingud/yaicli/commit/2a1050e7a9eea8753c164553b13796e5510b7965)) - Belingud
+
+
+---
+## [0.0.2] - 2025-04-02
+
+### ⛰️  Features
+
+- enhance OS detection and LLM API request handling - ([8c00de0](https://github.com/belingud/yaicli/commit/8c00de099e1c75fedcdd33e9d7e0443818538059)) - Belingud
+- add new dependencies and configurable API paths - ([3be3f67](https://github.com/belingud/yaicli/commit/3be3f67b3bd9645a9a8c9909be0e5542612c1c71)) - Belingud
+
+### 🚜 Refactor
+
+- **(config)** migrate config from JSON to INI format and enhance error handling - ([f556872](https://github.com/belingud/yaicli/commit/f556872fdb521adf8e20da6498fdaac26998a5b7)) - Belingud
+- update config path to reflect project name change - ([e6bf761](https://github.com/belingud/yaicli/commit/e6bf761aa0fae20b643848c586c6dc55d6f324fb)) - Belingud
+- rename project from llmcli to yaicli and update related files - ([cdb5a97](https://github.com/belingud/yaicli/commit/cdb5a97d06c9f042c1c8731c8f11a4a7284783f0)) - Belingud
+- rename project from shellai to llmcli and update related files - ([db4ecb8](https://github.com/belingud/yaicli/commit/db4ecb85236b72fd7536c99b21d210037c09889e)) - Belingud
+- reorganize imports and improve code readability - ([0f52c05](https://github.com/belingud/yaicli/commit/0f52c05918d177d4623ff2f07aff2fc2e3aa9e91)) - Belingud
+- migrate llmcli to class-based ShellAI implementation - ([2509cba](https://github.com/belingud/yaicli/commit/2509cba5cad7c8626f794d88d971fff7eea9a404)) - Belingud
+
+### Build
+
+- add bump2version for version management - ([de287f1](https://github.com/belingud/yaicli/commit/de287f1262eae64ae5fd0cb634dea93762a17282)) - Belingud
+
+

yaicli-0.0.3/Justfile

@@ -0,0 +1,33 @@
+# Justfile for Python project management
+
+# Clean build artifacts
+clean:
+    @echo "Cleaning build artifacts..."
+    @rm -rf build/ dist/ *.egg-info/
+    @echo "Cleaning cache files..."
+    @find . -type d -name "__pycache__" -exec rm -rf {} +
+    @echo "Cleaning test artifacts..."
+    @rm -rf .pytest_cache/
+    @echo "Cleaning pdm build artifacts..."
+    @rm -rf .pdm_build/
+
+# Run tests with pytest
+test:
+    @echo "Running tests..."
+    @pytest tests/
+
+# Build package with hatch (runs clean first)
+build:
+    @echo "Building package..."
+    @rm -rf dist/
+    @uv build
+
+# Install package in editable mode
+install:
+    @echo "Installing packages..."
+    @pip install -e .
+
+# Generate changelog from git log
+changelog:
+    @echo "Generating changelog..."
+    @git cliff -l --prepend CHANGELOG.md

{yaicli-0.0.1 → yaicli-0.0.3}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.0.1
+Version: 0.0.3
 Summary: A simple CLI tool to interact with LLM
 License-File: LICENSE
 Requires-Python: >=3.8
+Requires-Dist: distro>=1.9.0
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: requests>=2.32.3

yaicli-0.0.3/cliff.toml

@@ -0,0 +1,90 @@
+# git-cliff ~ configuration file
+# https://git-cliff.org/docs/configuration
+
+[changelog]
+# template for the changelog header
+header = """"""
+# template for the changelog body
+# https://keats.github.io/tera/docs/#introduction
+body = """
+---
+{% if version %}\
+    {% if previous.version %}\
+        ## [{{ version | trim_start_matches(pat="v") }}]($REPO/compare/{{ previous.version }}..{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+    {% else %}\
+        ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+    {% endif %}\
+{% else %}\
+    ## [unreleased]
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits
+    | filter(attribute="scope")
+    | sort(attribute="scope") %}
+        - **({{commit.scope}})**{% if commit.breaking %} [**breaking**]{% endif %} \
+            {{ commit.message }} - ([{{ commit.id | truncate(length=7, end="") }}]($REPO/commit/{{ commit.id }})) - {{ commit.author.name }}
+    {%- endfor -%}
+    {% raw %}\n{% endraw %}\
+    {%- for commit in commits %}
+        {%- if commit.scope -%}
+        {% else -%}
+            - {% if commit.breaking %} [**breaking**]{% endif %}\
+                {{ commit.message }} - ([{{ commit.id | truncate(length=7, end="") }}]($REPO/commit/{{ commit.id }})) - {{ commit.author.name }}
+        {% endif -%}
+    {% endfor -%}
+{% endfor %}\n
+"""
+# template for the changelog footer
+footer = """"""
+# remove the leading and trailing whitespace from the templates
+trim = true
+# postprocessors
+postprocessors = [
+    { pattern = '\$REPO', replace = "https://github.com/belingud/yaicli" }, # replace repository URL
+]
+
+[git]
+# parse the commits based on https://www.conventionalcommits.org
+conventional_commits = true
+# filter out the commits that are not conventional
+filter_unconventional = true
+# process each line of a commit as an individual commit
+split_commits = false
+# regex for preprocessing the commit messages
+commit_preprocessors = [
+    # { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://github.com/orhun/git-cliff/issues/${2}))"}, # replace issue numbers
+]
+# regex for parsing and grouping commits
+commit_parsers = [
+    { message = "^feat", group = "<!-- 0 -->⛰️  Features" },
+    { message = "^fix", group = "<!-- 1 -->🐛 Bug Fixes" },
+    { message = "^doc", group = "<!-- 3 -->📚 Documentation" },
+    { message = "^perf", group = "<!-- 4 -->⚡ Performance" },
+    { message = "^refactor\\(clippy\\)", skip = true },
+    { message = "^refactor", group = "<!-- 2 -->🚜 Refactor" },
+    { message = "^style", group = "<!-- 5 -->🎨 Styling" },
+    { message = "^test", group = "<!-- 6 -->🧪 Testing" },
+    { message = "^chore\\(release\\): prepare for", skip = true },
+    { message = "^chore\\(deps.*\\)", skip = true },
+    { message = "^chore\\(pr\\)", skip = true },
+    { message = "^chore\\(pull\\)", skip = true },
+    { message = "^chore\\(npm\\).*yarn\\.lock", skip = true },
+    { message = "^chore|^ci", group = "<!-- 7 -->⚙️ Miscellaneous Tasks" },
+    { body = ".*security", group = "<!-- 8 -->🛡️ Security" },
+    { message = "^revert", group = "<!-- 9 -->◀️ Revert" },
+]
+# protect breaking changes from being skipped due to matching a skipping commit_parser
+protect_breaking_commits = false
+# filter out the commits that are not matched by commit parsers
+filter_commits = false
+# regex for matching git tags
+tag_pattern = "v[0-9].*"
+# regex for skipping tags
+skip_tags = "beta|alpha"
+# regex for ignoring tags
+ignore_tags = "rc|beta"
+# sort the tags topologically
+topo_order = false
+# sort the commits inside sections by oldest/newest order
+sort_commits = "newest"

yaicli-0.0.3/debug.py

@@ -0,0 +1,12 @@
+from yaicli import ShellAI
+
+
+def main():
+    ai = ShellAI()
+    ai.load_config()
+    r = ai.get_command_from_llm("列出当前目录中所有的文件,包含隐藏文件")
+    print(r)
+
+
+if __name__ == "__main__":
+    main()

{yaicli-0.0.1 → yaicli-0.0.3}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "yaicli"
-version = "0.0.1"
+version = "0.0.3"
 description = "A simple CLI tool to interact with LLM"
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = [
+    "distro>=1.9.0",
     "jmespath>=1.0.1",
     "prompt-toolkit>=3.0.50",
     "requests>=2.32.3",

yaicli-0.0.1/test_shellai.py → yaicli-0.0.3/tests

@@ -1,6 +1,6 @@
 import pytest
 
-from llmcli import ShellAI
+from yaicli import ShellAI
 
 
 @pytest.fixture

{yaicli-0.0.1 → yaicli-0.0.3}/uv.lock

@@ -132,6 +132,15 @@ wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6" },
 ]
 
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://repo.huaweicloud.com/repository/pypi/simple/" }
+sdist = { url = "https://repo.huaweicloud.com/repository/pypi/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" }
+wheels = [
+    { url = "https://repo.huaweicloud.com/repository/pypi/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" },
+]
+
 [[package]]
 name = "exceptiongroup"
 version = "1.2.2"
@@ -168,41 +177,6 @@ wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980" },
 ]
 
-[[package]]
-name = "llm-cli"
-version = "0.0.1"
-source = { editable = "." }
-dependencies = [
-    { name = "jmespath" },
-    { name = "prompt-toolkit" },
-    { name = "requests" },
-    { name = "rich" },
-    { name = "typer" },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "bump2version" },
-    { name = "pytest" },
-    { name = "ruff" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "jmespath", specifier = ">=1.0.1" },
-    { name = "prompt-toolkit", specifier = ">=3.0.50" },
-    { name = "requests", specifier = ">=2.32.3" },
-    { name = "rich", specifier = ">=13.9.4" },
-    { name = "typer", specifier = ">=0.15.2" },
-]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "bump2version", specifier = ">=1.0.1" },
-    { name = "pytest", specifier = ">=8.3.5" },
-    { name = "ruff", specifier = ">=0.11.2" },
-]
-
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -439,3 +413,40 @@ sdist = { url = "https://repo.huaweicloud.com/repository/pypi/packages/6c/63/535
 wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859" },
 ]
+
+[[package]]
+name = "yaicli"
+version = "0.0.3"
+source = { editable = "." }
+dependencies = [
+    { name = "distro" },
+    { name = "jmespath" },
+    { name = "prompt-toolkit" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "typer" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "bump2version" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "distro", specifier = ">=1.9.0" },
+    { name = "jmespath", specifier = ">=1.0.1" },
+    { name = "prompt-toolkit", specifier = ">=3.0.50" },
+    { name = "requests", specifier = ">=2.32.3" },
+    { name = "rich", specifier = ">=13.9.4" },
+    { name = "typer", specifier = ">=0.15.2" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bump2version", specifier = ">=1.0.1" },
+    { name = "pytest", specifier = ">=8.3.5" },
+    { name = "ruff", specifier = ">=0.11.2" },
+]

{yaicli-0.0.1 → yaicli-0.0.3}/yaicli.py

@@ -1,5 +1,6 @@
 import configparser
 import json
+import platform
 import subprocess
 import time
 from enum import StrEnum
@@ -11,6 +12,7 @@ from typing import Annotated, Optional
 import jmespath
 import requests
 import typer
+from distro import name as distro_name
 from prompt_toolkit import PromptSession
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.keys import Keys
@@ -33,7 +35,7 @@ class CasePreservingConfigParser(configparser.RawConfigParser):
 
 class ShellAI:
     # Configuration file path
-    CONFIG_PATH = Path("~/.config/llmcli/config.ini").expanduser()
+    CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
 
     # Default configuration template
     DEFAULT_CONFIG_INI = """[core]
@@ -61,7 +63,6 @@ ANSWER_PATH=choices[0].message.content
 STREAM=true"""
 
     def __init__(self, verbose: bool = False):
-        # Initialize terminal components
         self.verbose = verbose
         self.console = Console()
         self.bindings = KeyBindings()
@@ -83,15 +84,20 @@ STREAM=true"""
                 else ModeEnum.EXECUTE.value
             )
 
-    def get_os(self):
+    def detect_os(self):
         """Detect operating system"""
         if self.config.get("OS_NAME") != "auto":
             return self.config.get("OS_NAME")
-        import platform
-
-        return platform.system()
-
-    def get_shell(self):
+        current_platform = platform.system()
+        if current_platform == "Linux":
+            return "Linux/" + distro_name(pretty=True)
+        if current_platform == "Windows":
+            return "Windows " + platform.release()
+        if current_platform == "Darwin":
+            return "Darwin/MacOS " + platform.mac_ver()[0]
+        return current_platform
+
+    def detect_shell(self):
         """Detect shell"""
         if self.config.get("SHELL_NAME") != "auto":
             return self.config.get("SHELL_NAME")
@@ -103,6 +109,29 @@ STREAM=true"""
             return "powershell.exe" if is_powershell else "cmd.exe"
         return basename(getenv("SHELL", "/bin/sh"))
 
+    def build_cmd_prompt(self):
+        _os = self.detect_os()
+        _shell = self.detect_shell()
+        return f"""Your are a Shell Command Generator.
+Generate a command EXCLUSIVELY for {_os} OS with {_shell} shell.
+Rules:
+1. Use ONLY {_shell}-specific syntax and connectors (&&, ||, |, etc)
+2. Output STRICTLY in plain text format
+3. NEVER use markdown, code blocks or explanations
+4. Chain multi-step commands in SINGLE LINE
+5. Return NOTHING except the ready-to-run command"""
+
+    def build_default_prompt(self):
+        """Build default prompt"""
+        _os = self.detect_os()
+        _shell = self.detect_shell()
+        return (
+            "You are yaili, a system management and programing assistant, "
+            f"You are managing {_os} operating system with {_shell} shell. "
+            "Your responses should be concise and use Markdown format, "
+            "unless the user explicitly requests more details."
+        )
+
     def get_default_config(self):
         """Get default configuration"""
         config = CasePreservingConfigParser()
@@ -137,36 +166,42 @@ STREAM=true"""
         response.raise_for_status()  # Raise an exception for non-200 status codes
         return response
 
-    def call_llm_api(self, prompt):
-        """Call LLM API, return streaming output"""
+    def get_llm_url(self) -> Optional[str]:
+        """Get LLM API URL"""
         base = self.config.get("BASE_URL", "").rstrip("/")
         if not base:
             self.console.print(
                 "[red]Base URL not found. Please set it in the configuration file. Default: https://api.openai.com/v1[/red]"
             )
-            return
+            raise typer.Exit(code=1)
         COMPLETION_PATH = self.config.get("COMPLETION_PATH", "").lstrip("/")
         if not COMPLETION_PATH:
             self.console.print(
                 "[red]Completions path not set. Please set it in the configuration file. Default: `/chat/completions`[/red]"
             )
-            return
-        url = f"{base}/{COMPLETION_PATH}"
-        headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
-        data = {
+            raise typer.Exit(code=1)
+        return f"{base}/{COMPLETION_PATH}"
+
+    def build_data(self, prompt: str, mode: str = ModeEnum.TEMP.value) -> dict:
+        """Build request data"""
+        if mode == ModeEnum.EXECUTE.value:
+            system_prompt = self.build_cmd_prompt()
+        else:
+            system_prompt = self.build_default_prompt()
+        return {
             "model": self.config["MODEL"],
-            "messages": [{"role": "user", "content": prompt}],
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt},
+            ],
             "stream": self.config.get("STREAM", "true") == "true",
+            "temperature": 0.7,
+            "top_p": 0.7,
+            "max_tokens": 200,
         }
-        try:
-            response = self._call_api(url, headers, data)
-        except requests.exceptions.RequestException as e:
-            self.console.print(f"[red]Error calling API: {e}[/red]")
-            return
-        if not response:
-            return
 
-        self.console.print("\n[bold green]Assistant:[/bold green]")
+    def stream_response(self, response):
+        """Stream response from LLM API"""
         full_completion = ""
         # Streaming response loop
         with Live(console=self.console) as live:
@@ -190,24 +225,31 @@ STREAM=true"""
                             self.console.print(f"[red]Error decoding JSON: {decoded_line}[/red]")
                 time.sleep(0.05)
 
+    def call_llm_api(self, prompt: str):
+        """Call LLM API, return streaming output"""
+        url = self.get_llm_url()
+        headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
+        data = self.build_data(prompt)
+        try:
+            response = self._call_api(url, headers, data)
+        except requests.exceptions.RequestException as e:
+            self.console.print(f"[red]Error calling API: {e}[/red]")
+            if self.verbose and e.response:
+                self.console.print(f"{e.response.text}")
+            raise typer.Exit(code=1) from None
+        if not response:
+            raise typer.Exit(code=1)
+
+        self.console.print("\n[bold green]Assistant:[/bold green]")
+        self.stream_response(response)  # Stream the response
         self.console.print()  # Add a newline after the completion
 
     def get_command_from_llm(self, prompt):
         """Request Shell command from LLM"""
-        url = f"{self.config['BASE_URL']}/chat/completions"
+        url = self.get_llm_url()
         headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
-        data = {
-            "model": self.config["MODEL"],
-            "messages": [
-                {
-                    "role": "system",
-                    "content": "You are a command line assistant, return one Linux/macOS shell commands only, without explanation and triple-backtick code blocks.",
-                },
-                {"role": "user", "content": prompt},
-            ],
-            "stream": False,  # Always use non-streaming for command generation
-        }
-
+        data = self.build_data(prompt, mode=ModeEnum.EXECUTE.value)
+        data["stream"] = False
         try:
             response = self._call_api(url, headers, data)
         except requests.exceptions.RequestException as e:
@@ -397,7 +439,7 @@ def main(
     ] = False,
 ):
     """LLM CLI Tool"""
-    cli = ShellAI()
+    cli = ShellAI(verbose=verbose)
     cli.run(chat=chat, shell=shell, prompt=prompt)
 
 

yaicli-0.0.1/cmd_llm.py

@@ -1,405 +0,0 @@
-import configparser
-import json
-import subprocess
-import time
-from enum import StrEnum
-from os import getenv
-from os.path import basename, pathsep
-from pathlib import Path
-from typing import Annotated, Optional
-
-import jmespath
-import requests
-import typer
-from prompt_toolkit import PromptSession
-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
-
-
-class ModeEnum(StrEnum):
-    CHAT = "chat"
-    EXECUTE = "exec"
-    TEMP = "temp"
-
-
-class CasePreservingConfigParser(configparser.RawConfigParser):
-    def optionxform(self, optionstr):
-        return optionstr
-
-
-class ShellAI:
-    # Configuration file path
-    CONFIG_PATH = Path("~/.config/llmcli/config.ini").expanduser()
-
-    # Default configuration template
-    DEFAULT_CONFIG_INI = """[core]
-BASE_URL=https://api.openai.com/v1
-API_KEY=
-MODEL=gpt-4o
-
-# default run mode, default: temp
-# chat: interactive chat mode
-# exec: shell command generation mode
-# temp: one-shot mode
-DEFAULT_MODE=temp
-
-# auto detect shell and os
-SHELL_NAME=auto
-OS_NAME=auto
-
-# if you want to use custom completions path, you can set it here
-COMPLETION_PATH=/chat/completions
-# if you want to use custom answer path, you can set it here
-ANSWER_PATH=choices[0].message.content
-
-# true: streaming response
-# false: non-streaming response
-STREAM=true"""
-
-    def __init__(self, verbose: bool = False):
-        # Initialize terminal components
-        self.verbose = verbose
-        self.console = Console()
-        self.bindings = KeyBindings()
-        self.session = PromptSession(key_bindings=self.bindings)
-        self.current_mode = ModeEnum.CHAT.value
-        self.config = {}
-
-        # Setup key bindings
-        self._setup_key_bindings()
-
-    def _setup_key_bindings(self):
-        """Setup keyboard shortcuts"""
-
-        @self.bindings.add(Keys.ControlI)  # Bind Ctrl+I to switch modes
-        def _(event: KeyPressEvent):
-            self.current_mode = (
-                ModeEnum.CHAT.value
-                if self.current_mode == ModeEnum.EXECUTE.value
-                else ModeEnum.EXECUTE.value
-            )
-
-    def get_os(self):
-        """Detect operating system"""
-        if self.config.get("OS_NAME") != "auto":
-            return self.config.get("OS_NAME")
-        import platform
-
-        return platform.system()
-
-    def get_shell(self):
-        """Detect shell"""
-        if self.config.get("SHELL_NAME") != "auto":
-            return self.config.get("SHELL_NAME")
-        import platform
-
-        current_platform = platform.system()
-        if current_platform in ("Windows", "nt"):
-            is_powershell = len(getenv("PSModulePath", "").split(pathsep)) >= 3
-            return "powershell.exe" if is_powershell else "cmd.exe"
-        return basename(getenv("SHELL", "/bin/sh"))
-
-    def get_default_config(self):
-        """Get default configuration"""
-        config = CasePreservingConfigParser()
-        try:
-            config.read_string(self.DEFAULT_CONFIG_INI)
-            config_dict = {k.upper(): v for k, v in config["core"].items()}
-            config_dict["STREAM"] = str(config_dict.get("STREAM", "true")).lower()
-            return config_dict
-        except configparser.Error as e:
-            self.console.print(f"[red]Error parsing config: {e}[/red]")
-            raise typer.Exit(code=1) from None
-
-    def load_config(self):
-        """Load LLM API configuration"""
-        if not self.CONFIG_PATH.exists():
-            self.console.print(
-                "[bold yellow]Configuration file not found. 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)
-            return self.config
-        config = CasePreservingConfigParser()
-        config.read(self.CONFIG_PATH)
-        self.config = dict(config["core"])
-        self.config["STREAM"] = str(self.config.get("STREAM", "true")).lower()
-        return self.config
-
-    def _call_api(self, url, headers, data):
-        """Generic API call method"""
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()  # Raise an exception for non-200 status codes
-        return response
-
-    def call_llm_api(self, prompt):
-        """Call LLM API, return streaming output"""
-        base = self.config.get("BASE_URL", "").rstrip("/")
-        if not base:
-            self.console.print(
-                "[red]Base URL not found. Please set it in the configuration file. Default: https://api.openai.com/v1[/red]"
-            )
-            return
-        COMPLETION_PATH = self.config.get("COMPLETION_PATH", "").lstrip("/")
-        if not COMPLETION_PATH:
-            self.console.print(
-                "[red]Completions path not set. Please set it in the configuration file. Default: `/chat/completions`[/red]"
-            )
-            return
-        url = f"{base}/{COMPLETION_PATH}"
-        headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
-        data = {
-            "model": self.config["MODEL"],
-            "messages": [{"role": "user", "content": prompt}],
-            "stream": self.config.get("STREAM", "true") == "true",
-        }
-        try:
-            response = self._call_api(url, headers, data)
-        except requests.exceptions.RequestException as e:
-            self.console.print(f"[red]Error calling API: {e}[/red]")
-            return
-        if not response:
-            return
-
-        self.console.print("\n[bold green]Assistant:[/bold green]")
-        full_completion = ""
-        # Streaming response loop
-        with Live(console=self.console) as live:
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                decoded_line = line.decode("utf-8")
-                if decoded_line.startswith("data: "):
-                    decoded_line = decoded_line[6:]
-                    if decoded_line == "[DONE]":
-                        break
-                    try:
-                        json_data = json.loads(decoded_line)
-                        content = json_data["choices"][0]["delta"].get("content", "")
-                        full_completion += content
-                        markdown = Markdown(markup=full_completion)
-                        live.update(markdown, refresh=True)
-                    except json.JSONDecodeError:
-                        self.console.print("[red]Error decoding response JSON[/red]")
-                        if self.verbose:
-                            self.console.print(f"[red]Error decoding JSON: {decoded_line}[/red]")
-                time.sleep(0.05)
-
-        self.console.print()  # Add a newline after the completion
-
-    def get_command_from_llm(self, prompt):
-        """Request Shell command from LLM"""
-        url = f"{self.config['BASE_URL']}/chat/completions"
-        headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
-        data = {
-            "model": self.config["MODEL"],
-            "messages": [
-                {
-                    "role": "system",
-                    "content": "You are a command line assistant, return one Linux/macOS shell commands only, without explanation and triple-backtick code blocks.",
-                },
-                {"role": "user", "content": prompt},
-            ],
-            "stream": False,  # Always use non-streaming for command generation
-        }
-
-        try:
-            response = self._call_api(url, headers, data)
-        except requests.exceptions.RequestException as e:
-            self.console.print(f"[red]Error calling API: {e}[/red]")
-            return None
-        if not response:
-            return None
-        ANSWER_PATH = self.config.get("ANSWER_PATH", None)
-        if not ANSWER_PATH:
-            ANSWER_PATH = "choices[0].message.content"
-            if self.verbose:
-                self.console.print(
-                    "[bold yellow]Answer path not set. Using default: `choices[0].message.content`[/bold yellow]"
-                )
-        content = jmespath.search(ANSWER_PATH, response.json())
-        return content.strip()
-
-    def execute_shell_command(self, command):
-        """Execute shell command"""
-        self.console.print(f"\n[bold green]Executing command: [/bold green] {command}\n")
-        result = subprocess.run(command, shell=True)
-        if result.returncode != 0:
-            self.console.print(
-                f"\n[bold red]Command failed with return code: {result.returncode}[/bold red]"
-            )
-
-    def get_prompt_tokens(self):
-        """Get prompt tokens based on current mode"""
-        if self.current_mode == ModeEnum.CHAT.value:
-            qmark = "💬"
-        elif self.current_mode == ModeEnum.EXECUTE.value:
-            qmark = "🚀"
-        else:
-            qmark = ""
-        return [("class:qmark", qmark), ("class:question", " {} ".format(">"))]
-
-    def chat_mode(self, user_input: str):
-        """Interactive chat mode"""
-        if self.current_mode != ModeEnum.CHAT.value:
-            return self.current_mode
-
-        self.call_llm_api(user_input)
-        return ModeEnum.CHAT.value
-
-    def _filter_command(self, command):
-        """Filter out unwanted characters from command
-
-        The LLM may return commands in markdown format with code blocks.
-        This method removes markdown formatting from the command.
-        It handles various formats including:
-        - Commands surrounded by ``` (plain code blocks)
-        - Commands with language specifiers like ```bash, ```zsh, etc.
-        - Commands with specific examples like ```ls -al```
-
-        example:
-        ```bash\nls -la\n``` ==> ls -al
-        ```zsh\nls -la\n``` ==> ls -al
-        ```ls -al``` ==> ls -al
-        ls -al ==> ls -al
-        ```\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
-        ```bash\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
-        """
-        if not command or not command.strip():
-            return ""
-
-        # Handle commands that are already without code blocks
-        if "```" not in command:
-            return command.strip()
-
-        # Handle code blocks with or without language specifiers
-        lines = command.strip().split("\n")
-
-        # Check if it's a single-line code block like ```ls -al```
-        if len(lines) == 1 and lines[0].startswith("```") and lines[0].endswith("```"):
-            return lines[0][3:-3].strip()
-
-        # Handle multi-line code blocks
-        if lines[0].startswith("```"):
-            # Remove the opening ``` line (with or without language specifier)
-            content_lines = lines[1:]
-
-            # If the last line is a closing ```, remove it
-            if content_lines and content_lines[-1].strip() == "```":
-                content_lines = content_lines[:-1]
-
-            # Join the remaining lines and strip any extra whitespace
-            return "\n".join(line.strip() for line in content_lines if line.strip())
-
-    def execute_mode(self, user_input: str):
-        """Execute mode"""
-        if user_input == "" or self.current_mode != ModeEnum.EXECUTE.value:
-            return self.current_mode
-
-        command = self.get_command_from_llm(user_input)
-        command = self._filter_command(command)
-        if not command:
-            self.console.print("[bold red]No command generated[/bold red]")
-            return self.current_mode
-        self.console.print(f"\n[bold magenta]Generated command:[/bold magenta] {command}")
-        confirm = Confirm.ask("Execute this command?")
-        if confirm:
-            self.execute_shell_command(command)
-        return ModeEnum.EXECUTE.value
-
-    def run_repl_loop(self):
-        while True:
-            user_input = self.session.prompt(self.get_prompt_tokens)
-            # Skip empty input
-            if not user_input.strip():
-                continue
-
-            if user_input.lower() in ("exit", "quit"):
-                break
-
-            if self.current_mode == ModeEnum.CHAT.value:
-                self.chat_mode(user_input)
-            elif self.current_mode == ModeEnum.EXECUTE.value:
-                self.execute_mode(user_input)
-
-        self.console.print("[bold green]Exiting...[/bold green]")
-
-    def run_one_shot(self, prompt: str):
-        """Run one-shot mode with given prompt"""
-        if self.current_mode == ModeEnum.EXECUTE.value:
-            self.execute_mode(prompt)  # Execute mode for one-shot prompt
-        else:
-            self.call_llm_api(prompt)
-
-    def run(self, chat=False, shell=False, prompt: Optional[str] = None):
-        """Run the CLI application"""
-        # Load configuration
-        self.config = self.load_config()
-        if not self.config.get("API_KEY", None):
-            self.console.print(
-                "[red]API key not found. Please set it in the configuration file.[/red]"
-            )
-            return
-
-        # Set initial mode
-        self.current_mode = self.config["DEFAULT_MODE"]
-
-        # Check run mode from command line arguments
-        if all([chat, shell]):
-            self.console.print("[red]Cannot use both --chat and --shell[/red]")
-            return
-        elif chat:
-            self.current_mode = ModeEnum.CHAT.value
-        elif shell:
-            self.current_mode = ModeEnum.EXECUTE.value
-
-        if self.verbose:
-            self.console.print("[bold yellow]Verbose mode enabled[/bold yellow]")
-            self.console.print(f"[bold yellow]Current mode: {self.current_mode}[/bold yellow]")
-            self.console.print(f"[bold yellow]Using model: {self.config['MODEL']}[/bold yellow]")
-
-        if self.current_mode in (ModeEnum.TEMP.value, ModeEnum.EXECUTE.value) and prompt:
-            self.run_one_shot(prompt)
-        elif self.current_mode == ModeEnum.CHAT.value:
-            self.run_repl_loop()
-
-
-# CLI application setup
-CONTEXT_SETTINGS = {
-    "help_option_names": ["-h", "--help"],
-    "show_default": True,
-}
-
-app = typer.Typer(
-    name="ShellAI",
-    context_settings=CONTEXT_SETTINGS,
-    pretty_exceptions_enable=False,
-    short_help="ShellAI Command Line Tool",
-    no_args_is_help=True,
-    invoke_without_command=True,
-)
-
-
-@app.command()
-def main(
-    prompt: Annotated[str, typer.Argument(show_default=False, help="The prompt send to the LLM")],
-    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,
-):
-    """LLM CLI Tool"""
-    cli = ShellAI()
-    cli.run(chat=chat, shell=shell, prompt=prompt)
-
-
-if __name__ == "__main__":
-    app()