tokf 0.2.33

Config-driven CLI tool that compresses command output before it reaches an LLM context
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use std::path::PathBuf;

use super::types::RewriteConfig;

/// Search config dirs for `rewrites.toml` (first found wins).
///
/// Search order:
/// 1. `.tokf/rewrites.toml` (project-local)
/// 2. `~/.config/tokf/rewrites.toml` (user-level)
pub fn load_user_config() -> Option<RewriteConfig> {
    load_user_config_from(&config_search_paths())
}

fn config_search_paths() -> Vec<PathBuf> {
    let mut paths = Vec::new();

    if let Ok(cwd) = std::env::current_dir() {
        paths.push(cwd.join(".tokf/rewrites.toml"));
    }

    if let Some(user) = crate::paths::user_dir() {
        paths.push(user.join("rewrites.toml"));
    }

    paths
}

/// Testable version that accepts explicit paths.
pub fn load_user_config_from(paths: &[PathBuf]) -> Option<RewriteConfig> {
    for path in paths {
        if let Ok(content) = std::fs::read_to_string(path) {
            match toml::from_str(&content) {
                Ok(config) => return Some(config),
                Err(e) => {
                    eprintln!("[tokf] warning: failed to parse {}: {e}", path.display());
                    return None;
                }
            }
        }
    }
    None
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
    use std::fs;

    use tempfile::TempDir;

    use super::*;

    #[test]
    fn load_config_first_found_wins() {
        let dir1 = TempDir::new().unwrap();
        let dir2 = TempDir::new().unwrap();

        let path1 = dir1.path().join("rewrites.toml");
        let path2 = dir2.path().join("rewrites.toml");

        fs::write(
            &path1,
            r#"
[[rewrite]]
match = "^first"
replace = "first"
"#,
        )
        .unwrap();
        fs::write(
            &path2,
            r#"
[[rewrite]]
match = "^second"
replace = "second"
"#,
        )
        .unwrap();

        let config = load_user_config_from(&[path1, path2]).unwrap();
        assert_eq!(config.rewrite[0].match_pattern, "^first");
    }

    #[test]
    fn load_config_nonexistent_returns_none() {
        let result = load_user_config_from(&[PathBuf::from("/no/such/file.toml")]);
        assert!(result.is_none());
    }

    #[test]
    fn load_config_invalid_toml_returns_none() {
        let dir = TempDir::new().unwrap();
        let path = dir.path().join("rewrites.toml");
        fs::write(&path, "not valid [[[").unwrap();

        let result = load_user_config_from(&[path]);
        assert!(result.is_none());
    }
}