use crate::modules::achievements::{home_dir, AchievementProgress, ArcadeStats};
use crate::models::{EnvironmentState, HealthScore, ProjectStack};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
pub const CACHE_TTL: Duration = Duration::from_secs(300);
pub const CACHE_TTL_SECS: u64 = 300;
pub fn default_config() -> LimitlessConfig {
LimitlessConfig {
preferred_stack: None,
auto_approve_safe_fixes: false,
color_enabled: true,
animation_enabled: true,
verbose_mode: false,
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
pub struct LimitlessConfig {
pub preferred_stack: Option<ProjectStack>,
pub auto_approve_safe_fixes: bool,
pub color_enabled: bool,
pub animation_enabled: bool,
pub verbose_mode: bool,
}
impl Default for LimitlessConfig {
fn default() -> Self {
default_config()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PersistenceManager {
pub config_dir: PathBuf,
pub config_file: PathBuf,
pub stats_file: PathBuf,
pub cache_file: PathBuf,
}
impl PersistenceManager {
pub fn at_dir(dir: impl AsRef<Path>) -> Self {
let dir = dir.as_ref().to_path_buf();
Self {
config_dir: dir.clone(),
config_file: dir.join("config.json"),
stats_file: dir.join("stats.json"),
cache_file: dir.join("cache.json"),
}
}
pub fn from_home(home: impl AsRef<Path>) -> Self {
Self::at_dir(home.as_ref().join(".limitless"))
}
pub fn load_config(&self) -> Result<Option<LimitlessConfig>, String> {
if !self.config_file.exists() {
return Ok(None);
}
let raw = fs::read_to_string(&self.config_file)
.map_err(|err| format!("could not read {}: {err}", self.config_file.display()))?;
serde_json::from_str(&raw)
.map(Some)
.map_err(|err| format!("invalid config file {}: {err}", self.config_file.display()))
}
pub fn init_config(&self) -> Result<LimitlessConfig, String> {
fs::create_dir_all(&self.config_dir)
.map_err(|err| format!("could not create {}: {err}", self.config_dir.display()))?;
if !self.config_file.exists() {
self.save_config(&LimitlessConfig::default())?;
}
self.load_config()?.ok_or_else(|| {
format!("{} disappeared during init", self.config_file.display())
})
}
pub fn save_config(&self, config: &LimitlessConfig) -> Result<(), String> {
let json = serde_json::to_string_pretty(config)
.map_err(|err| format!("could not serialize config: {err}"))?;
atomic_write(&self.config_file, json.as_bytes())
}
pub fn load_stats(&self) -> Result<ArcadeStats, String> {
if !self.stats_file.exists() {
return Ok(ArcadeStats::default());
}
let raw = fs::read_to_string(&self.stats_file)
.map_err(|err| format!("could not read {}: {err}", self.stats_file.display()))?;
if let Ok(stats) = serde_json::from_str::<ArcadeStats>(&raw) {
return Ok(stats);
}
if let Ok(legacy) = serde_json::from_str::<AchievementProgress>(&raw) {
return Ok(legacy.stats);
}
Err(format!(
"invalid stats file {}",
self.stats_file.display()
))
}
pub fn save_stats(&self, stats: &ArcadeStats) -> Result<(), String> {
let json = serde_json::to_string_pretty(stats)
.map_err(|err| format!("could not serialize stats: {err}"))?;
atomic_write(&self.stats_file, json.as_bytes())
}
pub fn cache_diagnostics(&self, state: &EnvironmentState) -> Result<(), String> {
let entry = CacheEntry::fresh(state.clone());
let json = serde_json::to_string_pretty(&entry)
.map_err(|err| format!("could not serialize cache: {err}"))?;
atomic_write(&self.cache_file, json.as_bytes())
}
fn cached_entry(&self) -> Result<Option<CacheEntry>, String> {
if !self.cache_file.exists() {
return Ok(None);
}
let raw = fs::read_to_string(&self.cache_file)
.map_err(|err| format!("could not read {}: {err}", self.cache_file.display()))?;
serde_json::from_str(&raw)
.map(Some)
.map_err(|err| format!("invalid cache file {}: {err}", self.cache_file.display()))
}
pub fn get_cached_diagnostics(&self) -> Option<EnvironmentState> {
let entry = self.cached_entry().ok().flatten()?;
if !entry.is_fresh() {
return None;
}
let mut state = entry.state;
state.health_score = HealthScore::from_results(&state.diagnostics);
Some(state)
}
}
impl Default for PersistenceManager {
fn default() -> Self {
match home_dir() {
Some(home) => Self::from_home(home),
None => Self::at_dir(
std::env::current_dir()
.unwrap_or_else(|_| PathBuf::from("."))
.join(".limitless"),
),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CacheEntry {
pub saved_at: u64,
pub state: EnvironmentState,
}
impl CacheEntry {
pub fn fresh(state: EnvironmentState) -> Self {
Self {
saved_at: unix_secs_now(),
state,
}
}
pub fn age_secs(&self) -> u64 {
unix_secs_now().saturating_sub(self.saved_at)
}
pub fn is_fresh(&self) -> bool {
self.age_secs() < CACHE_TTL_SECS
}
}
pub fn unix_secs_now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_secs())
.unwrap_or(0)
}
fn atomic_write(path: &Path, contents: &[u8]) -> Result<(), String> {
let parent = path
.parent()
.filter(|p| !p.as_os_str().is_empty())
.unwrap_or_else(|| Path::new("."));
fs::create_dir_all(parent)
.map_err(|err| format!("could not create {}: {err}", parent.display()))?;
let name = path
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("data.json");
let tmp = parent.join(format!(".{name}.tmp"));
fs::write(&tmp, contents)
.map_err(|err| format!("could not write {}: {err}", tmp.display()))?;
if path.exists() {
fs::remove_file(path)
.map_err(|err| format!("could not replace {}: {err}", path.display()))?;
}
fs::rename(&tmp, path)
.map_err(|err| format!("could not finalize {}: {err}", path.display()))?;
Ok(())
}
pub fn init_config() -> Result<LimitlessConfig, String> {
PersistenceManager::default().init_config()
}
pub fn save_config(config: &LimitlessConfig) -> Result<(), String> {
PersistenceManager::default().save_config(config)
}
pub fn load_stats() -> Result<ArcadeStats, String> {
PersistenceManager::default().load_stats()
}
pub fn save_stats(stats: &ArcadeStats) -> Result<(), String> {
PersistenceManager::default().save_stats(stats)
}
pub fn get_cached_diagnostics() -> Option<EnvironmentState> {
PersistenceManager::default().get_cached_diagnostics()
}
pub fn cache_diagnostics(state: &EnvironmentState) -> Result<(), String> {
PersistenceManager::default().cache_diagnostics(state)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::{CheckStatus, DiagnosticResult, HealthScore, ProjectStack};
use std::fs;
struct TempDir(PathBuf);
impl TempDir {
fn new(tag: &str) -> Self {
let path = std::env::temp_dir().join(format!(
"limitless_config_{}_{}_{}",
tag,
std::process::id(),
unix_secs_now()
));
Self(path)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
fn manager(tag: &str) -> (PersistenceManager, TempDir) {
let dir = TempDir::new(tag);
let manager = PersistenceManager::at_dir(dir.path().join(".limitless"));
(manager, dir)
}
fn sample_state() -> EnvironmentState {
let diagnostics = vec![
DiagnosticResult::new("Runtime Check", CheckStatus::Pass, "ok"),
DiagnosticResult::new("Env Audit", CheckStatus::Warn, "no .env"),
];
EnvironmentState {
detected_stack: ProjectStack::Node {
version: "22.0.0".into(),
package_manager: "npm".into(),
},
runtime_version: Some("v22.0.0".into()),
env_file_exists: false,
env_example_exists: true,
dependencies_healthy: true,
blocked_ports: vec![(3000, 1234)],
diagnostics: diagnostics.clone(),
health_score: HealthScore::from_results(&diagnostics),
}
}
#[test]
fn default_config_json_matches_spec() {
let json = serde_json::to_string_pretty(&LimitlessConfig::default()).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["preferred_stack"], serde_json::Value::Null);
assert_eq!(parsed["auto_approve_safe_fixes"], false);
assert_eq!(parsed["color_enabled"], true);
assert_eq!(parsed["animation_enabled"], true);
assert_eq!(parsed["verbose_mode"], false);
}
#[test]
fn init_config_creates_directory_and_default_file() {
let (manager, dir) = manager("init_default");
let config = manager.init_config().unwrap();
assert_eq!(config, LimitlessConfig::default());
assert!(dir.path().join(".limitless").is_dir());
assert!(manager.config_file.is_file());
let json = fs::read_to_string(&manager.config_file).unwrap();
assert!(json.contains("\"preferred_stack\": null"));
assert!(json.contains("\"color_enabled\": true"));
}
#[test]
fn init_config_preserves_existing_settings() {
let (manager, _dir) = manager("init_keep");
let custom = LimitlessConfig {
preferred_stack: Some(ProjectStack::Python { version: "3.12".into() }),
auto_approve_safe_fixes: true,
color_enabled: false,
animation_enabled: false,
verbose_mode: true,
};
manager.save_config(&custom).unwrap();
assert_eq!(manager.init_config().unwrap(), custom);
}
#[test]
fn initializing_twice_is_idempotent() {
let (manager, _dir) = manager("init_idem");
let first = manager.init_config().unwrap();
let second = manager.init_config().unwrap();
assert_eq!(first, second);
let text = fs::read_to_string(&manager.config_file).unwrap();
assert!(!text.contains("__idem__"));
}
#[test]
fn init_config_errors_on_corrupt_file() {
let (manager, _dir) = manager("init_corrupt");
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(&manager.config_file, "not json {").unwrap();
let err = manager.init_config().unwrap_err();
assert!(err.contains("config.json"), "{err}");
}
#[test]
fn load_config_is_none_when_missing() {
let (manager, _dir) = manager("load_missing");
assert_eq!(manager.load_config().unwrap(), None);
}
#[test]
fn save_config_creates_nested_directory_atomically() {
let dir = TempDir::new("deep");
let manager = PersistenceManager::at_dir(dir.path().join("a").join("b").join(".limitless"));
manager.save_config(&LimitlessConfig::default()).unwrap();
assert!(manager.config_file.is_file());
let leftover: Vec<_> = fs::read_dir(&manager.config_dir)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| e.file_name().to_string_lossy().ends_with(".tmp"))
.collect();
assert!(leftover.is_empty(), "temp file left behind");
}
#[test]
fn preferred_stack_round_trips() {
let (manager, _dir) = manager("stack_rt");
let config = LimitlessConfig {
preferred_stack: Some(ProjectStack::Rust { version: "1.80.0".into() }),
..LimitlessConfig::default()
};
manager.save_config(&config).unwrap();
assert_eq!(manager.load_config().unwrap(), Some(config));
}
#[test]
fn load_stats_returns_defaults_when_missing() {
let (manager, _dir) = manager("stats_missing");
let stats = manager.load_stats().unwrap();
assert_eq!(stats.diagnostics_run, 0);
assert_eq!(stats.best_arcade_score, 0);
}
#[test]
fn save_then_load_stats_round_trips() {
let (manager, _dir) = manager("stats_rt");
let mut stats = ArcadeStats::default();
stats.record_diagnostic_at(1200, 3);
stats.record_fix();
stats.record_process_killed();
stats.record_arcade_game(900);
manager.save_stats(&stats).unwrap();
assert!(manager.stats_file.is_file());
assert_eq!(manager.load_stats().unwrap(), stats);
}
#[test]
fn load_stats_errors_on_corrupt_file() {
let (manager, _dir) = manager("stats_corrupt");
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(&manager.stats_file, "{oops").unwrap();
let err = manager.load_stats().unwrap_err();
assert!(err.contains("stats.json"), "{err}");
}
#[test]
fn cache_round_trips_within_ttl() {
let (manager, _dir) = manager("cache_rt");
let state = sample_state();
manager.cache_diagnostics(&state).unwrap();
assert!(manager.cache_file.is_file());
assert_eq!(manager.get_cached_diagnostics(), Some(state));
}
#[test]
fn cache_expires_after_ttl() {
let (manager, _dir) = manager("cache_ttl");
let state = sample_state();
let entry = CacheEntry {
saved_at: unix_secs_now().saturating_sub(CACHE_TTL_SECS + 1),
state,
};
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(
&manager.cache_file,
serde_json::to_string_pretty(&entry).unwrap(),
)
.unwrap();
assert!(entry.age_secs() >= CACHE_TTL_SECS);
assert_eq!(manager.get_cached_diagnostics(), None);
}
#[test]
fn cache_boundary_exactly_at_ttl_still_counts_fresh() {
let (manager, _dir) = manager("cache_edge");
let entry = CacheEntry {
saved_at: unix_secs_now().saturating_sub(CACHE_TTL_SECS - 1),
state: sample_state(),
};
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(
&manager.cache_file,
serde_json::to_string_pretty(&entry).unwrap(),
)
.unwrap();
assert!(entry.is_fresh());
assert!(manager.get_cached_diagnostics().is_some());
}
#[test]
fn cache_missing_file_returns_none() {
let (manager, _dir) = manager("cache_missing");
assert_eq!(manager.get_cached_diagnostics(), None);
}
#[test]
fn cache_corrupt_file_returns_none() {
let (manager, _dir) = manager("cache_bad");
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(&manager.cache_file, "garbage").unwrap();
assert_eq!(manager.get_cached_diagnostics(), None);
}
#[test]
fn default_manager_uses_home_directory() {
let home = home_dir().expect("home dir should exist in tests");
let manager = PersistenceManager::default();
assert_eq!(manager.config_dir, home.join(".limitless"));
}
#[test]
fn load_stats_reads_legacy_progress_wrapper() {
let (manager, _dir) = manager("stats_wrapper");
let mut wrapped = AchievementProgress::default();
wrapped.stats.record_diagnostic(500);
wrapped.unlocked.push("Speed Runner".into());
let json = serde_json::to_string_pretty(&wrapped).unwrap();
assert!(json.contains("\"unlocked\""));
fs::create_dir_all(&manager.config_dir).unwrap();
fs::write(&manager.stats_file, json).unwrap();
assert_eq!(manager.load_stats().unwrap(), wrapped.stats);
}
#[test]
fn free_functions_target_the_default_manager() {
assert!(init_config().is_ok());
assert!(load_stats().is_ok());
assert_eq!(get_cached_diagnostics(), None);
}
}