Rust + LLM 开发实战：构建智能命令行运维助手

Rust + LLM 开发实战：构建智能命令行运维助手 | 极客日志

sudo apt update && sudo apt install curl build-essential

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

source "$HOME/.cargo/env"

echo 'source "$HOME/.cargo/env"' >> ~/.bashrc

cargo new rust-shell-assistant
cd rust-shell-assistant

[package]
name = "rust-shell-assistant"
version = "1.0.0"
edition = "2021"
authors = ["Your Name <[email protected]>"]
description = "智能 Shell 助手 - 使用 AI 将自然语言转换为 Shell 命令"

[dependencies]
# 异步运行时
tokio = { version = "1.35", features = ["full"] }
# HTTP 客户端
reqwest = { version = "0.11", features = ["json"] }
# JSON 序列化
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
# 命令行参数解析
clap = { version = "4.4", features = ["derive"] }
# 终端彩色输出
colored = "2.1"
# 交互式命令行
rustyline = "13.0"
# 错误处理
anyhow = "1.0"
thiserror = "1.0"
# 环境变量
dotenv = "0.15"
# 日志
log = "0.4"
env_logger = "0.11"

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true

use anyhow::{Context, Result};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::time::Duration;
use crate::config::Config;

/// AI 客户端
pub struct AIClient {
    client: Client,
    config: Config,
}

/// API 请求消息
#[derive(Debug, Serialize, Deserialize)]
pub struct Message {
    pub role: String,
    pub content: String,
}

/// API 请求体
#[derive(Debug, Serialize)]
struct ChatRequest {
    model: String,
    messages: Vec<Message>,
    max_tokens: u32,
    temperature: f32,
}

/// API 响应体
#[derive(Debug, Deserialize)]
struct ChatResponse {
    choices: Vec<Choice>,
}

#[derive(Debug, Deserialize)]
struct Choice {
    message: Message,
}

impl AIClient {
    /// 创建新的 AI 客户端
    pub fn new(config: Config) -> Result<Self> {
        let client = Client::builder()
            .timeout(Duration::from_secs(config.timeout_seconds))
            .build()
            .context("创建 HTTP 客户端失败")?;
        Ok(AIClient { client, config })
    }

    /// 发送聊天请求
    pub async fn chat(&self, messages: Vec<Message>) -> Result<String> {
        let request_body = ChatRequest {
            model: self.config.model.clone(),
            messages,
            max_tokens: self.config.max_tokens,
            temperature: self.config.temperature,
        };
        let mut request = self.client.post(&self.config.api_url).json(&request_body);

        // 如果有 API 密钥，添加到请求头
        if let Some(api_key) = &self.config.api_key {
            request = request.bearer_auth(api_key);
        }

        let response = request
            .send()
            .await
            .context("发送 API 请求失败")?;
        if !response.status().is_success() {
            let status = response.status();
            let error_text = response.text().await.unwrap_or_default();
            anyhow::bail!("API 请求失败：{} - {}", status, error_text);
        }
        let chat_response: ChatResponse = response
            .json()
            .await
            .context("解析 API 响应失败")?;
        chat_response
            .choices
            .first()
            .map(|choice| choice.message.content.clone())
            .context("API 响应中没有内容")
    }

    /// 将自然语言转换为 Shell 命令
    pub async fn natural_language_to_command(&self, query: &str) -> Result<String> {
        let system_prompt = r#"你是一个专业的 Linux Shell 命令助手。
你的任务是将用户的自然语言描述转换为准确的 Shell 命令。
规则：
1. 只返回命令本身，不要有任何解释或额外文字
2. 如果需要多个命令，用 && 连接
3. 确保命令安全且符合最佳实践
4. 优先使用常见的 Linux 命令
5. 不要使用危险的命令（如 rm -rf / 等）
示例：
用户：列出当前目录的所有文件
助手：ls -la
用户：查看系统内存使用情况
助手：free -h "#;
        let messages = vec![
            Message {
                role: "system".to_string(),
                content: system_prompt.to_string(),
            },
            Message {
                role: "user".to_string(),
                content: query.to_string(),
            },
        ];
        self.chat(messages).await
    }

    /// 解释 Shell 命令
    pub async fn explain_command(&self, command: &str) -> Result<String> {
        let system_prompt = "你是一个 Shell 命令解释专家。请用简洁的中文解释给定的命令，包括每个参数的作用。";
        let messages = vec![
            Message {
                role: "system".to_string(),
                content: system_prompt.to_string(),
            },
            Message {
                role: "user".to_string(),
                content: format!("请解释这个命令：{}", command),
            },
        ];
        self.chat(messages).await
    }
}

use anyhow::{Context, Result};
use std::process::{Command, Output};

/// Shell 命令执行器
pub struct ShellExecutor;

impl ShellExecutor {
    /// 创建新的执行器
    pub fn new() -> Self {
        ShellExecutor
    }

    /// 执行 Shell 命令
    pub fn execute(&self, command: &str) -> Result<CommandResult> {
        // 检查危险命令
        if self.is_dangerous_command(command) {
            anyhow::bail!("检测到危险命令，拒绝执行：{}", command);
        }
        let output = if cfg!(target_os = "windows") {
            Command::new("cmd")
                .args(["/C", command])
                .output()
                .context("执行命令失败")?
        } else {
            Command::new("sh")
                .arg("-c")
                .arg(command)
                .output()
                .context("执行命令失败")?
        };
        Ok(CommandResult::from_output(output))
    }

    /// 检查是否为危险命令
    fn is_dangerous_command(&self, command: &str) -> bool {
        let dangerous_patterns = vec![
            "rm -rf /",
            "rm -rf /*",
            "mkfs",
            "dd if=/dev/zero",
            "> /dev/sda",
            ":(){ :|:& };:",
            "chmod -R 777 /",
        ];
        dangerous_patterns.iter().any(|pattern| command.contains(pattern))
    }
}

/// 命令执行结果
#[derive(Debug)]
pub struct CommandResult {
    pub success: bool,
    pub stdout: String,
    pub stderr: String,
    #[allow(dead_code)] // 显式允许未使用的字段
    pub exit_code: i32,
}

impl CommandResult {
    fn from_output(output: Output) -> Self {
        CommandResult {
            success: output.status.success(),
            stdout: String::from_utf8_lossy(&output.stdout).to_string(),
            stderr: String::from_utf8_lossy(&output.stderr).to_string(),
            exit_code: output.status.code().unwrap_or(-1),
        }
    }
}

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::env;

/// AI API 配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    /// API 基础 URL
    pub api_url: String,
    /// 模型名称
    pub model: String,
    /// API 密钥（可选）
    pub api_key: Option<String>,
    /// 最大 token 数
    pub max_tokens: u32,
    /// 温度参数
    pub temperature: f32,
    /// 请求超时时间（秒）
    pub timeout_seconds: u64,
}

impl Config {
    /// 从环境变量加载配置
    pub fn from_env() -> Result<Self> {
        // 尝试加载 .env 文件
        dotenv::dotenv().ok();
        let api_url = env::var("AI_API_URL")
            .unwrap_or_else(|_| "https://api.example.com/v1/chat/completions".to_string());
        let model = env::var("AI_MODEL")
            .unwrap_or_else(|_| "/zhipuai/GLM-4.7".to_string());
        let api_key = env::var("AI_API_KEY").ok();
        let max_tokens = env::var("MAX_TOKENS")
            .unwrap_or_else(|_| "1000".to_string())
            .parse()
            .context("MAX_TOKENS 必须是有效的数字")?;
        let temperature = env::var("TEMPERATURE")
            .unwrap_or_else(|_| "0.7".to_string())
            .parse()
            .context("TEMPERATURE 必须是有效的浮点数")?;
        let timeout_seconds = env::var("TIMEOUT_SECONDS")
            .unwrap_or_else(|_| "30".to_string())
            .parse()
            .context("TIMEOUT_SECONDS 必须是有效的数字")?;
        Ok(Config {
            api_url,
            model,
            api_key,
            max_tokens,
            temperature,
            timeout_seconds,
        })
    }

    /// 创建默认配置
    pub fn default() -> Self {
        Config {
            api_url: "https://api.example.com/v1/chat/completions".to_string(),
            model: "/zhipuai/GLM-4.7".to_string(),
            api_key: None,
            max_tokens: 1000,
            temperature: 0.7,
            timeout_seconds: 30,
        }
    }
}

mod ai_client;
mod config;
mod shell_executor;
mod utils;

use ai_client::AIClient;
use anyhow::Result;
use clap::Parser;
use config::Config;
use rustyline::error::ReadlineError;
use rustyline::DefaultEditor;
use shell_executor::ShellExecutor;
use std::collections::VecDeque;

/// 智能 Shell 助手命令行参数
#[derive(Parser, Debug)]
#[command(name = "rust-shell-assistant")]
#[command(about = "智能 Shell 助手 - 使用 AI 将自然语言转换为 Shell 命令", long_about = None)]
struct Args {
    /// 直接查询模式（不进入交互式界面）
    #[arg(short, long)]
    query: Option<String>,
    /// 只生成命令，不执行
    #[arg(short, long)]
    dry_run: bool,
    /// 显示详细日志
    #[arg(short, long)]
    verbose: bool,
}

/// 命令历史记录
struct CommandHistory {
    history: VecDeque<HistoryEntry>,
    max_size: usize,
}

#[derive(Clone)]
struct HistoryEntry {
    query: String,
    command: String,
    executed: bool,
}

impl CommandHistory {
    fn new(max_size: usize) -> Self {
        CommandHistory {
            history: VecDeque::new(),
            max_size,
        }
    }

    fn add(&mut self, query: String, command: String, executed: bool) {
        if self.history.len() >= self.max_size {
            self.history.pop_front();
        }
        self.history.push_back(HistoryEntry { query, command, executed });
    }

    fn print(&self) {
        if self.history.is_empty() {
            utils::print_info("暂无历史记录");
            return;
        }
        println!("\n{}", colored::Colorize::bright_blue("=== 命令历史 ==="));
        for (i, entry) in self.history.iter().enumerate() {
            let status = if entry.executed { "✓" } else { "✗" };
            println!(
                "{}. [{}] {} -> {}",
                i + 1,
                status,
                colored::Colorize::cyan(&entry.query),
                colored::Colorize::white(&entry.command)
            );
        }
        println!();
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let args = Args::parse();

    // 初始化日志
    if args.verbose {
        env_logger::Builder::from_default_env()
            .filter_level(log::LevelFilter::Debug)
            .init();
    }

    // 加载配置
    let config = Config::from_env().unwrap_or_else(|_| {
        utils::print_info("使用默认配置");
        Config::default()
    });

    // 创建 AI 客户端和 Shell 执行器
    let ai_client = AIClient::new(config)?;
    let shell_executor = ShellExecutor::new();

    // 如果是直接查询模式
    if let Some(query) = args.query {
        return handle_single_query(&ai_client, &shell_executor, &query, args.dry_run).await;
    }

    // 进入交互式模式
    run_interactive_mode(ai_client, shell_executor).await
}

/// 处理单次查询
async fn handle_single_query(
    ai_client: &AIClient,
    shell_executor: &ShellExecutor,
    query: &str,
    dry_run: bool,
) -> Result<()> {
    utils::print_info(&format!("查询：{}", query));
    let command = ai_client.natural_language_to_command(query).await?;
    let command = command.trim();
    utils::print_command_suggestion(command);
    if dry_run {
        utils::print_info("干运行模式，不执行命令");
        return Ok(());
    }
    if utils::get_user_confirmation("执行此命令？(y/n):") {
        let result = shell_executor.execute(command)?;
        utils::print_execution_result(result.success, &result.stdout, &result.stderr);
    } else {
        utils::print_info("已取消执行");
    }
    Ok(())
}

/// 运行交互式模式
async fn run_interactive_mode(ai_client: AIClient, shell_executor: ShellExecutor) -> Result<()> {
    utils::print_welcome();
    let mut rl = DefaultEditor::new()?;
    let mut history = CommandHistory::new(50);
    loop {
        let readline = rl.readline(">> ");
        match readline {
            Ok(line) => {
                let line = line.trim();
                if line.is_empty() {
                    continue;
                }
                // 添加到 readline 历史
                let _ = rl.add_history_entry(line);

                // 处理特殊命令
                if matches!(line, "exit" | "quit") {
                    println!("{}", colored::Colorize::bright_green("再见！"));
                    break;
                }
                if line == "help" {
                    utils::print_help();
                    continue;
                }
                if line == "history" {
                    history.print();
                    continue;
                }
                if line == "clear" {
                    print!("\x1B[2J\x1B[1;1H");
                    continue;
                }

                // 处理 explain 命令
                if line.starts_with("explain ") {
                    let command = line.strip_prefix("explain ").unwrap();
                    if let Err(e) = handle_explain(&ai_client, command).await {
                        utils::print_error(&format!("解释失败：{}", e));
                    }
                    continue;
                }

                // 处理普通查询
                if let Err(e) = handle_query(&ai_client, &shell_executor, line, &mut history).await {
                    utils::print_error(&format!("处理失败：{}", e));
                }
            }
            Err(ReadlineError::Interrupted) => {
                utils::print_info("使用 'exit' 或 'quit' 退出");
                continue;
            }
            Err(ReadlineError::Eof) => {
                println!("{}", colored::Colorize::bright_green("再见！"));
                break;
            }
            Err(err) => {
                utils::print_error(&format!("读取输入错误：{}", err));
                break;
            }
        }
    }
    Ok(())
}

/// 处理查询
async fn handle_query(
    ai_client: &AIClient,
    shell_executor: &ShellExecutor,
    query: &str,
    history: &mut CommandHistory,
) -> Result<()> {
    // 调用 AI 生成命令
    let command = ai_client.natural_language_to_command(query).await?;
    let command = command.trim();
    utils::print_command_suggestion(command);

    // 询问用户是否执行
    if utils::get_user_confirmation("执行此命令？(y/n):") {
        match shell_executor.execute(command) {
            Ok(result) => {
                utils::print_execution_result(result.success, &result.stdout, &result.stderr);
                history.add(query.to_string(), command.to_string(), true);
            }
            Err(e) => {
                utils::print_error(&format!("执行失败：{}", e));
                history.add(query.to_string(), command.to_string(), false);
            }
        }
    } else {
        utils::print_info("已取消执行");
        history.add(query.to_string(), command.to_string(), false);
    }
    Ok(())
}

/// 处理命令解释
async fn handle_explain(ai_client: &AIClient, command: &str) -> Result<()> {
    utils::print_info(&format!("正在解释命令：{}", command));
    let explanation = ai_client.explain_command(command).await?;
    println!("\n{}", colored::Colorize::bright_cyan("📖 命令解释:"));
    println!("{}\n", explanation);
    Ok(())
}

# AI API 配置
AI_API_URL=https://api.example.com/v1/chat/completions
AI_MODEL=/zhipuai/GLM-4.7
AI_API_KEY=your_api_key_here

# 可选配置
MAX_TOKENS=1000
TEMPERATURE=0.7
TIMEOUT_SECONDS=30

sudo apt-get install -y pkg-config libssl-dev build-essential

cargo install --path .

Rust + LLM 开发实战：构建智能命令行运维助手

Rust + LLM 开发实战：构建智能命令行运维助手

第一章：Linux 环境下的 Rust 开发生态构建

1.1 构建工具链与系统依赖安装

1.2 Rust 工具链（Toolchain）的部署

1.3 环境变量配置与验证

第二章：大模型服务接入与资源配置

2.1 获取 API 凭证

2.2 模型选型与端点配置

第三章：Rust 项目架构设计与依赖管理

3.1 依赖库（Crates）深度解析

第四章：核心模块实现原理

4.1 AI 客户端模块 (ai_client.rs)

4.2 Shell 执行器模块 (shell_executor.rs)

4.3 配置管理模块 (config.rs)

4.4 主程序与 REPL 循环 (main.rs)

4.5 环境变量配置

第五章：编译链路排查与系统库链接问题

5.1 OpenSSL 链接故障分析

5.2 类型系统约束与 Trait 实现排查

第六章：工具部署与实战演示

6.1 本地安装与路径配置

6.2 交互模式实测

6.3 命令行参数模式实测

6.4 后端资源监控

结语

更多推荐文章

相关免费在线工具

Rust + LLM 开发实战：构建智能命令行运维助手

Rust + LLM 开发实战：构建智能命令行运维助手

第一章：Linux 环境下的 Rust 开发生态构建

1.1 构建工具链与系统依赖安装

1.2 Rust 工具链（Toolchain）的部署

1.3 环境变量配置与验证

第二章：大模型服务接入与资源配置

2.1 获取 API 凭证

2.2 模型选型与端点配置

第三章：Rust 项目架构设计与依赖管理

3.1 依赖库（Crates）深度解析

第四章：核心模块实现原理

4.1 AI 客户端模块 (ai_client.rs)

4.2 Shell 执行器模块 (shell_executor.rs)

4.3 配置管理模块 (config.rs)

4.4 主程序与 REPL 循环 (main.rs)

4.5 环境变量配置

第五章：编译链路排查与系统库链接问题

5.1 OpenSSL 链接故障分析

5.2 类型系统约束与 Trait 实现排查

第六章：工具部署与实战演示

6.1 本地安装与路径配置

6.2 交互模式实测

6.3 命令行参数模式实测

6.4 后端资源监控

结语

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具