177 lines
5.4 KiB
Markdown
177 lines
5.4 KiB
Markdown
# Architecture Overview
|
|
|
|
This document provides a comprehensive overview of Edison's architecture, components, and their interactions.
|
|
|
|
## System Architecture
|
|
|
|
```mermaid
|
|
graph TD
|
|
subgraph User Interaction
|
|
CLI[CLI Module]
|
|
Interactive[Interactive Mode]
|
|
Console[Console UI]
|
|
end
|
|
|
|
subgraph Core Components
|
|
APIClient[API Client]
|
|
PromptManager[Prompt Manager]
|
|
CommandExecutor[Command Executor]
|
|
end
|
|
|
|
subgraph Configuration
|
|
ConfigManager[Config Manager]
|
|
Validation[Validation]
|
|
end
|
|
|
|
subgraph Utilities
|
|
Logging[Logging Utils]
|
|
OSUtils[OS Utils]
|
|
end
|
|
|
|
CLI --> APIClient
|
|
CLI --> CommandExecutor
|
|
CLI --> Console
|
|
CLI --> Interactive
|
|
Interactive --> APIClient
|
|
Interactive --> CommandExecutor
|
|
|
|
APIClient --> PromptManager
|
|
APIClient --> ConfigManager
|
|
CommandExecutor --> Validation
|
|
CommandExecutor --> OSUtils
|
|
|
|
ConfigManager --> Logging
|
|
|
|
style User Interaction fill:#f9d5e5,stroke:#333,stroke-width:2px
|
|
style Core Components fill:#d3f6db,stroke:#333,stroke-width:2px
|
|
style Configuration fill:#d3f6f5,stroke:#333,stroke-width:2px
|
|
style Utilities fill:#eeeeee,stroke:#333,stroke-width:2px
|
|
```
|
|
|
|
## Component Breakdown
|
|
|
|
### User Interaction Layer
|
|
|
|
The user interaction layer handles all user-facing functionality:
|
|
|
|
1. **CLI Module** (`edison/cli.py`):
|
|
- Entry point for the application
|
|
- Parses command-line arguments
|
|
- Initializes logging and configuration
|
|
- Coordinates between components
|
|
|
|
2. **Interactive Mode** (`edison/ui/interactive.py`):
|
|
- Provides a dedicated shell for continuous interaction
|
|
- Manages command history and user input
|
|
- Handles special commands and actions
|
|
|
|
3. **Console UI** (`edison/ui/console.py`):
|
|
- Formats and displays text output
|
|
- Presents commands and prompt options
|
|
- Manages colored output with termcolor
|
|
|
|
### Core Components
|
|
|
|
The core components handle the main business logic:
|
|
|
|
1. **API Client** (`edison/core/api_client.py`):
|
|
- Manages communication with the OpenAI API
|
|
- Handles API key management and retry logic
|
|
- Processes responses from the API
|
|
|
|
2. **Prompt Manager** (`edison/core/prompt_manager.py`):
|
|
- Constructs effective prompts for the AI model
|
|
- Formats user queries for optimal command generation
|
|
- Adapts prompts based on shell and OS
|
|
|
|
3. **Command Executor** (`edison/core/command_executor.py`):
|
|
- Safely executes generated commands
|
|
- Handles command output and errors
|
|
- Adapts execution for different shells and platforms
|
|
|
|
### Configuration Layer
|
|
|
|
The configuration layer manages settings and validation:
|
|
|
|
1. **Config Manager** (`edison/config/config_manager.py`):
|
|
- Loads and validates configuration from edison.yaml
|
|
- Provides default settings
|
|
- Handles environment variables for API keys
|
|
|
|
2. **Validation** (`edison/utils/validation.py`):
|
|
- Validates commands for safety
|
|
- Detects potentially dangerous operations
|
|
- Checks for invalid syntax or formatting
|
|
|
|
### Utilities
|
|
|
|
Utility modules provide support functions:
|
|
|
|
1. **Logging Utils** (`edison/utils/logging_utils.py`):
|
|
- Configures logging for the application
|
|
- Manages log files and levels
|
|
- Provides logger access
|
|
|
|
2. **OS Utils** (`edison/utils/os_utils.py`):
|
|
- Provides OS-specific functionality
|
|
- Detects platform and shell information
|
|
- Manages environment variables
|
|
|
|
## Data Flow
|
|
|
|
```mermaid
|
|
sequenceDiagram
|
|
participant User
|
|
participant CLI
|
|
participant Config
|
|
participant APIClient
|
|
participant CommandExecutor
|
|
participant Shell
|
|
|
|
User->>CLI: Input query
|
|
CLI->>Config: Load configuration
|
|
CLI->>APIClient: Send query
|
|
APIClient->>APIClient: Format prompt
|
|
APIClient->>OpenAI: API request
|
|
OpenAI-->>APIClient: Command response
|
|
APIClient-->>CLI: Return command
|
|
CLI->>User: Display command
|
|
User->>CLI: Confirm execution
|
|
CLI->>CommandExecutor: Execute command
|
|
CommandExecutor->>Shell: Run in shell
|
|
Shell-->>CommandExecutor: Command output
|
|
CommandExecutor-->>CLI: Execution result
|
|
CLI->>User: Display output
|
|
```
|
|
|
|
1. User inputs a natural language query
|
|
2. CLI loads configuration and processes arguments
|
|
3. Query is sent to the API client
|
|
4. API client formats the prompt and sends it to OpenAI
|
|
5. Response is received and processed
|
|
6. Command is displayed to the user
|
|
7. User confirms, modifies, or cancels execution
|
|
8. If confirmed, command is sent to the command executor
|
|
9. Command executor runs the command in the appropriate shell
|
|
10. Output is returned to the CLI and displayed to the user
|
|
|
|
## Extension Points
|
|
|
|
Edison is designed to be extensible in several ways:
|
|
|
|
1. **New UI Components**: Add new UI modes by extending the UI components
|
|
2. **Alternative AI Providers**: The API client can be extended to support other AI providers
|
|
3. **Custom Prompt Templates**: The prompt manager can be enhanced with specialized prompts
|
|
4. **Additional Command Validation**: Add custom validation rules in the validation module
|
|
5. **Platform-Specific Features**: Extend OS utils for additional platform support
|
|
|
|
## Technologies Used
|
|
|
|
Edison is built using:
|
|
|
|
- **Python**: Core programming language
|
|
- **OpenAI API**: For natural language processing and command generation
|
|
- **prompt_toolkit**: For interactive shell functionality
|
|
- **termcolor**: For colored terminal output
|
|
- **pyyaml**: For configuration file parsing
|
|
- **pyperclip**: For clipboard integration |