sofos 0.1.22

An interactive AI coding agent for your terminal
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

/// Central configuration for Sofos
#[derive(Debug, Clone)]
pub struct SofosConfig {
    pub max_messages: usize,
    pub max_context_tokens: usize,
    pub max_tool_iterations: u32,
    #[allow(dead_code)]
    pub max_file_size: usize,
    #[allow(dead_code)]
    pub max_bash_output: usize,
    /// Auto-compact when token usage exceeds this ratio of max_context_tokens
    pub compaction_trigger_ratio: f64,
    /// Number of recent messages to preserve during compaction
    pub compaction_preserve_recent: usize,
    /// Truncate tool results longer than this (chars) during compaction
    pub tool_result_truncate_threshold: usize,
}

impl Default for SofosConfig {
    fn default() -> Self {
        Self {
            max_messages: 500,
            max_context_tokens: 165_000,
            max_tool_iterations: 200,
            max_file_size: 10 * 1024 * 1024,
            max_bash_output: 50 * 1024 * 1024,
            compaction_trigger_ratio: 0.80,
            compaction_preserve_recent: 20,
            tool_result_truncate_threshold: 2000,
        }
    }
}

/// Configuration for the language model
#[derive(Clone)]
pub struct ModelConfig {
    pub model: String,
    pub max_tokens: u32,
    pub enable_thinking: bool,
    pub thinking_budget: u32,
}

impl ModelConfig {
    pub fn new(
        model: String,
        max_tokens: u32,
        enable_thinking: bool,
        thinking_budget: u32,
    ) -> Self {
        Self {
            model,
            max_tokens,
            enable_thinking,
            thinking_budget,
        }
    }

    pub fn set_thinking(&mut self, enabled: bool) {
        self.enable_thinking = enabled;
    }
}

impl SofosConfig {
    // No need for new() since Default::default() is the idiomatic way
}

/// Safe mode message shown to user and AI
pub const SAFE_MODE_MESSAGE: &str = "[SYSTEM: Safe (read-only) mode has been enabled. \
                                     No file modifications or bash commands are allowed.\
                                     Available tools: list_directory, read_file and web_search.]";

/// Normal mode message shown when switching from safe mode
pub const NORMAL_MODE_MESSAGE: &str = "[SYSTEM: Normal (unrestricted) mode has been enabled. \
                                       File modifications and bash commands are now allowed.\
                                       All tools are available]";

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = SofosConfig::default();
        assert_eq!(config.max_messages, 500);
        assert_eq!(config.max_context_tokens, 165_000);
        assert_eq!(config.max_tool_iterations, 200);
        assert_eq!(config.max_file_size, 10 * 1024 * 1024);
        assert_eq!(config.max_bash_output, 50 * 1024 * 1024);
        assert!((config.compaction_trigger_ratio - 0.80).abs() < f64::EPSILON);
        assert_eq!(config.compaction_preserve_recent, 20);
        assert_eq!(config.tool_result_truncate_threshold, 2000);
    }
}