1use std::collections::HashMap;
2use std::path::PathBuf;
3use std::{fmt, str::FromStr};
4
5use serde::{Deserialize, Serialize};
6
7use crate::SecretString;
8use crate::mode::AgentMode;
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize)]
18#[serde(rename_all = "lowercase")]
19pub enum AutoAcceptMode {
20 Off,
21 #[default]
22 Safe,
23 All,
24}
25
26impl<'de> Deserialize<'de> for AutoAcceptMode {
27 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
28 where
29 D: serde::Deserializer<'de>,
30 {
31 struct AutoAcceptModeVisitor;
32
33 impl<'de> serde::de::Visitor<'de> for AutoAcceptModeVisitor {
34 type Value = AutoAcceptMode;
35
36 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
37 formatter
38 .write_str("a string (\"off\", \"safe\", \"all\") or a boolean (true/false)")
39 }
40
41 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
42 where
43 E: serde::de::Error,
44 {
45 Ok(if v {
46 AutoAcceptMode::All
47 } else {
48 AutoAcceptMode::Off
49 })
50 }
51
52 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
53 where
54 E: serde::de::Error,
55 {
56 AutoAcceptMode::from_str(v).map_err(serde::de::Error::custom)
57 }
58
59 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
60 where
61 E: serde::de::Error,
62 {
63 AutoAcceptMode::from_str(&v).map_err(serde::de::Error::custom)
64 }
65 }
66
67 deserializer.deserialize_any(AutoAcceptModeVisitor)
68 }
69}
70
71impl FromStr for AutoAcceptMode {
72 type Err = String;
73
74 fn from_str(s: &str) -> Result<Self, Self::Err> {
75 match s.to_lowercase().as_str() {
76 "off" | "false" | "no" | "0" | "disabled" => Ok(AutoAcceptMode::Off),
77 "safe" | "on" => Ok(AutoAcceptMode::Safe),
78 "all" | "always" | "true" | "yes" | "1" | "enabled" => Ok(AutoAcceptMode::All),
79 _ => Err(format!(
80 "Unknown auto-accept mode '{}'. Valid values: off, safe, all",
81 s
82 )),
83 }
84 }
85}
86
87impl fmt::Display for AutoAcceptMode {
88 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
89 match self {
90 AutoAcceptMode::Off => write!(f, "off"),
91 AutoAcceptMode::Safe => write!(f, "safe"),
92 AutoAcceptMode::All => write!(f, "all"),
93 }
94 }
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize, Default)]
104pub struct ProjectSettings {
105 #[serde(default, skip_serializing_if = "Option::is_none")]
107 pub safe_command_prefixes: Option<Vec<String>>,
108 #[serde(default, skip_serializing_if = "Option::is_none")]
110 pub denied_command_prefixes: Option<Vec<String>>,
111 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub auto_accept_mode: Option<AutoAcceptMode>,
114 #[serde(default, skip_serializing_if = "Option::is_none")]
116 pub context_limit: Option<u32>,
117 #[serde(default, skip_serializing_if = "Option::is_none")]
121 pub project_md_files: Option<Vec<String>>,
122 #[serde(default, skip_serializing_if = "Option::is_none")]
124 pub preferred_mode: Option<AgentMode>,
125}
126
127pub fn discover_project_settings(
132 start_dir: &std::path::Path,
133) -> Option<Result<ProjectSettings, SettingsError>> {
134 let mut dir = start_dir.to_path_buf();
135
136 loop {
137 let candidate = dir.join(".tinyharness").join("config.json");
138 if candidate.is_file() {
139 let content = match std::fs::read_to_string(&candidate) {
140 Ok(c) => c,
141 Err(e) => return Some(Err(SettingsError::Io(e))),
142 };
143 let parsed = serde_json::from_str(&content).map_err(SettingsError::Parse);
144 return Some(parsed);
145 }
146
147 if let Some(parent) = dir.parent() {
149 if parent == dir {
150 break;
151 }
152 dir = parent.to_path_buf();
153 } else {
154 break;
155 }
156 }
157
158 None
159}
160
161#[derive(Debug, Clone, Copy, PartialEq, Eq)]
163pub enum SettingSource {
164 Global,
166 Project,
168 Default,
170}
171
172impl std::fmt::Display for SettingSource {
173 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
174 match self {
175 SettingSource::Global => f.write_str("global"),
176 SettingSource::Project => f.write_str("project"),
177 SettingSource::Default => f.write_str("default"),
178 }
179 }
180}
181
182#[derive(Debug, Clone)]
186pub struct MergedSettings {
187 pub safe_commands: Vec<String>,
189 pub safe_commands_source: SettingSource,
190 pub denied_commands: Vec<String>,
192 pub denied_commands_source: SettingSource,
193 pub auto_accept_mode: AutoAcceptMode,
194 pub auto_accept_mode_source: SettingSource,
195 pub context_limit: Option<u32>,
196 pub context_limit_source: SettingSource,
197 pub project_md_files: Vec<String>,
198 pub project_md_files_source: SettingSource,
199 pub preferred_mode: AgentMode,
200 pub preferred_mode_source: SettingSource,
201}
202
203pub fn load_merged_settings() -> (Settings, Option<ProjectSettings>, MergedSettings) {
209 let global = load_settings();
210
211 let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
212 let project = match discover_project_settings(&cwd) {
213 Some(Ok(ps)) => Some(ps),
214 Some(Err(e)) => {
215 tracing::warn!(
216 "Failed to parse .tinyharness/config.json: {e}. Ignoring project settings."
217 );
218 None
219 }
220 None => None,
221 };
222
223 let merged = merge_settings(&global, project.as_ref());
224 (global, project, merged)
225}
226
227fn merge_settings(global: &Settings, project: Option<&ProjectSettings>) -> MergedSettings {
229 let global_safe = global.get_safe_commands();
230 let global_denied = global.get_denied_commands();
231
232 match project {
233 None => MergedSettings {
234 safe_commands: global_safe,
235 safe_commands_source: SettingSource::Default,
236 denied_commands: global_denied,
237 denied_commands_source: SettingSource::Default,
238 auto_accept_mode: global.auto_accept_mode,
239 auto_accept_mode_source: SettingSource::Default,
240 context_limit: global.context_limit,
241 context_limit_source: SettingSource::Default,
242 project_md_files: Vec::new(),
243 project_md_files_source: SettingSource::Default,
244 preferred_mode: global.preferred_mode,
245 preferred_mode_source: SettingSource::Default,
246 },
247 Some(p) => {
248 let safe_commands = if let Some(ref proj_safe) = p.safe_command_prefixes {
250 let mut combined = global_safe.clone();
251 for cmd in proj_safe {
252 if !combined.contains(cmd) {
253 combined.push(cmd.clone());
254 }
255 }
256 combined
257 } else {
258 global_safe
259 };
260 let safe_source = if p.safe_command_prefixes.is_some() {
261 SettingSource::Project
262 } else {
263 SettingSource::Default
264 };
265
266 let (denied_commands, denied_source) =
268 if let Some(ref proj_denied) = p.denied_command_prefixes {
269 (proj_denied.clone(), SettingSource::Project)
270 } else {
271 (global_denied, SettingSource::Default)
272 };
273
274 let (auto_accept_mode, auto_source) = p
275 .auto_accept_mode
276 .map(|v| (v, SettingSource::Project))
277 .unwrap_or((global.auto_accept_mode, SettingSource::Default));
278
279 let (context_limit, ctx_source) = p
280 .context_limit
281 .map(|v| (Some(v), SettingSource::Project))
282 .unwrap_or((global.context_limit, SettingSource::Default));
283
284 let (project_md_files, md_source) = p
285 .project_md_files
286 .as_ref()
287 .map(|files| (files.clone(), SettingSource::Project))
288 .unwrap_or((Vec::new(), SettingSource::Default));
289
290 let (preferred_mode, mode_source) = p
291 .preferred_mode
292 .map(|m| (m, SettingSource::Project))
293 .unwrap_or((global.preferred_mode, SettingSource::Default));
294
295 MergedSettings {
296 safe_commands,
297 safe_commands_source: safe_source,
298 denied_commands,
299 denied_commands_source: denied_source,
300 auto_accept_mode,
301 auto_accept_mode_source: auto_source,
302 context_limit,
303 context_limit_source: ctx_source,
304 project_md_files,
305 project_md_files_source: md_source,
306 preferred_mode,
307 preferred_mode_source: mode_source,
308 }
309 }
310 }
311}
312
313pub fn generate_project_config_template(settings: &Settings) -> ProjectSettings {
317 ProjectSettings {
318 safe_command_prefixes: settings.safe_command_prefixes.clone(),
319 denied_command_prefixes: settings.denied_command_prefixes.clone(),
320 auto_accept_mode: Some(settings.auto_accept_mode),
321 context_limit: settings.context_limit,
322 project_md_files: None, preferred_mode: Some(settings.preferred_mode),
324 }
325}
326
327#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
329pub enum ProviderKind {
330 #[default]
331 Ollama,
332 LlamaCpp,
333 Vllm,
334 OpenAiCompat,
340 Sockudo,
341}
342
343impl fmt::Display for ProviderKind {
344 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
345 match self {
346 ProviderKind::Ollama => f.write_str("ollama"),
347 ProviderKind::LlamaCpp => f.write_str("llama.cpp"),
348 ProviderKind::Vllm => f.write_str("vllm"),
349 ProviderKind::OpenAiCompat => f.write_str("openai-compat"),
350 ProviderKind::Sockudo => f.write_str("sockudo"),
351 }
352 }
353}
354
355impl FromStr for ProviderKind {
356 type Err = String;
357
358 fn from_str(s: &str) -> Result<Self, Self::Err> {
359 match s.trim().to_lowercase().as_str() {
360 "ollama" => Ok(ProviderKind::Ollama),
361 "llama.cpp" | "llamacpp" | "llama_cpp" => Ok(ProviderKind::LlamaCpp),
362 "vllm" => Ok(ProviderKind::Vllm),
363 "openai-compat" | "openaicompat" | "openai_compat" => Ok(ProviderKind::OpenAiCompat),
364 "sockudo" => Ok(ProviderKind::Sockudo),
365 _ => Err(format!("Unknown provider '{}'", s)),
366 }
367 }
368}
369
370#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
377pub enum OllamaThinkType {
378 Off,
380 Low,
382 #[default]
384 Medium,
385 High,
387}
388
389impl fmt::Display for OllamaThinkType {
390 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
391 match self {
392 OllamaThinkType::Off => f.write_str("off"),
393 OllamaThinkType::Low => f.write_str("low"),
394 OllamaThinkType::Medium => f.write_str("medium"),
395 OllamaThinkType::High => f.write_str("high"),
396 }
397 }
398}
399
400impl FromStr for OllamaThinkType {
401 type Err = String;
402
403 fn from_str(s: &str) -> Result<Self, Self::Err> {
404 match s.trim().to_lowercase().as_str() {
405 "off" | "false" | "0" => Ok(OllamaThinkType::Off),
406 "low" => Ok(OllamaThinkType::Low),
407 "medium" | "mid" => Ok(OllamaThinkType::Medium),
408 "high" => Ok(OllamaThinkType::High),
409 _ => Err(format!(
410 "Unknown think type '{}'. Valid values: off, low, medium, high",
411 s
412 )),
413 }
414 }
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize)]
421#[serde(default)] pub struct Settings {
423 #[serde(default)]
424 pub last_provider: ProviderKind,
425 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
430 pub provider_urls: HashMap<ProviderKind, String>,
431 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
436 pub provider_models: HashMap<ProviderKind, String>,
437 #[serde(default)]
438 pub preferred_mode: AgentMode,
439 #[serde(default)]
440 pub ollama_api_key: Option<SecretString>,
441 pub openai_compat_api_key: Option<SecretString>,
445 pub sockudo_app_id: Option<String>,
447 pub sockudo_app_key: Option<String>,
449 pub sockudo_app_secret: Option<SecretString>,
451 #[serde(default)]
453 pub ollama_timeout_secs: u64,
454 #[serde(default)]
456 pub ollama_max_retries: u32,
457 #[serde(default)]
459 pub ollama_think_type: OllamaThinkType,
460 #[serde(default)]
462 pub show_thinking: bool,
463 pub context_limit: Option<u32>,
465 #[serde(default)]
475 pub auto_accept_mode: AutoAcceptMode,
476 pub skip_health_check: bool,
482 pub safe_command_prefixes: Option<Vec<String>>,
484 pub denied_command_prefixes: Option<Vec<String>>,
487 pub project_md_files: Option<Vec<String>>,
492}
493
494impl Default for Settings {
495 fn default() -> Self {
496 Settings {
497 last_provider: ProviderKind::Ollama,
498 provider_urls: HashMap::new(),
499 provider_models: HashMap::new(),
500 preferred_mode: AgentMode::Casual,
501 ollama_api_key: None,
502 openai_compat_api_key: None,
503 sockudo_app_id: None,
504 sockudo_app_key: None,
505 sockudo_app_secret: None,
506 ollama_timeout_secs: 5,
507 ollama_max_retries: 3,
508 ollama_think_type: OllamaThinkType::Medium,
509 show_thinking: false,
510 context_limit: None,
511 auto_accept_mode: AutoAcceptMode::Safe,
512 skip_health_check: false,
513 safe_command_prefixes: None,
514 denied_command_prefixes: None,
515 project_md_files: None,
516 }
517 }
518}
519
520pub fn get_default_safe_commands() -> Vec<String> {
523 vec![
524 "cd".to_string(),
525 "ls".to_string(),
526 "grep".to_string(),
527 "glob".to_string(),
528 "find".to_string(),
529 "cat".to_string(),
530 "head".to_string(),
531 "tail".to_string(),
532 "wc".to_string(),
533 "pwd".to_string(),
534 "echo".to_string(),
535 "printf".to_string(),
536 "tree".to_string(),
537 "file".to_string(),
538 "stat".to_string(),
539 "du".to_string(),
540 "df".to_string(),
541 "free".to_string(),
542 "uptime".to_string(),
543 "whoami".to_string(),
544 "hostname".to_string(),
545 "uname".to_string(),
546 "date".to_string(),
547 "cal".to_string(),
548 "ps".to_string(),
549 "env".to_string(),
550 "printenv".to_string(),
551 "which".to_string(),
552 "whereis".to_string(),
553 "type".to_string(),
554 "git status".to_string(),
555 "git diff".to_string(),
556 "git log".to_string(),
557 "git show".to_string(),
558 "git branch".to_string(),
559 "git remote".to_string(),
560 "git tag".to_string(),
561 "git describe".to_string(),
562 "git rev-parse".to_string(),
563 "cargo tree".to_string(),
564 "cargo metadata".to_string(),
565 "cargo doc".to_string(),
566 "rustc --version".to_string(),
567 "cargo --version".to_string(),
568 ]
569}
570
571impl Settings {
572 pub fn get_safe_commands(&self) -> Vec<String> {
574 self.safe_command_prefixes
575 .clone()
576 .unwrap_or_else(get_default_safe_commands)
577 }
578
579 pub fn get_denied_commands(&self) -> Vec<String> {
584 self.denied_command_prefixes.clone().unwrap_or_default()
585 }
586
587 pub fn get_url_for(&self, kind: ProviderKind) -> Option<&str> {
589 self.provider_urls.get(&kind).map(|s| s.as_str())
590 }
591
592 pub fn set_url_for(&mut self, kind: ProviderKind, url: String) {
594 self.provider_urls.insert(kind, url);
595 }
596
597 pub fn get_model_for(&self, kind: ProviderKind) -> Option<&str> {
599 self.provider_models.get(&kind).map(|s| s.as_str())
600 }
601
602 pub fn set_model_for(&mut self, kind: ProviderKind, model: String) {
604 self.provider_models.insert(kind, model);
605 }
606
607 pub fn get_current_model(&self) -> Option<&str> {
609 self.get_model_for(self.last_provider)
610 }
611
612 pub fn get_current_url(&self) -> Option<&str> {
614 self.get_url_for(self.last_provider)
615 }
616}
617
618#[derive(Debug)]
622pub enum SettingsError {
623 Io(std::io::Error),
624 Parse(serde_json::Error),
625}
626
627impl std::fmt::Display for SettingsError {
628 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629 match self {
630 SettingsError::Io(e) => write!(f, "I/O error: {}", e),
631 SettingsError::Parse(e) => write!(f, "parse error: {}", e),
632 }
633 }
634}
635
636impl std::error::Error for SettingsError {
637 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
638 match self {
639 SettingsError::Io(e) => Some(e),
640 SettingsError::Parse(e) => Some(e),
641 }
642 }
643}
644
645impl From<std::io::Error> for SettingsError {
646 fn from(e: std::io::Error) -> Self {
647 SettingsError::Io(e)
648 }
649}
650
651impl From<serde_json::Error> for SettingsError {
652 fn from(e: serde_json::Error) -> Self {
653 SettingsError::Parse(e)
654 }
655}
656
657pub struct SettingsStore {
664 path: std::path::PathBuf,
665}
666
667impl SettingsStore {
668 pub fn default_path() -> Self {
671 let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
672 let path = std::path::PathBuf::from(home).join(".config/tinyharness/settings.json");
673 SettingsStore { path }
674 }
675
676 pub fn new(path: std::path::PathBuf) -> Self {
678 SettingsStore { path }
679 }
680
681 pub fn load(&self) -> Result<Settings, SettingsError> {
686 if !self.path.exists() {
687 return Ok(Settings::default());
688 }
689 let content = std::fs::read_to_string(&self.path)?;
690 let mut settings: Settings = serde_json::from_str(&content)?;
691
692 if let Ok(raw) = serde_json::from_str::<serde_json::Value>(&content)
697 && let Some(obj) = raw.as_object()
698 && !obj.contains_key("auto_accept_mode")
699 {
700 if let Some(val) = obj.get("auto_accept_all") {
702 if val.as_bool() == Some(true) {
703 settings.auto_accept_mode = AutoAcceptMode::All;
704 } else if val.as_bool() == Some(false) {
705 settings.auto_accept_mode = AutoAcceptMode::Off;
706 }
707 }
708 else if let Some(val) = obj.get("auto_accept_safe_commands")
711 && val.as_bool() == Some(false)
712 {
713 settings.auto_accept_mode = AutoAcceptMode::Off;
714 }
715 }
716
717 if let Ok(raw) = serde_json::from_str::<serde_json::Value>(&content)
721 && let Some(obj) = raw.as_object()
722 {
723 if settings.provider_models.is_empty()
724 && let Some(model) = obj.get("last_model")
725 && let Some(model_str) = model.as_str()
726 && !model_str.is_empty()
727 {
728 settings
729 .provider_models
730 .insert(settings.last_provider, model_str.to_string());
731 }
732 if settings.provider_urls.is_empty()
733 && let Some(url) = obj.get("last_provider_url")
734 && let Some(url_str) = url.as_str()
735 && !url_str.is_empty()
736 {
737 settings
738 .provider_urls
739 .insert(settings.last_provider, url_str.to_string());
740 }
741 }
742
743 Ok(settings)
744 }
745
746 pub fn load_or_default(&self) -> Settings {
751 self.load().unwrap_or_else(|e| {
752 tracing::warn!("Failed to load settings: {e}. Using defaults.");
753 Settings::default()
754 })
755 }
756
757 pub fn save(&self, settings: &Settings) -> Result<(), SettingsError> {
759 let dir = self.path.parent().ok_or_else(|| {
760 SettingsError::Io(std::io::Error::new(
761 std::io::ErrorKind::InvalidInput,
762 "settings path has no parent directory",
763 ))
764 })?;
765 std::fs::create_dir_all(dir)?;
766
767 let json = serde_json::to_string_pretty(settings)?;
768 let tmp_path = dir.join("settings.json.tmp");
769
770 {
771 let mut file = std::fs::File::create(&tmp_path)?;
772 std::io::Write::write_all(&mut file, json.as_bytes())?;
773 std::io::Write::flush(&mut file)?;
774 }
775
776 std::fs::rename(&tmp_path, &self.path)?;
777 Ok(())
778 }
779
780 pub fn path(&self) -> &std::path::Path {
782 &self.path
783 }
784}
785
786pub fn load_settings() -> Settings {
793 SettingsStore::default_path().load_or_default()
794}
795
796pub fn save_settings(settings: &Settings) {
802 let store = SettingsStore::default_path();
803 if let Err(e) = store.save(settings) {
804 tracing::warn!("Failed to save settings: {e}");
805 }
806}
807
808pub fn resolve_project_md_files(settings: Option<&Settings>) -> Vec<String> {
817 if let Ok(env) = std::env::var("TINYHARNESS_MD_FILES") {
819 let files: Vec<String> = env
820 .split(',')
821 .map(|s| s.trim().to_string())
822 .filter(|s| !s.is_empty())
823 .collect();
824 if !files.is_empty() {
825 return files;
826 }
827 }
828
829 if let Some(s) = settings
831 && let Some(ref configured) = s.project_md_files
832 && !configured.is_empty()
833 {
834 return configured.clone();
835 }
836
837 crate::context::DEFAULT_PROJECT_MD_FILE_NAMES
839 .iter()
840 .map(|s| s.to_string())
841 .collect()
842}
843
844pub fn prompts_dir() -> PathBuf {
848 let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
849 PathBuf::from(home)
850 .join(".config")
851 .join("tinyharness")
852 .join("prompts")
853}
854
855pub fn ensure_prompts_initialized() -> PathBuf {
864 let dir = prompts_dir();
865 if !dir.exists() {
866 std::fs::create_dir_all(&dir).ok();
867 }
868
869 {
871 let header_path = dir.join("header.md");
872 if !header_path.exists() {
873 let header_text = include_str!("../prompts/header.md");
874 if let Err(e) = std::fs::write(&header_path, header_text.trim()) {
875 tracing::warn!(
876 "Failed to write default header to {}: {e}",
877 header_path.display(),
878 );
879 }
880 }
881 }
882
883 let modes = [
884 AgentMode::Casual,
885 AgentMode::Planning,
886 AgentMode::Agent,
887 AgentMode::Research,
888 ];
889
890 for mode in &modes {
891 let file_path = dir.join(mode.prompts_filename());
892 if !file_path.exists() {
893 let default_text = mode.default_system_prompt();
894 if let Err(e) = std::fs::write(&file_path, default_text.trim()) {
896 tracing::warn!(
897 "Failed to write default prompt to {}: {e}",
898 file_path.display(),
899 );
900 }
901 }
902 }
903
904 dir
905}
906
907#[cfg(test)]
910mod tests {
911 use super::*;
912
913 #[test]
916 fn load_settings_missing_fields_uses_defaults() {
917 let json = r#"{
918 "last_provider": "OpenAiCompat",
919 "last_provider_url": "http://localhost:8080/v1",
920 "last_model": "MiniMax-M3",
921 "preferred_mode": "Agent",
922 "ollama_api_key": null,
923 "openai_compat_api_key": "sk-test",
924 "ollama_timeout_secs": 5,
925 "ollama_max_retries": 3,
926 "ollama_think_type": "High",
927 "show_thinking": true,
928 "context_limit": 256000,
929 "auto_accept_mode": "all",
930 "skip_health_check": true
931 }"#;
932
933 let settings: Settings =
934 serde_json::from_str(json).expect("missing fields should use defaults");
935 assert_eq!(settings.last_provider, ProviderKind::OpenAiCompat);
936 assert_eq!(settings.preferred_mode, AgentMode::Agent);
937 assert!(settings.skip_health_check);
939 assert_eq!(settings.ollama_think_type, OllamaThinkType::High);
940 }
941
942 #[test]
944 fn load_settings_empty_object_uses_all_defaults() {
945 let settings: Settings =
946 serde_json::from_str("{}").expect("empty object should use defaults");
947 assert_eq!(settings.last_provider, ProviderKind::Ollama);
948 assert_eq!(settings.preferred_mode, AgentMode::Casual);
949 assert!(!settings.skip_health_check);
950 }
951
952 #[test]
953 fn auto_accept_mode_from_string() {
954 let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "all"}"#).unwrap();
955 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
956
957 let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "off"}"#).unwrap();
958 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
959
960 let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "safe"}"#).unwrap();
961 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Safe);
962 }
963
964 #[test]
965 fn auto_accept_mode_from_legacy_bool() {
966 let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": true}"#).unwrap();
967 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
968
969 let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": false}"#).unwrap();
970 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
971 }
972 #[test]
973 fn auto_accept_mode_from_legacy_all_field() {
974 let store = SettingsStore::new(temp_settings_path());
976 let json = r#"{"auto_accept_all": true}"#;
977 std::fs::write(store.path(), json).unwrap();
978 let settings = store.load().unwrap();
979 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
980 let _ = std::fs::remove_file(store.path());
981
982 let store = SettingsStore::new(temp_settings_path());
984 let json = r#"{"auto_accept_all": false}"#;
985 std::fs::write(store.path(), json).unwrap();
986 let settings = store.load().unwrap();
987 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
988 let _ = std::fs::remove_file(store.path());
989 }
990 #[test]
991 fn auto_accept_mode_from_legacy_safe_commands_field() {
992 let store = SettingsStore::new(temp_settings_path());
994 let json = r#"{"auto_accept_safe_commands": false}"#;
995 std::fs::write(store.path(), json).unwrap();
996 let settings = store.load().unwrap();
997 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
998 let _ = std::fs::remove_file(store.path());
999
1000 let store = SettingsStore::new(temp_settings_path());
1002 let json = r#"{"auto_accept_safe_commands": true}"#;
1003 std::fs::write(store.path(), json).unwrap();
1004 let settings = store.load().unwrap();
1005 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Safe);
1006 let _ = std::fs::remove_file(store.path());
1007 }
1008
1009 #[test]
1010 fn auto_accept_mode_explicit_overrides_legacy() {
1011 let settings: Settings =
1013 serde_json::from_str(r#"{"auto_accept_mode": "off", "auto_accept_all": true}"#)
1014 .unwrap();
1015 assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
1016 }
1017
1018 #[test]
1019 fn migrate_legacy_last_model_and_url() {
1020 let store = SettingsStore::new(temp_settings_path());
1021 let json = r#"{"last_provider": "Ollama", "last_model": "qwen2.5:7b", "last_provider_url": "http://localhost:11434"}"#;
1022 std::fs::write(store.path(), json).unwrap();
1023 let settings = store.load().unwrap();
1024 assert_eq!(
1025 settings.get_model_for(ProviderKind::Ollama),
1026 Some("qwen2.5:7b")
1027 );
1028 assert_eq!(
1029 settings.get_url_for(ProviderKind::Ollama),
1030 Some("http://localhost:11434")
1031 );
1032 let _ = std::fs::remove_file(store.path());
1033 }
1034
1035 #[test]
1036 fn migrate_legacy_fields_for_openai_compat() {
1037 let store = SettingsStore::new(temp_settings_path());
1038 let json = r#"{"last_provider": "OpenAiCompat", "last_model": "gpt-4o", "last_provider_url": "https://api.openai.com/v1"}"#;
1039 std::fs::write(store.path(), json).unwrap();
1040 let settings = store.load().unwrap();
1041 assert_eq!(
1042 settings.get_model_for(ProviderKind::OpenAiCompat),
1043 Some("gpt-4o")
1044 );
1045 assert_eq!(
1046 settings.get_url_for(ProviderKind::OpenAiCompat),
1047 Some("https://api.openai.com/v1")
1048 );
1049 assert_eq!(settings.get_model_for(ProviderKind::Ollama), None);
1051 let _ = std::fs::remove_file(store.path());
1052 }
1053
1054 #[test]
1055 fn per_provider_model_and_url_accessors() {
1056 let mut settings = Settings::default();
1057 settings.set_model_for(ProviderKind::Ollama, "qwen2.5:7b".to_string());
1058 settings.set_model_for(ProviderKind::LlamaCpp, "llama-3.1-8b".to_string());
1059 settings.set_url_for(ProviderKind::LlamaCpp, "http://localhost:8080".to_string());
1060
1061 assert_eq!(
1062 settings.get_model_for(ProviderKind::Ollama),
1063 Some("qwen2.5:7b")
1064 );
1065 assert_eq!(
1066 settings.get_model_for(ProviderKind::LlamaCpp),
1067 Some("llama-3.1-8b")
1068 );
1069 assert_eq!(settings.get_model_for(ProviderKind::Vllm), None);
1070 assert_eq!(
1071 settings.get_url_for(ProviderKind::LlamaCpp),
1072 Some("http://localhost:8080")
1073 );
1074 assert_eq!(settings.get_url_for(ProviderKind::Ollama), None);
1075 }
1076
1077 #[test]
1078 fn get_current_model_and_url_use_last_provider() {
1079 let mut settings = Settings {
1080 last_provider: ProviderKind::OpenAiCompat,
1081 ..Settings::default()
1082 };
1083 settings.set_model_for(ProviderKind::OpenAiCompat, "gpt-4o".to_string());
1084 settings.set_url_for(
1085 ProviderKind::OpenAiCompat,
1086 "https://api.openai.com/v1".to_string(),
1087 );
1088
1089 assert_eq!(settings.get_current_model(), Some("gpt-4o"));
1090 assert_eq!(
1091 settings.get_current_url(),
1092 Some("https://api.openai.com/v1")
1093 );
1094 }
1095
1096 fn temp_settings_path() -> std::path::PathBuf {
1097 let mut dir = std::env::temp_dir();
1098 dir.push(format!(
1099 "tinyharness_test_{}_{:?}.json",
1100 std::process::id(),
1101 std::thread::current().id()
1102 ));
1103 dir
1104 }
1105}