yaicli 0.0.4__tar.gz → 0.0.5__tar.gz

{yaicli-0.0.4 → yaicli-0.0.5}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.4
+current_version = 0.0.5
 commit = True
 tag = True
 

{yaicli-0.0.4 → yaicli-0.0.5}/CHANGELOG.md

@@ -1,4 +1,17 @@
 
+---
+## [0.0.4](https://github.com/belingud/yaicli/compare/v0.0.3..v0.0.4) - 2025-04-02
+
+### 🚜 Refactor
+
+- simplify multi-line statements for better readability - ([4870bb7](https://github.com/belingud/yaicli/commit/4870bb7460682791ca79bbe2bcc0cef94bf51c26)) - Belingud
+- rename ShellAI to yaicli and improve CLI help handling - ([dad0905](https://github.com/belingud/yaicli/commit/dad090540a7c1f8c8b30e3c688643a76e504b0c0)) - Belingud
+
+### ⚙️ Miscellaneous Tasks
+
+- update yaicli version to 0.0.3 - ([a689a02](https://github.com/belingud/yaicli/commit/a689a02b1c5e0cb278484267ef71f5f3acec8203)) - Belingud
+
+
 ---
 ## [0.0.3](https://github.com/belingud/yaicli/compare/v0.0.2..v0.0.3) - 2025-04-02
 

yaicli-0.0.5/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: yaicli
+Version: 0.0.5
+Summary: A simple CLI tool to interact with LLM
+License-File: LICENSE
+Requires-Python: >=3.9
+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
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.2
+Description-Content-Type: text/markdown
+
+# YAICLI - Your AI Command Line Interface
+
+YAICLI is a powerful command-line AI assistant tool that enables you to interact with Large Language Models (LLMs) through your terminal. It offers multiple operation modes for everyday conversations, generating and executing shell commands, and one-shot quick queries.
+
+## Features
+
+- **Multiple Operation Modes**:
+  - **Chat Mode (💬)**: Interactive conversation with the AI assistant
+  - **Execute Mode (🚀)**: Generate and execute shell commands specific to your OS and shell
+  - **Temp Mode**: Quick queries without entering interactive mode
+
+- **Smart Environment Detection**:
+  - Automatically detects your operating system and shell
+  - Customizes responses and commands for your specific environment
+
+- **Rich Terminal Interface**:
+  - Markdown rendering for formatted responses
+  - Streaming responses for real-time feedback
+  - Color-coded output for better readability
+
+- **Configurable**:
+  - Customizable API endpoints
+  - Support for different LLM providers
+  - Adjustable response parameters
+
+- **Keyboard Shortcuts**:
+  - Tab to switch between Chat and Execute modes
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 or higher
+- pip (Python package manager)
+
+### Install from PyPI
+
+```bash
+# Install by pip
+pip install yaicli
+
+# Install by pipx
+pipx install yaicli
+
+# Install by uv
+uv tool install yaicli
+```
+
+### Install from Source
+
+```bash
+git clone https://github.com/yourusername/yaicli.git
+cd yaicli
+pip install .
+```
+
+## Configuration
+
+On first run, YAICLI will create a default configuration file at `~/.config/yaicli/config.ini`. You'll need to edit this file to add your API key and customize other settings.
+
+Just run `ai`, and it will create the config file for you. Then you can edit it to add your api key.
+
+### Configuration File
+
+```ini
+[core]
+BASE_URL=https://api.openai.com/v1
+API_KEY=your_api_key_here
+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
+```
+
+### Configuration Options
+
+- **BASE_URL**: API endpoint URL (default: OpenAI API)
+- **API_KEY**: Your API key for the LLM provider
+- **MODEL**: The model to use (e.g., gpt-4o, gpt-3.5-turbo), default: gpt-4o
+- **DEFAULT_MODE**: Default operation mode (chat, exec, or temp), default: temp
+- **SHELL_NAME**: Shell to use (auto for automatic detection), default: auto
+- **OS_NAME**: OS to use (auto for automatic detection), default: auto
+- **COMPLETION_PATH**: Path for completions endpoint, default: /chat/completions
+- **ANSWER_PATH**: Json path expression to extract answer from response, default: choices[0].message.content
+- **STREAM**: Enable/disable streaming responses
+
+## Usage
+
+### Basic Usage
+
+```bash
+# One-shot mode
+ai "What is the capital of France?"
+
+# Chat mode
+ai --chat
+
+# Shell command generation mode
+ai --shell "Create a backup of my Documents folder"
+
+# Verbose mode for debugging
+ai --verbose "Explain quantum computing"
+```
+
+### Command Line Options
+
+- `<PROMPT>`: Argument
+- `--verbose` or `-V`: Show verbose information
+- `--chat` or `-c`: Start in chat mode
+- `--shell` or `-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` or `-h`: Show this message and exit
+
+```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.                                                                                              │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+
+```
+
+### Interactive Mode
+
+In interactive mode (chat or shell), you can:
+- Type your queries and get responses
+- Use `Tab` to switch between Chat and Execute modes
+- Type 'exit' or 'quit' to exit
+
+### Shell Command Generation
+
+In Execute mode:
+1. Enter your request in natural language
+2. YAICLI will generate an appropriate shell command
+3. Review the command
+4. Confirm to execute or reject
+
+## Examples
+
+### Chat Mode Example
+
+```bash
+$ ai --chat
+💬 > Tell me about the solar system
+
+Assistant:
+Certainly! Here’s a brief overview of the solar system:
+
+ • Sun: The central star of the solar system, providing light and energy.
+ • Planets:
+    • Mercury: Closest to the Sun, smallest planet.
+    • Venus: Second planet, known for its thick atmosphere and high surface temperature.
+    • Earth: Third planet, the only known planet to support life.
+    • Mars: Fourth planet, often called the "Red Planet" due to its reddish appearance.
+    • Jupiter: Largest planet, a gas giant with many moons.
+    • Saturn: Known for its prominent ring system, also a gas giant.
+    • Uranus: An ice giant, known for its unique axial tilt.
+    • Neptune: Another ice giant, known for its deep blue color.
+ • Dwarf Planets:
+    • Pluto: Once considered the ninth planet, now classified as
+
+💬 >
+```
+
+### Execute Mode Example
+
+```bash
+$ ai --shell "Find all PDF files in my Downloads folder"
+
+Generated command: find ~/Downloads -type f -name "*.pdf"
+Execute this command? [y/n]: y
+
+Executing command: find ~/Downloads -type f -name "*.pdf"
+
+/Users/username/Downloads/document1.pdf
+/Users/username/Downloads/report.pdf
+...
+```
+
+## Technical Implementation
+
+YAICLI is built using several Python libraries:
+
+- **Typer**: Provides the command-line interface
+- **Rich**: Provides terminal content formatting and beautiful display
+- **prompt_toolkit**: Provides interactive command-line input experience
+- **requests**: Handles API requests
+- **jmespath**: Parses JSON responses
+
+## Contributing
+
+Contributions of code, issue reports, or feature suggestions are welcome.
+
+## License
+
+[Apache License 2.0](LICENSE)
+
+---
+
+*YAICLI - Making your terminal smarter*

yaicli-0.0.5/README.md

@@ -0,0 +1,230 @@
+# YAICLI - Your AI Command Line Interface
+
+YAICLI is a powerful command-line AI assistant tool that enables you to interact with Large Language Models (LLMs) through your terminal. It offers multiple operation modes for everyday conversations, generating and executing shell commands, and one-shot quick queries.
+
+## Features
+
+- **Multiple Operation Modes**:
+  - **Chat Mode (💬)**: Interactive conversation with the AI assistant
+  - **Execute Mode (🚀)**: Generate and execute shell commands specific to your OS and shell
+  - **Temp Mode**: Quick queries without entering interactive mode
+
+- **Smart Environment Detection**:
+  - Automatically detects your operating system and shell
+  - Customizes responses and commands for your specific environment
+
+- **Rich Terminal Interface**:
+  - Markdown rendering for formatted responses
+  - Streaming responses for real-time feedback
+  - Color-coded output for better readability
+
+- **Configurable**:
+  - Customizable API endpoints
+  - Support for different LLM providers
+  - Adjustable response parameters
+
+- **Keyboard Shortcuts**:
+  - Tab to switch between Chat and Execute modes
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 or higher
+- pip (Python package manager)
+
+### Install from PyPI
+
+```bash
+# Install by pip
+pip install yaicli
+
+# Install by pipx
+pipx install yaicli
+
+# Install by uv
+uv tool install yaicli
+```
+
+### Install from Source
+
+```bash
+git clone https://github.com/yourusername/yaicli.git
+cd yaicli
+pip install .
+```
+
+## Configuration
+
+On first run, YAICLI will create a default configuration file at `~/.config/yaicli/config.ini`. You'll need to edit this file to add your API key and customize other settings.
+
+Just run `ai`, and it will create the config file for you. Then you can edit it to add your api key.
+
+### Configuration File
+
+```ini
+[core]
+BASE_URL=https://api.openai.com/v1
+API_KEY=your_api_key_here
+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
+```
+
+### Configuration Options
+
+- **BASE_URL**: API endpoint URL (default: OpenAI API)
+- **API_KEY**: Your API key for the LLM provider
+- **MODEL**: The model to use (e.g., gpt-4o, gpt-3.5-turbo), default: gpt-4o
+- **DEFAULT_MODE**: Default operation mode (chat, exec, or temp), default: temp
+- **SHELL_NAME**: Shell to use (auto for automatic detection), default: auto
+- **OS_NAME**: OS to use (auto for automatic detection), default: auto
+- **COMPLETION_PATH**: Path for completions endpoint, default: /chat/completions
+- **ANSWER_PATH**: Json path expression to extract answer from response, default: choices[0].message.content
+- **STREAM**: Enable/disable streaming responses
+
+## Usage
+
+### Basic Usage
+
+```bash
+# One-shot mode
+ai "What is the capital of France?"
+
+# Chat mode
+ai --chat
+
+# Shell command generation mode
+ai --shell "Create a backup of my Documents folder"
+
+# Verbose mode for debugging
+ai --verbose "Explain quantum computing"
+```
+
+### Command Line Options
+
+- `<PROMPT>`: Argument
+- `--verbose` or `-V`: Show verbose information
+- `--chat` or `-c`: Start in chat mode
+- `--shell` or `-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` or `-h`: Show this message and exit
+
+```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.                                                                                              │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+
+```
+
+### Interactive Mode
+
+In interactive mode (chat or shell), you can:
+- Type your queries and get responses
+- Use `Tab` to switch between Chat and Execute modes
+- Type 'exit' or 'quit' to exit
+
+### Shell Command Generation
+
+In Execute mode:
+1. Enter your request in natural language
+2. YAICLI will generate an appropriate shell command
+3. Review the command
+4. Confirm to execute or reject
+
+## Examples
+
+### Chat Mode Example
+
+```bash
+$ ai --chat
+💬 > Tell me about the solar system
+
+Assistant:
+Certainly! Here’s a brief overview of the solar system:
+
+ • Sun: The central star of the solar system, providing light and energy.
+ • Planets:
+    • Mercury: Closest to the Sun, smallest planet.
+    • Venus: Second planet, known for its thick atmosphere and high surface temperature.
+    • Earth: Third planet, the only known planet to support life.
+    • Mars: Fourth planet, often called the "Red Planet" due to its reddish appearance.
+    • Jupiter: Largest planet, a gas giant with many moons.
+    • Saturn: Known for its prominent ring system, also a gas giant.
+    • Uranus: An ice giant, known for its unique axial tilt.
+    • Neptune: Another ice giant, known for its deep blue color.
+ • Dwarf Planets:
+    • Pluto: Once considered the ninth planet, now classified as
+
+💬 >
+```
+
+### Execute Mode Example
+
+```bash
+$ ai --shell "Find all PDF files in my Downloads folder"
+
+Generated command: find ~/Downloads -type f -name "*.pdf"
+Execute this command? [y/n]: y
+
+Executing command: find ~/Downloads -type f -name "*.pdf"
+
+/Users/username/Downloads/document1.pdf
+/Users/username/Downloads/report.pdf
+...
+```
+
+## Technical Implementation
+
+YAICLI is built using several Python libraries:
+
+- **Typer**: Provides the command-line interface
+- **Rich**: Provides terminal content formatting and beautiful display
+- **prompt_toolkit**: Provides interactive command-line input experience
+- **requests**: Handles API requests
+- **jmespath**: Parses JSON responses
+
+## Contributing
+
+Contributions of code, issue reports, or feature suggestions are welcome.
+
+## License
+
+[Apache License 2.0](LICENSE)
+
+---
+
+*YAICLI - Making your terminal smarter*

yaicli-0.0.5/README_wind.md

@@ -0,0 +1,195 @@
+# YAICLI - Your AI Command Line Interface
+
+YAICLI is a powerful command-line AI assistant tool that allows you to interact with Large Language Models (LLMs) through your terminal. It provides multiple operation modes for daily conversations, generating and executing shell commands, and quick one-time queries.
+
+## Features
+
+### Multiple Operation Modes
+
+1. **Chat Mode**
+   - Interactive conversation interface
+   - Markdown-formatted responses
+   - Streaming output display
+
+2. **Execute Mode**
+   - Automatically generates shell commands from natural language descriptions
+   - Detects current operating system and shell environment to generate appropriate commands
+   - Automatically filters unnecessary Markdown formatting from command output
+   - Confirmation mechanism before execution for safety
+
+3. **Temp Mode (One-shot)**
+   - Quick single queries without maintaining a session
+
+### Intelligent Environment Detection
+
+- Automatically detects operating system (Windows, MacOS, Linux and its distributions)
+- Automatically detects shell type (bash, zsh, PowerShell, cmd, etc.)
+- Customizes prompts and commands based on your environment
+
+### User Experience
+
+- Streaming response display for real-time AI output viewing
+- Keyboard shortcuts (e.g., Ctrl+I to switch modes)
+- Command confirmation mechanism to prevent accidental execution
+
+## Requirements
+
+- Python 3.9+
+- Supported operating systems: Windows, MacOS, Linux
+
+## Dependencies
+
+```
+configparser
+json
+platform
+subprocess
+time
+jmespath
+requests
+typer
+distro
+prompt_toolkit
+```
+
+## Installation
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/yaicli.git
+   cd yaicli
+   ```
+
+2. Create virtual environment and install dependencies:
+   ```bash
+   uv sync
+   ```
+
+
+## Configuration
+
+The first time you run YAICLI, it will create a default configuration file at `~/.config/yaicli/config.ini`. You'll need to edit this file and add your API key.
+
+Example configuration file:
+
+```ini
+[core]
+BASE_URL=https://api.openai.com/v1
+API_KEY=your-api-key-here
+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
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+# One-shot mode (default): Send a prompt and get a response
+ai "How do I check memory usage on a Linux system?"
+
+# Chat mode: Start an interactive chat session
+ai --chat
+
+# Execute mode: Generate and execute shell commands
+ai --shell "Create a directory named project and create src and docs subdirectories in it"
+
+# Enable verbose output
+ai --verbose "Explain how Docker works"
+```
+
+### Interactive Commands
+
+In chat or execute mode:
+
+- Press `Ctrl+I` to switch between chat and execute modes
+- Type `exit` or `quit` to exit the application
+
+### Mode Descriptions
+
+1. **Chat Mode (--chat)**
+   ```bash
+   ai --chat
+   ```
+   Starts an interactive session where you can converse with the AI. Responses will be displayed in Markdown format.
+
+2. **Execute Mode (--shell)**
+   ```bash
+   ai --shell "Find all files larger than 100MB"
+   ```
+   The AI will generate appropriate shell commands and execute them after your confirmation.
+
+3. **One-shot Mode (default)**
+   ```bash
+   ai "Explain the difference between TCP and UDP"
+   ```
+   Sends a single query, provides the response, and exits.
+
+## Advanced Usage
+
+### Custom System Recognition
+
+If you want to specify a particular operating system or shell, you can modify the configuration file:
+
+```ini
+[core]
+# ...other configuration...
+SHELL_NAME=bash  # Force bash shell command syntax
+OS_NAME=Ubuntu   # Force commands targeting Ubuntu
+```
+
+### Custom API Endpoint
+
+YAICLI uses the OpenAI API by default, but you can use compatible APIs by modifying the configuration:
+
+```ini
+[core]
+BASE_URL=https://your-api-endpoint/v1
+COMPLETION_PATH=/chat/completions
+ANSWER_PATH=custom.json.path.to.content
+```
+
+## Technical Implementation
+
+YAICLI is built using several Python libraries:
+
+- **Typer**: Provides the command-line interface
+- **prompt_toolkit**: Provides interactive command-line input experience
+- **requests**: Handles API requests
+- **jmespath**: Parses JSON responses
+
+## Limitations and Notes
+
+- Requires a valid OpenAI API key or compatible API
+- Commands generated in execute mode should be carefully reviewed before execution
+- API calls may incur charges depending on your service provider and model
+
+## Contributing
+
+Contributions of code, issue reports, or feature suggestions are welcome.
+
+## License
+
+Apache License 2.0
+
+---
+
+*YAICLI - Making your terminal smarter*

{yaicli-0.0.4 → yaicli-0.0.5}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "yaicli"
-version = "0.0.4"
+version = "0.0.5"
 description = "A simple CLI tool to interact with LLM"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = [
     "distro>=1.9.0",
     "jmespath>=1.0.1",

yaicli-0.0.5/test_yaicli.py

@@ -0,0 +1,52 @@
+import pytest
+
+from yaicli import YAICLI
+
+
+@pytest.fixture
+def yaicli():
+    return YAICLI()
+
+def test_filter_command_basic(yaicli):
+    """test basic command filtering"""
+    command = "ls -la"
+    assert yaicli._filter_command(command) == "ls -la"
+
+
+@pytest.mark.parametrize("input_cmd,expected", [
+    ("```\nls -la\n```", "ls -la"),
+    ("```ls -la```", "ls -la"),
+])
+def test_filter_command_with_code_block(yaicli, input_cmd, expected):
+    """test code block"""
+    assert yaicli._filter_command(input_cmd) == expected
+
+@pytest.mark.parametrize("input_cmd,expected", [
+    ("```bash\nls -la\n```", "ls -la"),
+    ("```zsh\nls -la\n```", "ls -la"),
+    ("```shell\nls -la\n```", "ls -la"),
+    ("```sh\nls -la\n```", "ls -la"),
+])
+def test_filter_command_with_shell_type(yaicli, input_cmd, expected):
+    """test shell type declaration code block"""
+    assert yaicli._filter_command(input_cmd) == expected
+
+def test_filter_command_multiline(yaicli):
+    """test multiline command"""
+    command = "```\ncd /tmp\nls -la\n```"
+    assert yaicli._filter_command(command) == "cd /tmp\nls -la"
+
+def test_filter_command_with_spaces(yaicli):
+    """test command with extra spaces"""
+    command = "```bash  \n  ls -la  \n  ```"
+    assert yaicli._filter_command(command) == "ls -la"
+
+def test_filter_command_empty_block(yaicli):
+    """test empty code block"""
+    command = "```\n\n```"
+    assert yaicli._filter_command(command) == ""
+
+def test_filter_command_nested_blocks(yaicli):
+    """test nested code block"""
+    command = "```bash\n```echo hello```\n```"
+    assert yaicli._filter_command(command) == "```echo hello```"

{yaicli-0.0.4 → yaicli-0.0.5}/uv.lock

@@ -1,10 +1,6 @@
 version = 1
 revision = 1
-requires-python = ">=3.8"
-resolution-markers = [
-    "python_full_version >= '3.9'",
-    "python_full_version < '3.9'",
-]
+requires-python = ">=3.9"
 
 [[package]]
 name = "bump2version"
@@ -82,19 +78,6 @@ wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd" },
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407" },
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/10/bd/6517ea94f2672e801011d50b5d06be2a0deaf566aea27bcdcd47e5195357/charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/e5/0d/815a2ba3f283b4eeaa5ece57acade365c5b4135f65a807a083c818716582/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/aa/17/c94be7ee0d142687e047fe1de72060f6d6837f40eedc26e87e6e124a3fc6/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/f7/33/557ac796c47165fc141e4fb71d7b0310f67e05cb420756f3a82e0a0068e0/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/1e/0d/38ef4ae41e9248d63fc4998d933cae22473b1b2ac4122cf908d0f5eb32aa/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/43/01/754cdb29dd0560f58290aaaa284d43eea343ad0512e6ad3b8b5c11f08592/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/ba/cd/861883ba5160c7a9bd242c30b2c71074cda2aefcc0addc91118e0d4e0765/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/6f/7f/0c0dad447819e90b93f8ed238cc8f11b91353c23c19e70fa80483a155bed/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/8e/09/9f8abcc6fff60fb727268b63c376c8c79cc37b833c2dfe1f535dfb59523b/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/be/e5/3f363dad2e24378f88ccf63ecc39e817c29f32e308ef21a7a6d9c1201165/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/e4/10/a78c0e91f487b4ad0ef7480ac765e15b774f83de2597f1b6ef0eaf7a2f99/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/d3/81/396e7d7f5d7420da8273c91175d2e9a3f569288e3611d521685e4b9ac9cc/charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e" },
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/40/bb/20affbbd9ea29c71ea123769dc568a6d42052ff5089c5fe23e21e21084a6/charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4" },
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/7f/c0/b913f8f02836ed9ab32ea643c6fe4d3325c3d8627cf6e78098671cafff86/charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41" },
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/0f/6c/2bee440303d705b6fb1e2ec789543edec83d32d258299b16eed28aad48e0/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f" },
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/3d/04/cb42585f07f6f9fd3219ffb6f37d5a39b4fd2db2355b23683060029c35f7/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2" },
@@ -262,8 +245,7 @@ dependencies = [
     { name = "certifi" },
     { name = "charset-normalizer" },
     { name = "idna" },
-    { name = "urllib3", version = "2.2.3", source = { registry = "https://repo.huaweicloud.com/repository/pypi/simple/" }, marker = "python_full_version < '3.9'" },
-    { name = "urllib3", version = "2.3.0", source = { registry = "https://repo.huaweicloud.com/repository/pypi/simple/" }, marker = "python_full_version >= '3.9'" },
+    { name = "urllib3" },
 ]
 sdist = { url = "https://repo.huaweicloud.com/repository/pypi/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760" }
 wheels = [
@@ -381,25 +363,10 @@ wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/e0/86/39b65d676ec5732de17b7e3c476e45bb80ec64eb50737a8dce1a4178aba1/typing_extensions-4.13.0-py3-none-any.whl", hash = "sha256:c8dd92cc0d6425a97c18fbb9d1954e5ff92c1ca881a309c45f06ebc0b79058e5" },
 ]
 
-[[package]]
-name = "urllib3"
-version = "2.2.3"
-source = { registry = "https://repo.huaweicloud.com/repository/pypi/simple/" }
-resolution-markers = [
-    "python_full_version < '3.9'",
-]
-sdist = { url = "https://repo.huaweicloud.com/repository/pypi/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9" }
-wheels = [
-    { url = "https://repo.huaweicloud.com/repository/pypi/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac" },
-]
-
 [[package]]
 name = "urllib3"
 version = "2.3.0"
 source = { registry = "https://repo.huaweicloud.com/repository/pypi/simple/" }
-resolution-markers = [
-    "python_full_version >= '3.9'",
-]
 sdist = { url = "https://repo.huaweicloud.com/repository/pypi/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d" }
 wheels = [
     { url = "https://repo.huaweicloud.com/repository/pypi/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df" },

{yaicli-0.0.4 → yaicli-0.0.5}/yaicli.py

@@ -33,7 +33,13 @@ class CasePreservingConfigParser(configparser.RawConfigParser):
         return optionstr
 
 
-class ShellAI:
+class YAICLI:
+    """Main class for YAICLI
+    Chat mode: interactive chat mode
+    One-shot mode:
+        Temp mode: ask a question and get a response once
+        Execute mode: generate and execute shell commands
+    """
     # Configuration file path
     CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
 
@@ -45,8 +51,8 @@ MODEL=gpt-4o
 
 # default run mode, default: temp
 # chat: interactive chat mode
-# exec: shell command generation mode
-# temp: one-shot mode
+# exec: generate and execute shell commands once
+# temp: ask a question and get a response once
 DEFAULT_MODE=temp
 
 # auto detect shell and os
@@ -69,6 +75,8 @@ STREAM=true"""
         self.session = PromptSession(key_bindings=self.bindings)
         self.current_mode = ModeEnum.CHAT.value
         self.config = {}
+        self.history = []
+        self.max_history_length = 25
 
         # Setup key bindings
         self._setup_key_bindings()
@@ -82,10 +90,19 @@ STREAM=true"""
                 ModeEnum.CHAT.value if self.current_mode == ModeEnum.EXECUTE.value else ModeEnum.EXECUTE.value
             )
 
-    def detect_os(self):
-        """Detect operating system"""
+    def clear_history(self):
+        """Clear chat history"""
+        self.history = []
+
+    def detect_os(self) -> str:
+        """Detect operating system
+        Returns:
+            str: operating system name
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
         if self.config.get("OS_NAME") != "auto":
-            return self.config.get("OS_NAME")
+            return self.config["OS_NAME"]
         current_platform = platform.system()
         if current_platform == "Linux":
             return "Linux/" + distro_name(pretty=True)
@@ -95,10 +112,15 @@ STREAM=true"""
             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")
+    def detect_shell(self) -> str:
+        """Detect shell
+        Returns:
+            str: shell name
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
+        if self.config["SHELL_NAME"] != "auto":
+            return self.config["SHELL_NAME"]
         import platform
 
         current_platform = platform.system()
@@ -107,7 +129,13 @@ STREAM=true"""
             return "powershell.exe" if is_powershell else "cmd.exe"
         return basename(getenv("SHELL", "/bin/sh"))
 
-    def build_cmd_prompt(self):
+    def build_cmd_prompt(self) -> str:
+        """Build command prompt
+        Returns:
+            str: command prompt
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
         _os = self.detect_os()
         _shell = self.detect_shell()
         return f"""Your are a Shell Command Generator.
@@ -119,8 +147,13 @@ Rules:
 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"""
+    def build_default_prompt(self) -> str:
+        """Build default prompt
+        Returns:
+            str: default prompt
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
         _os = self.detect_os()
         _shell = self.detect_shell()
         return (
@@ -130,8 +163,13 @@ Rules:
             "unless the user explicitly requests more details."
         )
 
-    def get_default_config(self):
-        """Get default configuration"""
+    def get_default_config(self) -> dict[str, str]:
+        """Get default configuration
+        Returns:
+            dict: default configuration
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
         config = CasePreservingConfigParser()
         try:
             config.read_string(self.DEFAULT_CONFIG_INI)
@@ -142,8 +180,13 @@ Rules:
             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"""
+    def load_config(self) -> dict[str, str]:
+        """Load LLM API configuration
+        Returns:
+            dict: configuration
+        Raises:
+            typer.Exit: if there is an error with the request
+        """
         if not self.CONFIG_PATH.exists():
             self.console.print(
                 "[bold yellow]Configuration file not found. Creating default configuration file.[/bold yellow]"
@@ -158,14 +201,28 @@ Rules:
         self.config["STREAM"] = str(self.config.get("STREAM", "true")).lower()
         return self.config
 
-    def _call_api(self, url, headers, data):
-        """Generic API call method"""
+    def _call_api(self, url: str, headers: dict, data: dict) -> requests.Response:
+        """Call the API and return the response.
+        Args:
+            url: API endpoint URL
+            headers: request headers
+            data: request data
+        Returns:
+            requests.Response: response object
+        Raises:
+            requests.exceptions.RequestException: if there is an error with the request
+        """
         response = requests.post(url, headers=headers, json=data)
         response.raise_for_status()  # Raise an exception for non-200 status codes
         return response
 
-    def get_llm_url(self) -> Optional[str]:
-        """Get LLM API URL"""
+    def get_llm_url(self) -> str:
+        """Get LLM API URL
+        Returns:
+            str: LLM API URL
+        Raises:
+            typer.Exit: if API key or base URL is not set
+        """
         base = self.config.get("BASE_URL", "").rstrip("/")
         if not base:
             self.console.print(
@@ -181,25 +238,44 @@ Rules:
         return f"{base}/{COMPLETION_PATH}"
 
     def build_data(self, prompt: str, mode: str = ModeEnum.TEMP.value) -> dict:
-        """Build request data"""
+        """Build request data
+        Args:
+            prompt: user input
+            mode: chat or execute mode
+        Returns:
+            dict: request data
+        """
         if mode == ModeEnum.EXECUTE.value:
             system_prompt = self.build_cmd_prompt()
         else:
             system_prompt = self.build_default_prompt()
+
+        # Build messages list, first add system prompt
+        messages = [{"role": "system", "content": system_prompt}]
+
+        # Add history records in chat mode
+        if mode == ModeEnum.CHAT.value and self.history:
+            messages.extend(self.history)
+
+        # Add current user message
+        messages.append({"role": "user", "content": prompt})
+
         return {
             "model": self.config["MODEL"],
-            "messages": [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt},
-            ],
+            "messages": messages,
             "stream": self.config.get("STREAM", "true") == "true",
             "temperature": 0.7,
             "top_p": 0.7,
             "max_tokens": 200,
         }
 
-    def stream_response(self, response):
-        """Stream response from LLM API"""
+    def stream_response(self, response: requests.Response) -> str:
+        """Stream response from LLM API
+        Args:
+            response: requests.Response object
+        Returns:
+            str: full completion text
+        """
         full_completion = ""
         # Streaming response loop
         with Live(console=self.console) as live:
@@ -223,8 +299,15 @@ Rules:
                             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"""
+        return full_completion
+
+    def call_llm_api(self, prompt: str) -> str:
+        """Call LLM API, return streaming output
+        Args:
+            prompt: user input
+        Returns:
+            str: streaming output
+        """
         url = self.get_llm_url()
         headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
         data = self.build_data(prompt)
@@ -239,11 +322,18 @@ Rules:
             raise typer.Exit(code=1)
 
         self.console.print("\n[bold green]Assistant:[/bold green]")
-        self.stream_response(response)  # Stream the response
+        assistant_response = self.stream_response(response)  # Stream the response and get the full text
         self.console.print()  # Add a newline after the completion
 
-    def get_command_from_llm(self, prompt):
-        """Request Shell command from LLM"""
+        return assistant_response
+
+    def get_command_from_llm(self, prompt: str) -> Optional[str]:
+        """Request Shell command from LLM
+        Args:
+            prompt: user input
+        Returns:
+            str: shell command
+        """
         url = self.get_llm_url()
         headers = {"Authorization": f"Bearer {self.config['API_KEY']}"}
         data = self.build_data(prompt, mode=ModeEnum.EXECUTE.value)
@@ -265,15 +355,24 @@ Rules:
         content = jmespath.search(ANSWER_PATH, response.json())
         return content.strip()
 
-    def execute_shell_command(self, command):
-        """Execute shell command"""
+    def execute_shell_command(self, command: str) -> int:
+        """Execute shell command
+        Args:
+            command: shell command
+        Returns:
+            int: return code
+        """
         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]")
+        return result.returncode
 
     def get_prompt_tokens(self):
-        """Get prompt tokens based on current mode"""
+        """Get prompt tokens based on current mode
+        Returns:
+            list: prompt tokens for prompt_toolkit
+        """
         if self.current_mode == ModeEnum.CHAT.value:
             qmark = "💬"
         elif self.current_mode == ModeEnum.EXECUTE.value:
@@ -283,14 +382,35 @@ Rules:
         return [("class:qmark", qmark), ("class:question", " {} ".format(">"))]
 
     def chat_mode(self, user_input: str):
-        """Interactive chat mode"""
+        """
+        This method handles the chat mode.
+        It adds the user input to the history and calls the API to get a response.
+        It then adds the response to the history and manages the history length.
+        Args:
+            user_input: user input
+        Returns:
+            ModeEnum: current mode
+        """
         if self.current_mode != ModeEnum.CHAT.value:
             return self.current_mode
 
-        self.call_llm_api(user_input)
+        # Add user message to history
+        self.history.append({"role": "user", "content": user_input})
+
+        # Call API and get response
+        assistant_response = self.call_llm_api(user_input)
+
+        # Add assistant response to history
+        if assistant_response:
+            self.history.append({"role": "assistant", "content": assistant_response})
+
+        # Manage history length, keep recent conversations
+        if len(self.history) > self.max_history_length * 2:  # Each conversation has user and assistant messages
+            self.history = self.history[-self.max_history_length * 2 :]
+
         return ModeEnum.CHAT.value
 
-    def _filter_command(self, command):
+    def _filter_command(self, command: str) -> Optional[str]:
         """Filter out unwanted characters from command
 
         The LLM may return commands in markdown format with code blocks.
@@ -335,11 +455,21 @@ Rules:
             return "\n".join(line.strip() for line in content_lines if line.strip())
 
     def execute_mode(self, user_input: str):
-        """Execute mode"""
+        """
+        This method generates a shell command from the user input and executes it.
+        If the user confirms the command, it is executed.
+        Args:
+            user_input: user input
+        Returns:
+            ModeEnum: current mode
+        """
         if user_input == "" or self.current_mode != ModeEnum.EXECUTE.value:
             return self.current_mode
 
         command = self.get_command_from_llm(user_input)
+        if not command:
+            self.console.print("[bold red]No command generated[/bold red]")
+            return self.current_mode
         command = self._filter_command(command)
         if not command:
             self.console.print("[bold red]No command generated[/bold red]")
@@ -357,25 +487,44 @@ Rules:
             if not user_input.strip():
                 continue
 
-            if user_input.lower() in ("exit", "quit"):
+            if user_input.lower() in ("/exit", "/quit", "/q"):
                 break
 
+            # Handle special commands
             if self.current_mode == ModeEnum.CHAT.value:
-                self.chat_mode(user_input)
+                if user_input.lower() == "/clear":
+                    self.clear_history()
+                    self.console.print("[bold yellow]Chat history cleared[/bold yellow]\n")
+                    continue
+                else:
+                    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"""
+        """Run one-shot mode with given prompt
+        Args:
+            prompt (str): Prompt to send to LLM
+        Returns:
+            None
+        """
         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"""
+        """Run the CLI application
+        Args:
+            chat (bool): Whether to run in chat mode
+            shell (bool): Whether to run in shell mode
+            prompt (Optional[str]): Prompt send to LLM
+
+        Returns:
+            None
+        """
         # Load configuration
         self.config = self.load_config()
         if not self.config.get("API_KEY", None):
@@ -434,7 +583,7 @@ def main(
         typer.echo(ctx.get_help())
         raise typer.Exit()
 
-    cli = ShellAI(verbose=verbose)
+    cli = YAICLI(verbose=verbose)
     cli.run(chat=chat, shell=shell, prompt=prompt)
 
 

yaicli-0.0.4/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: yaicli
-Version: 0.0.4
-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
-Requires-Dist: rich>=13.9.4
-Requires-Dist: typer>=0.15.2
-Description-Content-Type: text/markdown
-
-# llmcli

yaicli-0.0.4/README.md

@@ -1 +0,0 @@
-# llmcli

yaicli-0.0.4/tests

@@ -1,52 +0,0 @@
-import pytest
-
-from yaicli import ShellAI
-
-
-@pytest.fixture
-def shell_ai():
-    return ShellAI()
-
-def test_filter_command_basic(shell_ai):
-    """测试基本的命令过滤"""
-    command = "ls -la"
-    assert shell_ai._filter_command(command) == "ls -la"
-
-
-@pytest.mark.parametrize("input_cmd,expected", [
-    ("```\nls -la\n```", "ls -la"),
-    ("```ls -la```", "ls -la"),
-])
-def test_filter_command_with_code_block(shell_ai, input_cmd, expected):
-    """test code block"""
-    assert shell_ai._filter_command(input_cmd) == expected
-
-@pytest.mark.parametrize("input_cmd,expected", [
-    ("```bash\nls -la\n```", "ls -la"),
-    ("```zsh\nls -la\n```", "ls -la"),
-    ("```shell\nls -la\n```", "ls -la"),
-    ("```sh\nls -la\n```", "ls -la"),
-])
-def test_filter_command_with_shell_type(shell_ai, input_cmd, expected):
-    """测试带有shell类型声明的代码块"""
-    assert shell_ai._filter_command(input_cmd) == expected
-
-def test_filter_command_multiline(shell_ai):
-    """测试多行命令"""
-    command = "```\ncd /tmp\nls -la\n```"
-    assert shell_ai._filter_command(command) == "cd /tmp\nls -la"
-
-def test_filter_command_with_spaces(shell_ai):
-    """测试带有额外空格的命令"""
-    command = "```bash  \n  ls -la  \n  ```"
-    assert shell_ai._filter_command(command) == "ls -la"
-
-def test_filter_command_empty_block(shell_ai):
-    """测试空代码块"""
-    command = "```\n\n```"
-    assert shell_ai._filter_command(command) == ""
-
-def test_filter_command_nested_blocks(shell_ai):
-    """测试嵌套代码块"""
-    command = "```bash\n```echo hello```\n```"
-    assert shell_ai._filter_command(command) == "```echo hello```"