feat: add config command

Author: Crauzer

…tes/ritobin-tools/src/commands/config.rs …ritobin-tools/src/commands/config_cmd.rscrates/ritobin-tools/src/commands/config.rs renamed to crates/ritobin-tools/src/commands/config_cmd.rs crates/ritobin-tools/src/commands/config.rs renamed to crates/ritobin-tools/src/commands/config_cmd.rs

@@ -43,7 +43,7 @@ fn print_path_config(
 }
 
 pub fn show_config() -> Result<()> {
-    let cfg = config::load_config();
+    let (cfg, _) = config::load_or_create_config()?;
     let config_path = config::default_config_path();
 
     println!();
@@ -78,14 +78,50 @@ pub fn reset_config() -> Result<()> {
     println!();
     println!("  {} {}", "Config file:".bright_white().bold(), config_path);
     println!();
+
+    Ok(())
+}
+
+pub fn set_config_value(key: &str, value: &str) -> Result<()> {
+    let mut table = config::load_config_as_table()?;
+    let toml_value = parse_toml_value(value);
+
+    table.insert(key.to_string(), toml_value);
+
+    let _: AppConfig = table
+        .clone()
+        .try_into()
+        .map_err(|e| miette::miette!("Invalid configuration: {}", e))?;
+
+    config::save_config_table(&table)
+        .map_err(|e| miette::miette!("Failed to save config: {}", e))?;
+
     println!(
-        "  {}",
-        "Run 'league-mod config auto-detect' to find your League installation".bright_cyan()
+        "{}",
+        format!("✓ Set '{}' = '{}'", key, value)
+            .bright_green()
+            .bold()
     );
 
     Ok(())
 }
 
+/// Parse a string value into an appropriate TOML value type
+fn parse_toml_value(value: &str) -> toml::Value {
+    if let Ok(b) = value.parse::<bool>() {
+        return toml::Value::Boolean(b);
+    }
+    if let Ok(i) = value.parse::<i64>() {
+        return toml::Value::Integer(i);
+    }
+    if let Ok(f) = value.parse::<f64>()
+        && value.contains('.')
+    {
+        return toml::Value::Float(f);
+    }
+    toml::Value::String(value.to_string())
+}
+
 /// Ensures config.toml exists.
 pub fn ensure_config_exists() -> Result<()> {
     let (_cfg, _path) = config::load_or_create_config()

crates/ritobin-tools/src/commands/mod.rs

@@ -1,5 +1,5 @@
-mod config;
+pub mod config_cmd;
 pub mod convert;
 pub mod diff;
 
-pub use config::*;
+pub use config_cmd::ensure_config_exists;

crates/ritobin-tools/src/main.rs

@@ -1,25 +1,34 @@
-use camino::Utf8Path;
 use clap::builder::{Styles, styling::AnsiColor};
 use clap::{ColorChoice, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum};
-use league_toolkit::file::LeagueFileKind;
 use miette::Result;
-use serde::Deserialize;
-use serde::de::IntoDeserializer;
-use serde::de::value::Error;
 use tracing::Level;
 use tracing_indicatif::IndicatifLayer;
 use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{filter, fmt};
-use utils::config::{default_config_path, load_or_create_config};
 
-use crate::commands::{convert, diff};
+use crate::commands::{config_cmd, convert, diff};
 
 mod commands;
 mod utils;
 
+#[derive(Subcommand, Debug)]
+pub enum ConfigAction {
+    /// Show current configuration
+    Show,
+    /// Set a configuration value
+    Set {
+        /// Configuration key to set (e.g., 'hashtable_dir')
+        key: String,
+        /// Value to set for the configuration key
+        value: String,
+    },
+    /// Reset configuration to defaults
+    Reset,
+}
+
 #[derive(Copy, Clone, Debug, ValueEnum)]
 pub enum VerbosityLevel {
     /// Show errors and above
@@ -105,6 +114,12 @@ pub enum Commands {
         /// Disable colored output
         no_color: bool,
     },
+
+    /// Manage application configuration
+    Config {
+        #[command(subcommand)]
+        action: ConfigAction,
+    },
 }
 
 fn parse_args() -> Args {
@@ -142,6 +157,11 @@ fn main() -> Result<()> {
             context,
             no_color,
         } => diff::diff(file1, file2, context, no_color),
+        Commands::Config { action } => match action {
+            ConfigAction::Show => config_cmd::show_config(),
+            ConfigAction::Set { key, value } => config_cmd::set_config_value(&key, &value),
+            ConfigAction::Reset => config_cmd::reset_config(),
+        },
     }
 }
 
@@ -210,19 +230,6 @@ fn initialize_tracing(verbosity: VerbosityLevel, show_progress: bool) -> Result<
     Ok(())
 }
 
-fn parse_filter_type(s: &str) -> Result<LeagueFileKind, String> {
-    let deserializer: serde::de::value::StrDeserializer<Error> = s.into_deserializer();
-    if let Ok(kind) = LeagueFileKind::deserialize(deserializer) {
-        return Ok(kind);
-    }
-
-    // Fallback to extension
-    match LeagueFileKind::from_extension(s) {
-        LeagueFileKind::Unknown => Err(format!("Unknown file kind: {}", s)),
-        other => Ok(other),
-    }
-}
-
 fn cli_styles() -> Styles {
     Styles::styled()
         .header(AnsiColor::Yellow.on_default().bold())

crates/ritobin-tools/src/utils/config.rs

@@ -9,7 +9,6 @@ use std::env;
 use std::fs;
 use std::io;
 use std::path::Path;
-use std::time::{SystemTime, UNIX_EPOCH};
 
 /// Application-wide configuration stored in config.toml.
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -43,21 +42,6 @@ pub fn default_config_path() -> Option<Utf8PathBuf> {
     config_path("config.toml")
 }
 
-/// Loads the application configuration from config.toml.
-/// Returns default configuration if file doesn't exist or cannot be parsed.
-pub fn load_config() -> AppConfig {
-    if let Some(path) = default_config_path() {
-        if Path::new(path.as_str()).exists() {
-            if let Ok(content) = fs::read_to_string(path.as_str()) {
-                if let Ok(cfg) = toml::from_str(&content) {
-                    return cfg;
-                }
-            }
-        }
-    }
-    AppConfig::default()
-}
-
 /// Normalizes a path to use forward slashes
 fn normalize_path(path: &Utf8PathBuf) -> Utf8PathBuf {
     Utf8PathBuf::from(path.as_str().replace('\\', "/"))
@@ -82,16 +66,24 @@ pub fn save_config(cfg: &AppConfig) -> io::Result<()> {
 }
 
 /// Loads existing configuration or creates a new one with defaults.
+/// Missing fields in the config file are filled with default values.
 pub fn load_or_create_config() -> Result<(AppConfig, Utf8PathBuf)> {
     let path = default_config_path().ok_or(miette::miette!("Could not determine config path"))?;
 
     if Path::new(path.as_str()).exists() {
         let content = fs::read_to_string(path.as_str())
             .into_diagnostic()
             .wrap_err("Failed to read config file")?;
-        let cfg = toml::from_str(&content)
+        let mut cfg: AppConfig = toml::from_str(&content)
             .into_diagnostic()
             .wrap_err("Failed to parse config file")?;
+
+        // Fill in defaults for missing optional fields
+        let defaults = AppConfig::default();
+        if cfg.hashtable_dir.is_none() {
+            cfg.hashtable_dir = defaults.hashtable_dir;
+        }
+
         Ok((cfg, path))
     } else {
         let cfg = AppConfig::default();
@@ -102,38 +94,61 @@ pub fn load_or_create_config() -> Result<(AppConfig, Utf8PathBuf)> {
     }
 }
 
-/// Reads JSON from a path into type T. Returns Ok(None) if file cannot be read or parsed.
-pub fn read_json<T: serde::de::DeserializeOwned>(path: &Path) -> io::Result<Option<T>> {
-    match fs::read(path) {
-        Ok(bytes) => match serde_json::from_slice::<T>(&bytes) {
-            Ok(v) => Ok(Some(v)),
-            Err(_) => Ok(None),
-        },
-        Err(_) => Ok(None),
-    }
-}
+/// Loads configuration as a raw TOML table for flexible editing.
+pub fn load_config_as_table() -> Result<toml::Table> {
+    let path = default_config_path().ok_or(miette::miette!("Could not determine config path"))?;
+
+    if Path::new(path.as_str()).exists() {
+        let content = fs::read_to_string(path.as_str())
+            .into_diagnostic()
+            .wrap_err("Failed to read config file")?;
 
-/// Writes pretty-formatted JSON to the given path.
-pub fn write_json_pretty<T: serde::Serialize>(path: &Path, value: &T) -> io::Result<()> {
-    let data = serde_json::to_vec_pretty(value).unwrap_or_else(|_| b"{}".to_vec());
-    fs::write(path, data)
+        toml::from_str(&content)
+            .into_diagnostic()
+            .wrap_err("Failed to parse config file")
+    } else {
+        let cfg = AppConfig::default();
+        let content = toml::to_string_pretty(&cfg)
+            .into_diagnostic()
+            .wrap_err("Failed to serialize default config")?;
+        toml::from_str(&content)
+            .into_diagnostic()
+            .wrap_err("Failed to parse default config")
+    }
 }
 
-/// Returns current UNIX epoch seconds.
-pub fn now_epoch_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs()
+/// Saves a raw TOML table to the config file.
+pub fn save_config_table(table: &toml::Table) -> io::Result<()> {
+    if let Some(path) = default_config_path() {
+        let content = toml::to_string_pretty(table).map_err(io::Error::other)?;
+        fs::write(path.as_str(), content)
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "Could not determine config path",
+        ))
+    }
 }
 
 /// Returns the default directory where wad hashtables should be looked up.
 /// Uses the user's Documents folder: Documents/LeagueToolkit/bin_hashtables
+/// Falls back to ~/.local/share/LeagueToolkit/bin_hashtables on Linux if Documents isn't available
 pub fn default_hashtable_dir() -> Option<Utf8PathBuf> {
-    let user_dirs = directories_next::UserDirs::new()?;
-    let doc_dir = user_dirs.document_dir()?;
-    let mut path = doc_dir.to_path_buf();
-    path.push("LeagueToolkit");
+    // Try Documents folder first (Windows, macOS, and some Linux setups)
+    if let Some(doc_dir) =
+        directories_next::UserDirs::new().and_then(|u| u.document_dir().map(|p| p.to_path_buf()))
+    {
+        let mut path = doc_dir;
+        path.push("LeagueToolkit");
+        path.push("bin_hashtables");
+        if let Ok(utf8_path) = Utf8PathBuf::from_path_buf(path) {
+            return Some(utf8_path);
+        }
+    }
+
+    // Fallback: use data directory (~/.local/share on Linux, AppData on Windows)
+    let data_dirs = directories_next::ProjectDirs::from("", "", "LeagueToolkit")?;
+    let mut path = data_dirs.data_dir().to_path_buf();
     path.push("bin_hashtables");
     Utf8PathBuf::from_path_buf(path).ok()
 }