leach/rustGPT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

config file, bugfixes

Browse Source
This commit is contained in:
leach
2025-08-15 15:41:32 -04:00
parent b171a6b2b2
commit 7d237f692c
7 changed files with 364 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/cli.rs
View File

@@ -1,5 +1,6 @@
use anyhow::Result;
use crate::config::Config;
use crate::core::{
create_client, get_provider_for_model, provider::get_all_models, provider::get_supported_models,
provider::is_model_supported, ChatClient, Session,
@@ -12,22 +13,24 @@ pub struct ChatCLI {
current_model: Option<String>,
display: Display,
input: InputHandler,
config: Config,
}
impl ChatCLI {
pub fn new(session: Session) -> Result<Self> {
pub fn new(session: Session, config: Config) -> Result<Self> {
Ok(Self {
session,
client: None,
current_model: None,
display: Display::new(),
input: InputHandler::new()?,
config,
})
}
fn get_client(&mut self) -> Result<&ChatClient> {
if self.client.is_none() || self.current_model.as_ref() != Some(&self.session.model) {
let client = create_client(&self.session.model)?;
let client = create_client(&self.session.model, &self.config)?;
self.current_model = Some(self.session.model.clone());
self.client = Some(client);
}

235
src/config.rs Normal file
View File

@@ -0,0 +1,235 @@
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::env;
use std::fs;
use std::path::PathBuf;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
pub api: ApiConfig,
pub defaults: DefaultsConfig,
pub limits: LimitsConfig,
pub session: SessionConfig,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiConfig {
pub openai_base_url: String,
pub anthropic_base_url: String,
pub anthropic_version: String,
pub request_timeout_seconds: u64,
pub max_retries: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefaultsConfig {
pub model: String,
pub reasoning_effort: String,
pub enable_web_search: bool,
pub enable_reasoning_summary: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LimitsConfig {
pub max_tokens_anthropic: u32,
pub max_conversation_history: usize,
pub max_sessions_to_list: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionConfig {
pub sessions_dir_name: String,
pub file_extension: String,
}
impl Default for Config {
fn default() -> Self {
Self {
api: ApiConfig::default(),
defaults: DefaultsConfig::default(),
limits: LimitsConfig::default(),
session: SessionConfig::default(),
}
}
}
impl Default for ApiConfig {
fn default() -> Self {
Self {
openai_base_url: "https://api.openai.com/v1".to_string(),
anthropic_base_url: "https://api.anthropic.com/v1".to_string(),
anthropic_version: "2023-06-01".to_string(),
request_timeout_seconds: 120,
max_retries: 3,
}
}
}
impl Default for DefaultsConfig {
fn default() -> Self {
Self {
model: "gpt-5".to_string(),
reasoning_effort: "medium".to_string(),
enable_web_search: true,
enable_reasoning_summary: false,
}
}
}
impl Default for LimitsConfig {
fn default() -> Self {
Self {
max_tokens_anthropic: 4096,
max_conversation_history: 100,
max_sessions_to_list: 50,
}
}
}
impl Default for SessionConfig {
fn default() -> Self {
Self {
sessions_dir_name: ".chat_cli_sessions".to_string(),
file_extension: "json".to_string(),
}
}
}
#[derive(Debug)]
pub struct EnvVariables {
pub openai_api_key: Option<String>,
pub anthropic_api_key: Option<String>,
pub openai_base_url: Option<String>,
pub default_model: Option<String>,
}
impl Config {
pub fn load() -> Result<Self> {
let config_path = Self::config_file_path()?;
if config_path.exists() {
let config_content = fs::read_to_string(&config_path)
.with_context(|| format!("Failed to read config file: {:?}", config_path))?;
let mut config: Config = toml::from_str(&config_content)
.with_context(|| format!("Failed to parse config file: {:?}", config_path))?;
// Override with environment variables if present
config.apply_env_overrides()?;
Ok(config)
} else {
let mut config = Config::default();
config.apply_env_overrides()?;
Ok(config)
}
}
pub fn save(&self) -> Result<()> {
let config_path = Self::config_file_path()?;
// Create config directory if it doesn't exist
if let Some(parent) = config_path.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("Failed to create config directory: {:?}", parent))?;
}
let config_content = toml::to_string_pretty(self)
.context("Failed to serialize config")?;
fs::write(&config_path, config_content)
.with_context(|| format!("Failed to write config file: {:?}", config_path))?;
Ok(())
}
pub fn config_file_path() -> Result<PathBuf> {
let home = dirs::home_dir().context("Could not find home directory")?;
Ok(home.join(".config").join("gpt-cli-rust").join("config.toml"))
}
fn apply_env_overrides(&mut self) -> Result<()> {
// Override API URLs
if let Ok(openai_base_url) = env::var("OPENAI_BASE_URL") {
self.api.openai_base_url = openai_base_url;
}
// Override defaults
if let Ok(default_model) = env::var("DEFAULT_MODEL") {
self.defaults.model = default_model;
}
Ok(())
}
pub fn validate_env_variables() -> Result<EnvVariables> {
let openai_api_key = env::var("OPENAI_API_KEY").ok();
let anthropic_api_key = env::var("ANTHROPIC_API_KEY").ok();
let openai_base_url = env::var("OPENAI_BASE_URL").ok();
let default_model = env::var("DEFAULT_MODEL").ok();
// At least one API key must be present
if openai_api_key.is_none() && anthropic_api_key.is_none() {
return Err(anyhow::anyhow!(
"At least one API key must be set: OPENAI_API_KEY or ANTHROPIC_API_KEY"
));
}
Ok(EnvVariables {
openai_api_key,
anthropic_api_key,
openai_base_url,
default_model,
})
}
pub fn validate_model_availability(&self, env: &EnvVariables, model: &str) -> Result<()> {
use crate::core::provider::{get_provider_for_model, Provider};
let provider = get_provider_for_model(model);
match provider {
Provider::OpenAI => {
if env.openai_api_key.is_none() {
return Err(anyhow::anyhow!(
"OPENAI_API_KEY is required for OpenAI model: {}", model
));
}
}
Provider::Anthropic => {
if env.anthropic_api_key.is_none() {
return Err(anyhow::anyhow!(
"ANTHROPIC_API_KEY is required for Anthropic model: {}", model
));
}
}
}
Ok(())
}
pub fn create_example_config() -> Result<()> {
let config_path = Self::config_file_path()?;
if config_path.exists() {
return Ok(()); // Don't overwrite existing config
}
let example_config = Config::default();
example_config.save()?;
println!("Created example config file at: {:?}", config_path);
println!("You can customize it to change default settings.");
Ok(())
}
pub fn print_config_info(&self) {
println!("📋 Configuration:");
println!(" Default model: {}", self.defaults.model);
println!(" Web search: {}", if self.defaults.enable_web_search { "enabled" } else { "disabled" });
println!(" Reasoning summaries: {}", if self.defaults.enable_reasoning_summary { "enabled" } else { "disabled" });
println!(" Request timeout: {}s", self.api.request_timeout_seconds);
println!(" Max conversation history: {}", self.limits.max_conversation_history);
}
}

46
src/core/client.rs
View File

@@ -3,7 +3,9 @@ use reqwest::Client;
use serde::Deserialize;
use serde_json::{json, Value};
use std::env;
use std::time::Duration;
use crate::config::Config;
use super::{provider::Provider, session::Message};
#[derive(Debug)]
@@ -128,7 +130,8 @@ struct SearchAction {
#[allow(dead_code)]
#[serde(rename = "type")]
action_type: String,
query: String,
#[serde(default)]
query: Option<String>,
}
#[derive(Deserialize)]
@@ -164,19 +167,19 @@ struct AnthropicContent {
}
impl OpenAIClient {
pub fn new() -> Result<Self> {
pub fn new(config: &Config) -> Result<Self> {
let api_key = env::var("OPENAI_API_KEY")
.context("OPENAI_API_KEY environment variable is required")?;
let base_url = env::var("OPENAI_BASE_URL")
.unwrap_or_else(|_| "https://api.openai.com/v1".to_string());
let client = Client::new();
let client = Client::builder()
.timeout(Duration::from_secs(config.api.request_timeout_seconds))
.build()
.context("Failed to create HTTP client")?;
Ok(Self {
client,
api_key,
base_url,
base_url: config.api.openai_base_url.clone(),
})
}
@@ -368,7 +371,11 @@ impl OpenAIClient {
if item.status.as_deref() == Some("completed") {
search_count += 1;
if let Some(action) = &item.action {
final_content.push_str(&format!("🔍 Search {}: \"{}\"\n", search_count, action.query));
if let Some(query) = &action.query {
final_content.push_str(&format!("🔍 Search {}: \"{}\"\n", search_count, query));
} else {
final_content.push_str(&format!("🔍 Search {}: [no query specified]\n", search_count));
}
}
}
}
@@ -439,17 +446,19 @@ impl OpenAIClient {
}
impl AnthropicClient {
pub fn new() -> Result<Self> {
pub fn new(config: &Config) -> Result<Self> {
let api_key = env::var("ANTHROPIC_API_KEY")
.context("ANTHROPIC_API_KEY environment variable is required")?;
let base_url = "https://api.anthropic.com/v1".to_string();
let client = Client::new();
let client = Client::builder()
.timeout(Duration::from_secs(config.api.request_timeout_seconds))
.build()
.context("Failed to create HTTP client")?;
Ok(Self {
client,
api_key,
base_url,
base_url: config.api.anthropic_base_url.clone(),
})
}
@@ -489,9 +498,10 @@ impl AnthropicClient {
let (system_prompt, user_messages) = Self::convert_messages(messages);
let config = crate::config::Config::load().unwrap_or_default();
let mut payload = json!({
"model": model,
"max_tokens": 4096,
"max_tokens": config.limits.max_tokens_anthropic,
"messages": user_messages
});
@@ -504,7 +514,7 @@ impl AnthropicClient {
.post(&url)
.header("x-api-key", &self.api_key)
.header("Content-Type", "application/json")
.header("anthropic-version", "2023-06-01")
.header("anthropic-version", &config.api.anthropic_version)
.json(&payload)
.send()
.await
@@ -544,16 +554,16 @@ impl AnthropicClient {
}
}
pub fn create_client(model: &str) -> Result<ChatClient> {
pub fn create_client(model: &str, config: &Config) -> Result<ChatClient> {
let provider = super::provider::get_provider_for_model(model);
match provider {
Provider::OpenAI => {
let client = OpenAIClient::new()?;
let client = OpenAIClient::new(config)?;
Ok(ChatClient::OpenAI(client))
}
Provider::Anthropic => {
let client = AnthropicClient::new()?;
let client = AnthropicClient::new(config)?;
Ok(ChatClient::Anthropic(client))
}
}

8
src/core/session.rs
View File

@@ -4,6 +4,8 @@ use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;
use crate::config::Config;
const SYSTEM_PROMPT: &str = "You are an AI assistant running in a terminal (CLI) environment. \
Optimise all answers for 80‑column readability, prefer plain text, \
ASCII art or concise bullet lists over heavy markup, and wrap code \
@@ -62,8 +64,9 @@ impl Session {
}
pub fn sessions_dir() -> Result<PathBuf> {
let config = Config::load().unwrap_or_default();
let home = dirs::home_dir().context("Could not find home directory")?;
let sessions_dir = home.join(".chat_cli_sessions");
let sessions_dir = home.join(&config.session.sessions_dir_name);
if !sessions_dir.exists() {
fs::create_dir_all(&sessions_dir)
@@ -74,7 +77,8 @@ impl Session {
}
pub fn session_path(name: &str) -> Result<PathBuf> {
Ok(Self::sessions_dir()?.join(format!("{}.json", name)))
let config = Config::load().unwrap_or_default();
Ok(Self::sessions_dir()?.join(format!("{}.{}", name, config.session.file_extension)))
}
pub fn save(&self) -> Result<()> {

36
src/main.rs
View File

@@ -1,12 +1,13 @@
mod cli;
mod config;
mod core;
mod utils;
use anyhow::{Context, Result};
use clap::Parser;
use std::env;
use crate::cli::ChatCLI;
use crate::config::Config;
use crate::core::{provider::is_model_supported, Session};
use crate::utils::Display;
@@ -20,6 +21,9 @@ struct Args {
#[arg(short, long, help = "Model name to use (overrides saved value)")]
model: Option<String>,
#[arg(long, help = "Create example configuration file and exit")]
create_config: bool,
}
#[tokio::main]
@@ -27,6 +31,18 @@ async fn main() -> Result<()> {
let args = Args::parse();
let display = Display::new();
// Handle config creation
if args.create_config {
Config::create_example_config()?;
return Ok(());
}
// Load configuration
let config = Config::load().context("Failed to load configuration")?;
// Validate environment variables
let env_vars = Config::validate_env_variables().context("Environment validation failed")?;
// Load or create session
let session = match Session::load(&args.session) {
Ok(mut session) => {
@@ -45,23 +61,29 @@ async fn main() -> Result<()> {
Err(_) => {
let default_model = args
.model
.or_else(|| env::var("DEFAULT_MODEL").ok())
.unwrap_or_else(|| "gpt-5".to_string());
.or_else(|| env_vars.default_model.clone())
.unwrap_or_else(|| config.defaults.model.clone());
if !is_model_supported(&default_model) {
display.print_warning(&format!(
"Model '{}' is not supported. Falling back to 'gpt-5'",
default_model
"Model '{}' is not supported. Falling back to '{}'",
default_model, config.defaults.model
));
Session::new(args.session, "gpt-5".to_string())
Session::new(args.session, config.defaults.model.clone())
} else {
Session::new(args.session, default_model)
}
}
};
// Validate model availability
config.validate_model_availability(&env_vars, &session.model)?;
// Print configuration info
config.print_config_info();
// Run the CLI
let mut cli = ChatCLI::new(session).context("Failed to initialize CLI")?;
let mut cli = ChatCLI::new(session, config).context("Failed to initialize CLI")?;
cli.run().await.context("CLI error")?;
Ok(())