use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::{fmt, str::FromStr};
use serde::{Deserialize, Serialize};
use crate::SecretString;
use crate::mode::AgentMode;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum AutoAcceptMode {
Off,
#[default]
Safe,
All,
}
impl<'de> Deserialize<'de> for AutoAcceptMode {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct AutoAcceptModeVisitor;
impl<'de> serde::de::Visitor<'de> for AutoAcceptModeVisitor {
type Value = AutoAcceptMode;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter
.write_str("a string (\"off\", \"safe\", \"all\") or a boolean (true/false)")
}
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(if v {
AutoAcceptMode::All
} else {
AutoAcceptMode::Off
})
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
AutoAcceptMode::from_str(v).map_err(serde::de::Error::custom)
}
fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
AutoAcceptMode::from_str(&v).map_err(serde::de::Error::custom)
}
}
deserializer.deserialize_any(AutoAcceptModeVisitor)
}
}
impl FromStr for AutoAcceptMode {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"off" | "false" | "no" | "0" | "disabled" => Ok(AutoAcceptMode::Off),
"safe" | "on" => Ok(AutoAcceptMode::Safe),
"all" | "always" | "true" | "yes" | "1" | "enabled" => Ok(AutoAcceptMode::All),
_ => Err(format!(
"Unknown auto-accept mode '{}'. Valid values: off, safe, all",
s
)),
}
}
}
impl fmt::Display for AutoAcceptMode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
AutoAcceptMode::Off => write!(f, "off"),
AutoAcceptMode::Safe => write!(f, "safe"),
AutoAcceptMode::All => write!(f, "all"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SandboxConfig {
pub backend: String,
#[serde(default)]
pub writable_paths: Vec<String>,
}
impl Default for SandboxConfig {
fn default() -> Self {
Self::auto()
}
}
impl SandboxConfig {
pub fn disabled() -> Self {
SandboxConfig {
backend: "off".to_string(),
writable_paths: Vec::new(),
}
}
pub fn auto() -> Self {
SandboxConfig {
backend: "auto".to_string(),
..Self::disabled()
}
}
pub fn is_disabled(&self) -> bool {
crate::sandbox::SandboxBackend::is_off(&self.backend)
}
pub fn is_enabled(&self) -> bool {
!self.is_disabled()
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProjectSettings {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub safe_command_prefixes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub denied_command_prefixes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub auto_accept_mode: Option<AutoAcceptMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub context_limit: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub project_md_files: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preferred_mode: Option<AgentMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub auto_compact_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub questions_enabled: Option<bool>,
}
pub fn discover_project_settings(
start_dir: &std::path::Path,
) -> Option<Result<ProjectSettings, SettingsError>> {
let mut dir = start_dir.to_path_buf();
loop {
let candidate = dir.join(".tinyharness").join("config.json");
if candidate.is_file() {
let content = match std::fs::read_to_string(&candidate) {
Ok(c) => c,
Err(e) => return Some(Err(SettingsError::Io(e))),
};
let parsed = serde_json::from_str(&content).map_err(SettingsError::Parse);
return Some(parsed);
}
if let Some(parent) = dir.parent() {
if parent == dir {
break;
}
dir = parent.to_path_buf();
} else {
break;
}
}
None
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SettingSource {
Global,
Project,
Default,
}
impl std::fmt::Display for SettingSource {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
SettingSource::Global => f.write_str("global"),
SettingSource::Project => f.write_str("project"),
SettingSource::Default => f.write_str("default"),
}
}
}
#[derive(Debug, Clone)]
pub struct MergedSettings {
pub safe_commands: Vec<String>,
pub safe_commands_source: SettingSource,
pub denied_commands: Vec<String>,
pub denied_commands_source: SettingSource,
pub auto_accept_mode: AutoAcceptMode,
pub auto_accept_mode_source: SettingSource,
pub context_limit: Option<u32>,
pub context_limit_source: SettingSource,
pub project_md_files: Vec<String>,
pub project_md_files_source: SettingSource,
pub preferred_mode: AgentMode,
pub preferred_mode_source: SettingSource,
pub auto_compact_enabled: bool,
pub auto_compact_enabled_source: SettingSource,
pub questions_enabled: bool,
pub questions_enabled_source: SettingSource,
pub sandbox: SandboxConfig,
pub sandbox_source: SettingSource,
pub allowed_paths: Vec<String>,
pub allowed_paths_source: SettingSource,
}
pub fn load_merged_settings_from(
paths: &crate::paths::Paths,
) -> (Settings, Option<ProjectSettings>, MergedSettings) {
let global = load_settings_from(paths);
let project = project_settings_or_none(paths);
let merged = merge_settings(&global, project.as_ref());
(global, project, merged)
}
pub fn load_merged_settings() -> (Settings, Option<ProjectSettings>, MergedSettings) {
load_merged_settings_from(&crate::paths::Paths::default())
}
pub(crate) fn project_settings_or_none(paths: &crate::paths::Paths) -> Option<ProjectSettings> {
match discover_project_settings(paths.project_dir()) {
Some(Ok(ps)) => Some(ps),
Some(Err(e)) => {
tracing::warn!(
"Failed to parse .tinyharness/config.json: {e}. Ignoring project settings."
);
None
}
None => None,
}
}
fn merge_settings(global: &Settings, project: Option<&ProjectSettings>) -> MergedSettings {
let global_safe = global.get_safe_commands();
let global_denied = global.get_denied_commands();
match project {
None => MergedSettings {
safe_commands: global_safe,
safe_commands_source: SettingSource::Default,
denied_commands: global_denied,
denied_commands_source: SettingSource::Default,
auto_accept_mode: global.auto_accept_mode,
auto_accept_mode_source: SettingSource::Default,
context_limit: global.context_limit,
context_limit_source: SettingSource::Default,
project_md_files: Vec::new(),
project_md_files_source: SettingSource::Default,
preferred_mode: global.preferred_mode,
preferred_mode_source: SettingSource::Default,
auto_compact_enabled: global.auto_compact_enabled,
auto_compact_enabled_source: SettingSource::Default,
questions_enabled: global.questions_enabled,
questions_enabled_source: SettingSource::Default,
sandbox: global.sandbox.clone(),
sandbox_source: SettingSource::Global,
allowed_paths: global.allowed_paths.clone().unwrap_or_default(),
allowed_paths_source: SettingSource::Default,
},
Some(p) => {
let safe_commands = if let Some(ref proj_safe) = p.safe_command_prefixes {
let mut combined = global_safe.clone();
for cmd in proj_safe {
if !combined.contains(cmd) {
combined.push(cmd.clone());
}
}
combined
} else {
global_safe
};
let safe_source = if p.safe_command_prefixes.is_some() {
SettingSource::Project
} else {
SettingSource::Default
};
let (denied_commands, denied_source) =
if let Some(ref proj_denied) = p.denied_command_prefixes {
(proj_denied.clone(), SettingSource::Project)
} else {
(global_denied, SettingSource::Default)
};
let (auto_accept_mode, auto_source) = p
.auto_accept_mode
.map(|v| (v, SettingSource::Project))
.unwrap_or((global.auto_accept_mode, SettingSource::Default));
let (context_limit, ctx_source) = p
.context_limit
.map(|v| (Some(v), SettingSource::Project))
.unwrap_or((global.context_limit, SettingSource::Default));
let (project_md_files, md_source) = p
.project_md_files
.as_ref()
.map(|files| (files.clone(), SettingSource::Project))
.unwrap_or((Vec::new(), SettingSource::Default));
let (preferred_mode, mode_source) = p
.preferred_mode
.map(|m| (m, SettingSource::Project))
.unwrap_or((global.preferred_mode, SettingSource::Default));
let (auto_compact_enabled, ac_source) = p
.auto_compact_enabled
.map(|v| (v, SettingSource::Project))
.unwrap_or((global.auto_compact_enabled, SettingSource::Default));
let (questions_enabled, q_source) = p
.questions_enabled
.map(|v| (v, SettingSource::Project))
.unwrap_or((global.questions_enabled, SettingSource::Default));
let sandbox = global.sandbox.clone();
let sandbox_source = SettingSource::Global;
let allowed_paths = global.allowed_paths.clone().unwrap_or_default();
let allowed_paths_source = SettingSource::Global;
MergedSettings {
safe_commands,
safe_commands_source: safe_source,
denied_commands,
denied_commands_source: denied_source,
auto_accept_mode,
auto_accept_mode_source: auto_source,
context_limit,
context_limit_source: ctx_source,
project_md_files,
project_md_files_source: md_source,
preferred_mode,
preferred_mode_source: mode_source,
auto_compact_enabled,
auto_compact_enabled_source: ac_source,
questions_enabled,
questions_enabled_source: q_source,
sandbox,
sandbox_source,
allowed_paths,
allowed_paths_source,
}
}
}
}
impl MergedSettings {
pub fn tool_availability(&self) -> crate::tools::ToolAvailability {
crate::tools::ToolAvailability {
auto_compact: self.auto_compact_enabled,
question: self.questions_enabled,
}
}
}
pub fn generate_project_config_template(settings: &Settings) -> ProjectSettings {
ProjectSettings {
safe_command_prefixes: settings.safe_command_prefixes.clone(),
denied_command_prefixes: settings.denied_command_prefixes.clone(),
auto_accept_mode: Some(settings.auto_accept_mode),
context_limit: settings.context_limit,
project_md_files: None, preferred_mode: Some(settings.preferred_mode),
auto_compact_enabled: Some(settings.auto_compact_enabled),
questions_enabled: Some(settings.questions_enabled),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ProviderKind {
#[default]
Ollama,
LlamaCpp,
Vllm,
OpenAiCompat,
Sockudo,
}
impl fmt::Display for ProviderKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ProviderKind::Ollama => f.write_str("ollama"),
ProviderKind::LlamaCpp => f.write_str("llama.cpp"),
ProviderKind::Vllm => f.write_str("vllm"),
ProviderKind::OpenAiCompat => f.write_str("openai-compat"),
ProviderKind::Sockudo => f.write_str("sockudo"),
}
}
}
impl FromStr for ProviderKind {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.trim().to_lowercase().as_str() {
"ollama" => Ok(ProviderKind::Ollama),
"llama.cpp" | "llamacpp" | "llama_cpp" => Ok(ProviderKind::LlamaCpp),
"vllm" => Ok(ProviderKind::Vllm),
"openai-compat" | "openaicompat" | "openai_compat" => Ok(ProviderKind::OpenAiCompat),
"sockudo" => Ok(ProviderKind::Sockudo),
_ => Err(format!("Unknown provider '{}'", s)),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)] pub struct Settings {
#[serde(default)]
pub last_provider: ProviderKind,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub provider_urls: HashMap<ProviderKind, String>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub provider_models: HashMap<ProviderKind, String>,
#[serde(default)]
pub preferred_mode: AgentMode,
pub openai_compat_api_key: Option<SecretString>,
pub sockudo_app_id: Option<String>,
pub sockudo_app_key: Option<String>,
pub sockudo_app_secret: Option<SecretString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub request_timeout_secs: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub request_max_retries: Option<u32>,
#[serde(default)]
pub show_thinking: bool,
pub context_limit: Option<u32>,
#[serde(default)]
pub auto_accept_mode: AutoAcceptMode,
pub skip_health_check: bool,
pub safe_command_prefixes: Option<Vec<String>>,
pub denied_command_prefixes: Option<Vec<String>>,
pub project_md_files: Option<Vec<String>>,
#[serde(default = "default_true")]
pub auto_compact_enabled: bool,
#[serde(default = "default_true")]
pub questions_enabled: bool,
#[serde(default, skip_serializing_if = "SandboxConfig::is_disabled")]
pub sandbox: SandboxConfig,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_paths: Option<Vec<String>>,
}
fn default_true() -> bool {
true
}
pub fn timeout_default_for(kind: ProviderKind) -> u64 {
match kind {
ProviderKind::Ollama => 5,
ProviderKind::Sockudo => 120,
_ => 30,
}
}
impl Default for Settings {
fn default() -> Self {
Settings {
last_provider: ProviderKind::Ollama,
provider_urls: HashMap::new(),
provider_models: HashMap::new(),
preferred_mode: AgentMode::Casual,
openai_compat_api_key: None,
sockudo_app_id: None,
sockudo_app_key: None,
sockudo_app_secret: None,
request_timeout_secs: None,
request_max_retries: None,
show_thinking: true,
context_limit: None,
auto_accept_mode: AutoAcceptMode::Safe,
skip_health_check: false,
safe_command_prefixes: None,
denied_command_prefixes: None,
project_md_files: None,
auto_compact_enabled: true,
questions_enabled: true,
sandbox: SandboxConfig::default(),
allowed_paths: None,
}
}
}
pub fn get_default_safe_commands() -> Vec<String> {
vec![
"cd".to_string(),
"ls".to_string(),
"grep".to_string(),
"glob".to_string(),
"find".to_string(),
"cat".to_string(),
"head".to_string(),
"tail".to_string(),
"wc".to_string(),
"pwd".to_string(),
"echo".to_string(),
"printf".to_string(),
"tree".to_string(),
"file".to_string(),
"stat".to_string(),
"du".to_string(),
"df".to_string(),
"free".to_string(),
"uptime".to_string(),
"whoami".to_string(),
"hostname".to_string(),
"uname".to_string(),
"date".to_string(),
"cal".to_string(),
"ps".to_string(),
"env".to_string(),
"printenv".to_string(),
"which".to_string(),
"whereis".to_string(),
"type".to_string(),
"git status".to_string(),
"git diff".to_string(),
"git log".to_string(),
"git show".to_string(),
"git branch".to_string(),
"git remote".to_string(),
"git tag".to_string(),
"git describe".to_string(),
"git rev-parse".to_string(),
"cargo tree".to_string(),
"cargo metadata".to_string(),
"cargo doc".to_string(),
"rustc --version".to_string(),
"cargo --version".to_string(),
]
}
impl Settings {
pub fn get_safe_commands(&self) -> Vec<String> {
self.safe_command_prefixes
.clone()
.unwrap_or_else(get_default_safe_commands)
}
pub fn get_denied_commands(&self) -> Vec<String> {
self.denied_command_prefixes.clone().unwrap_or_default()
}
pub fn get_url_for(&self, kind: ProviderKind) -> Option<&str> {
self.provider_urls.get(&kind).map(|s| s.as_str())
}
pub fn set_url_for(&mut self, kind: ProviderKind, url: String) {
self.provider_urls.insert(kind, url);
}
pub fn get_model_for(&self, kind: ProviderKind) -> Option<&str> {
self.provider_models.get(&kind).map(|s| s.as_str())
}
pub fn set_model_for(&mut self, kind: ProviderKind, model: String) {
self.provider_models.insert(kind, model);
}
pub fn get_current_model(&self) -> Option<&str> {
self.get_model_for(self.last_provider)
}
pub fn get_current_url(&self) -> Option<&str> {
self.get_url_for(self.last_provider)
}
pub fn effective_timeout_secs(&self) -> u64 {
match self.request_timeout_secs {
Some(secs) if secs > 0 => secs,
_ => timeout_default_for(self.last_provider),
}
}
pub fn effective_max_retries(&self) -> u32 {
self.request_max_retries
.unwrap_or(match self.last_provider {
ProviderKind::Ollama => 3,
_ => 0,
})
}
}
#[derive(Debug)]
pub enum SettingsError {
Io(std::io::Error),
Parse(serde_json::Error),
}
impl std::fmt::Display for SettingsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
SettingsError::Io(e) => write!(f, "I/O error: {}", e),
SettingsError::Parse(e) => write!(f, "parse error: {}", e),
}
}
}
impl std::error::Error for SettingsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
SettingsError::Io(e) => Some(e),
SettingsError::Parse(e) => Some(e),
}
}
}
impl From<std::io::Error> for SettingsError {
fn from(e: std::io::Error) -> Self {
SettingsError::Io(e)
}
}
impl From<serde_json::Error> for SettingsError {
fn from(e: serde_json::Error) -> Self {
SettingsError::Parse(e)
}
}
pub struct SettingsStore {
path: std::path::PathBuf,
}
impl SettingsStore {
pub fn default_path() -> Self {
Self::from_paths(&crate::paths::Paths::default())
}
pub fn from_paths(paths: &crate::paths::Paths) -> Self {
SettingsStore {
path: paths.settings_file(),
}
}
pub fn new(path: std::path::PathBuf) -> Self {
SettingsStore { path }
}
pub fn load(&self) -> Result<Settings, SettingsError> {
self.cleanup_stale_temp_files();
if !self.path.exists() {
return Ok(Settings::default());
}
let content = std::fs::read_to_string(&self.path)?;
let mut settings: Settings = serde_json::from_str(&content)?;
if let Ok(raw) = serde_json::from_str::<serde_json::Value>(&content)
&& let Some(obj) = raw.as_object()
&& !obj.contains_key("auto_accept_mode")
{
if let Some(val) = obj.get("auto_accept_all") {
if val.as_bool() == Some(true) {
settings.auto_accept_mode = AutoAcceptMode::All;
} else if val.as_bool() == Some(false) {
settings.auto_accept_mode = AutoAcceptMode::Off;
}
}
else if let Some(val) = obj.get("auto_accept_safe_commands")
&& val.as_bool() == Some(false)
{
settings.auto_accept_mode = AutoAcceptMode::Off;
}
}
if let Ok(raw) = serde_json::from_str::<serde_json::Value>(&content)
&& let Some(obj) = raw.as_object()
{
if settings.provider_models.is_empty()
&& let Some(model) = obj.get("last_model")
&& let Some(model_str) = model.as_str()
&& !model_str.is_empty()
{
settings
.provider_models
.insert(settings.last_provider, model_str.to_string());
}
if settings.provider_urls.is_empty()
&& let Some(url) = obj.get("last_provider_url")
&& let Some(url_str) = url.as_str()
&& !url_str.is_empty()
{
settings
.provider_urls
.insert(settings.last_provider, url_str.to_string());
}
if settings.request_timeout_secs == Some(0) {
settings.request_timeout_secs = None;
}
if settings.request_timeout_secs.is_none()
&& let Some(timeout) = obj.get("ollama_timeout_secs").and_then(|v| v.as_u64())
{
settings.request_timeout_secs = Some(timeout);
}
if settings.request_max_retries.is_none()
&& let Some(retries) = obj.get("ollama_max_retries").and_then(|v| v.as_u64())
{
settings.request_max_retries = Some(retries as u32);
}
}
Ok(settings)
}
fn cleanup_stale_temp_files(&self) {
let Some(dir) = self.path.parent() else {
return;
};
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let name = entry.file_name();
let name = name.to_string_lossy();
if name.starts_with(".settings.json.tmp.")
&& let Err(e) = std::fs::remove_file(entry.path())
{
tracing::debug!("Could not remove stale temp file {name}: {e}");
}
}
}
pub fn load_or_default(&self) -> Settings {
self.load().unwrap_or_else(|e| {
tracing::warn!("Failed to load settings: {e}. Using defaults.");
if self.path.exists() {
let backup = self.path.with_extension("json.corrupt");
if let Err(backup_err) = std::fs::rename(&self.path, &backup) {
tracing::warn!(
"Could not back up corrupt settings to {}: {backup_err}",
backup.display(),
);
} else {
tracing::warn!("Corrupt settings backed up to {}", backup.display(),);
}
}
Settings::default()
})
}
pub fn save(&self, settings: &Settings) -> Result<(), SettingsError> {
let dir = self.path.parent().ok_or_else(|| {
SettingsError::Io(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"settings path has no parent directory",
))
})?;
std::fs::create_dir_all(dir)?;
let json = serde_json::to_string_pretty(settings)?;
let tmp_name = format!(
".settings.json.tmp.{}.{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0),
);
let tmp_path = dir.join(&tmp_name);
{
let mut file = std::fs::File::create(&tmp_path)?;
std::io::Write::write_all(&mut file, json.as_bytes())?;
std::io::Write::flush(&mut file)?;
file.sync_all()?;
}
std::fs::rename(&tmp_path, &self.path)?;
Ok(())
}
pub fn path(&self) -> &std::path::Path {
&self.path
}
}
pub fn load_settings_from(paths: &crate::paths::Paths) -> Settings {
SettingsStore::from_paths(paths).load_or_default()
}
pub fn load_settings() -> Settings {
load_settings_from(&crate::paths::Paths::default())
}
pub fn save_settings_to(
paths: &crate::paths::Paths,
settings: &Settings,
) -> Result<(), SettingsError> {
SettingsStore::from_paths(paths).save(settings)
}
pub fn save_settings(settings: &Settings) {
if let Err(e) = save_settings_to(&crate::paths::Paths::default(), settings) {
tracing::warn!("Failed to save settings: {e}");
}
}
pub fn update_settings_from(
paths: &crate::paths::Paths,
mutate: impl FnOnce(&mut Settings),
) -> Settings {
let mut settings = load_settings_from(paths);
mutate(&mut settings);
if let Err(e) = save_settings_to(paths, &settings) {
tracing::warn!("Failed to save settings: {e}");
}
settings
}
pub fn resolve_project_md_files(settings: Option<&Settings>) -> Vec<String> {
if let Ok(env) = std::env::var("TINYHARNESS_MD_FILES") {
let files: Vec<String> = env
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if !files.is_empty() {
return files;
}
}
if let Some(s) = settings
&& let Some(ref configured) = s.project_md_files
&& !configured.is_empty()
{
return configured.clone();
}
crate::context::DEFAULT_PROJECT_MD_FILE_NAMES
.iter()
.map(|s| s.to_string())
.collect()
}
pub fn prompts_dir() -> PathBuf {
prompts_dir_for(&crate::paths::Paths::default())
}
pub fn prompts_dir_for(paths: &crate::paths::Paths) -> PathBuf {
paths.prompts_dir()
}
pub fn ensure_prompts_initialized_in(dir: &Path) -> PathBuf {
if !dir.exists() {
std::fs::create_dir_all(dir).ok();
}
{
let header_path = dir.join("header.md");
if !header_path.exists() {
let header_text = include_str!("../prompts/header.md");
if let Err(e) = std::fs::write(&header_path, header_text.trim()) {
tracing::warn!(
"Failed to write default header to {}: {e}",
header_path.display(),
);
}
}
}
let modes = [AgentMode::Casual, AgentMode::Planning, AgentMode::Agent];
for mode in &modes {
let file_path = dir.join(mode.prompts_filename());
if !file_path.exists() {
let default_text = mode.default_system_prompt();
if let Err(e) = std::fs::write(&file_path, default_text.trim()) {
tracing::warn!(
"Failed to write default prompt to {}: {e}",
file_path.display(),
);
}
}
}
dir.to_path_buf()
}
pub fn ensure_prompts_initialized() -> PathBuf {
ensure_prompts_initialized_for(&crate::paths::Paths::default())
}
pub fn ensure_prompts_initialized_for(paths: &crate::paths::Paths) -> PathBuf {
ensure_prompts_initialized_in(&paths.prompts_dir())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn load_settings_missing_fields_uses_defaults() {
let json = r#"{
"last_provider": "OpenAiCompat",
"last_provider_url": "http://localhost:8080/v1",
"last_model": "MiniMax-M3",
"preferred_mode": "Agent",
"openai_compat_api_key": "sk-test",
"request_timeout_secs": 5,
"request_max_retries": 3,
"show_thinking": true,
"context_limit": 256000,
"auto_accept_mode": "all",
"skip_health_check": true
}"#;
let settings: Settings =
serde_json::from_str(json).expect("missing fields should use defaults");
assert_eq!(settings.last_provider, ProviderKind::OpenAiCompat);
assert_eq!(settings.preferred_mode, AgentMode::Agent);
assert!(settings.skip_health_check);
}
#[test]
fn load_settings_empty_object_uses_all_defaults() {
let settings: Settings =
serde_json::from_str("{}").expect("empty object should use defaults");
assert_eq!(settings.last_provider, ProviderKind::Ollama);
assert_eq!(settings.preferred_mode, AgentMode::Casual);
assert!(!settings.skip_health_check);
}
#[test]
fn questions_enabled_defaults_to_true() {
let settings: Settings =
serde_json::from_str("{}").expect("empty object should use defaults");
assert!(settings.questions_enabled);
assert!(settings.auto_compact_enabled);
assert!(Settings::default().questions_enabled);
}
#[test]
fn questions_enabled_can_be_disabled_and_roundtrips() {
let store = SettingsStore::new(temp_settings_path());
let settings = Settings {
questions_enabled: false,
..Settings::default()
};
store.save(&settings).unwrap();
let loaded = store.load().unwrap();
assert!(!loaded.questions_enabled);
assert!(loaded.auto_compact_enabled);
let _ = std::fs::remove_dir_all(store.path().parent().unwrap());
}
#[test]
fn project_settings_override_questions_enabled() {
let global = Settings {
questions_enabled: true,
..Settings::default()
};
let merged = merge_settings(&global, None);
assert!(merged.questions_enabled);
assert_eq!(merged.questions_enabled_source, SettingSource::Default);
let project = ProjectSettings {
questions_enabled: Some(false),
..ProjectSettings::default()
};
let merged = merge_settings(&global, Some(&project));
assert!(!merged.questions_enabled);
assert_eq!(merged.questions_enabled_source, SettingSource::Project);
}
#[test]
fn project_settings_cannot_set_allowed_paths() {
let global = Settings {
allowed_paths: Some(vec!["/opt/data".to_string()]),
..Settings::default()
};
let project: ProjectSettings =
serde_json::from_str(r#"{"allowed_paths": ["/", "~"]}"#).unwrap();
let merged = merge_settings(&global, Some(&project));
assert_eq!(merged.allowed_paths, vec!["/opt/data".to_string()]);
assert_eq!(merged.allowed_paths_source, SettingSource::Global);
let project: ProjectSettings =
serde_json::from_str(r#"{"sandbox": {"backend": "off"}}"#).unwrap();
let merged = merge_settings(&global, Some(&project));
assert_eq!(merged.sandbox, global.sandbox);
assert_eq!(merged.sandbox_source, SettingSource::Global);
}
#[test]
fn project_settings_questions_absent_falls_back_to_global() {
let global = Settings {
questions_enabled: false,
..Settings::default()
};
let project = ProjectSettings::default();
let merged = merge_settings(&global, Some(&project));
assert!(!merged.questions_enabled);
assert_eq!(merged.questions_enabled_source, SettingSource::Default);
}
#[test]
fn merged_settings_produce_tool_availability() {
let global = Settings {
questions_enabled: false,
auto_compact_enabled: true,
..Settings::default()
};
let availability = merge_settings(&global, None).tool_availability();
assert!(!availability.question);
assert!(availability.auto_compact);
let global = Settings::default();
let availability = merge_settings(&global, None).tool_availability();
assert_eq!(availability, crate::tools::ToolAvailability::all());
}
#[test]
fn discover_project_settings_parses_questions_enabled() {
let tmp = tempfile::tempdir().unwrap();
let dir = tmp.path().join(".tinyharness");
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("config.json"), r#"{"questions_enabled": false}"#).unwrap();
let found = discover_project_settings(tmp.path()).expect("config should be discovered");
let settings = found.expect("config should parse");
assert_eq!(settings.questions_enabled, Some(false));
assert_eq!(settings.auto_compact_enabled, None);
}
#[test]
fn generate_project_config_template_includes_questions() {
let settings = Settings {
questions_enabled: false,
..Settings::default()
};
let template = generate_project_config_template(&settings);
assert_eq!(template.questions_enabled, Some(false));
assert_eq!(template.auto_compact_enabled, Some(true));
}
#[test]
fn auto_accept_mode_from_string() {
let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "all"}"#).unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "off"}"#).unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": "safe"}"#).unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Safe);
}
#[test]
fn auto_accept_mode_from_legacy_bool() {
let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": true}"#).unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
let settings: Settings = serde_json::from_str(r#"{"auto_accept_mode": false}"#).unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
}
#[test]
fn auto_accept_mode_from_legacy_all_field() {
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"auto_accept_all": true}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::All);
let _ = std::fs::remove_file(store.path());
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"auto_accept_all": false}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
let _ = std::fs::remove_file(store.path());
}
#[test]
fn auto_accept_mode_from_legacy_safe_commands_field() {
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"auto_accept_safe_commands": false}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
let _ = std::fs::remove_file(store.path());
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"auto_accept_safe_commands": true}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Safe);
let _ = std::fs::remove_file(store.path());
}
#[test]
fn auto_accept_mode_explicit_overrides_legacy() {
let settings: Settings =
serde_json::from_str(r#"{"auto_accept_mode": "off", "auto_accept_all": true}"#)
.unwrap();
assert_eq!(settings.auto_accept_mode, AutoAcceptMode::Off);
}
#[test]
fn migrate_legacy_last_model_and_url() {
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"last_provider": "Ollama", "last_model": "qwen2.5:7b", "last_provider_url": "http://localhost:11434"}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(
settings.get_model_for(ProviderKind::Ollama),
Some("qwen2.5:7b")
);
assert_eq!(
settings.get_url_for(ProviderKind::Ollama),
Some("http://localhost:11434")
);
let _ = std::fs::remove_file(store.path());
}
#[test]
fn migrate_legacy_fields_for_openai_compat() {
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"last_provider": "OpenAiCompat", "last_model": "gpt-4o", "last_provider_url": "https://api.openai.com/v1"}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(
settings.get_model_for(ProviderKind::OpenAiCompat),
Some("gpt-4o")
);
assert_eq!(
settings.get_url_for(ProviderKind::OpenAiCompat),
Some("https://api.openai.com/v1")
);
assert_eq!(settings.get_model_for(ProviderKind::Ollama), None);
let _ = std::fs::remove_file(store.path());
}
#[test]
fn per_provider_model_and_url_accessors() {
let mut settings = Settings::default();
settings.set_model_for(ProviderKind::Ollama, "qwen2.5:7b".to_string());
settings.set_model_for(ProviderKind::LlamaCpp, "llama-3.1-8b".to_string());
settings.set_url_for(ProviderKind::LlamaCpp, "http://localhost:8080".to_string());
assert_eq!(
settings.get_model_for(ProviderKind::Ollama),
Some("qwen2.5:7b")
);
assert_eq!(
settings.get_model_for(ProviderKind::LlamaCpp),
Some("llama-3.1-8b")
);
assert_eq!(settings.get_model_for(ProviderKind::Vllm), None);
assert_eq!(
settings.get_url_for(ProviderKind::LlamaCpp),
Some("http://localhost:8080")
);
assert_eq!(settings.get_url_for(ProviderKind::Ollama), None);
}
#[test]
fn get_current_model_and_url_use_last_provider() {
let mut settings = Settings {
last_provider: ProviderKind::OpenAiCompat,
..Settings::default()
};
settings.set_model_for(ProviderKind::OpenAiCompat, "gpt-4o".to_string());
settings.set_url_for(
ProviderKind::OpenAiCompat,
"https://api.openai.com/v1".to_string(),
);
assert_eq!(settings.get_current_model(), Some("gpt-4o"));
assert_eq!(
settings.get_current_url(),
Some("https://api.openai.com/v1")
);
}
fn temp_settings_path() -> std::path::PathBuf {
let mut dir = std::env::temp_dir();
dir.push(format!(
"tinyharness_test_{}_{}_{:?}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0),
std::thread::current().id()
));
std::fs::create_dir_all(&dir).unwrap();
dir.push("settings.json");
dir
}
#[test]
fn save_and_load_roundtrip() {
let store = SettingsStore::new(temp_settings_path());
let mut settings = Settings {
last_provider: ProviderKind::OpenAiCompat,
auto_accept_mode: AutoAcceptMode::All,
..Settings::default()
};
settings.set_model_for(ProviderKind::OpenAiCompat, "gpt-4o".to_string());
store.save(&settings).unwrap();
let loaded = store.load().unwrap();
assert_eq!(loaded.last_provider, ProviderKind::OpenAiCompat);
assert_eq!(
loaded.get_model_for(ProviderKind::OpenAiCompat),
Some("gpt-4o")
);
assert_eq!(loaded.auto_accept_mode, AutoAcceptMode::All);
let dir = store.path().parent().unwrap();
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn corrupt_settings_backed_up_and_defaults_returned() {
let store = SettingsStore::new(temp_settings_path());
let corrupt_json = "{ this is not valid json !!!";
std::fs::write(store.path(), corrupt_json).unwrap();
let settings = store.load_or_default();
assert_eq!(settings.last_provider, ProviderKind::Ollama);
assert_eq!(settings.preferred_mode, AgentMode::Casual);
assert!(!store.path().exists());
let backup = store.path().with_extension("json.corrupt");
assert!(backup.exists(), "corrupt settings should be backed up");
let backup_content = std::fs::read_to_string(&backup).unwrap();
assert_eq!(backup_content, corrupt_json);
let dir = store.path().parent().unwrap();
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn stale_temp_files_cleaned_up_on_load() {
let store = SettingsStore::new(temp_settings_path());
let dir = store.path().parent().unwrap();
let tmp1 = dir.join(".settings.json.tmp.12345.999999999");
let tmp2 = dir.join(".settings.json.tmp.67890.888888888");
std::fs::write(&tmp1, "stale data").unwrap();
std::fs::write(&tmp2, "more stale data").unwrap();
assert!(tmp1.exists());
assert!(tmp2.exists());
let _ = store.load();
assert!(!tmp1.exists(), "stale temp file should be removed");
assert!(!tmp2.exists(), "stale temp file should be removed");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn save_leaves_no_temp_files() {
let store = SettingsStore::new(temp_settings_path());
store.save(&Settings::default()).unwrap();
let dir = store.path().parent().unwrap();
let entries = std::fs::read_dir(dir).unwrap();
for entry in entries.flatten() {
let name = entry.file_name();
assert!(
!name.to_string_lossy().starts_with(".settings.json.tmp."),
"no temp files should remain after successful save"
);
}
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn multiple_saves_are_consistent() {
let store = SettingsStore::new(temp_settings_path());
for i in 0..10 {
let settings = Settings {
request_timeout_secs: Some(i),
..Settings::default()
};
store.save(&settings).unwrap();
}
let loaded = store.load().unwrap();
assert_eq!(loaded.request_timeout_secs, Some(9));
let dir = store.path().parent().unwrap();
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn migrate_legacy_ollama_timeout_and_retries() {
let store = SettingsStore::new(temp_settings_path());
let json =
r#"{"last_provider": "Ollama", "ollama_timeout_secs": 42, "ollama_max_retries": 7}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.request_timeout_secs, Some(42));
assert_eq!(settings.request_max_retries, Some(7));
let _ = std::fs::remove_file(store.path());
}
#[test]
fn migrate_legacy_timeout_does_not_override_new_fields() {
let store = SettingsStore::new(temp_settings_path());
let json = r#"{"last_provider": "Ollama", "ollama_timeout_secs": 42, "ollama_max_retries": 7, "request_timeout_secs": 99}"#;
std::fs::write(store.path(), json).unwrap();
let settings = store.load().unwrap();
assert_eq!(settings.request_timeout_secs, Some(99));
assert_eq!(settings.request_max_retries, Some(7));
let _ = std::fs::remove_file(store.path());
}
#[test]
fn effective_timeout_retries_defaults_per_provider() {
let mut settings = Settings {
last_provider: ProviderKind::Ollama,
..Settings::default()
};
assert_eq!(settings.effective_timeout_secs(), 5);
assert_eq!(settings.effective_max_retries(), 3);
settings.last_provider = ProviderKind::OpenAiCompat;
assert_eq!(settings.effective_timeout_secs(), 30);
assert_eq!(settings.effective_max_retries(), 0);
settings.last_provider = ProviderKind::Sockudo;
assert_eq!(settings.effective_timeout_secs(), 120);
assert_eq!(settings.effective_max_retries(), 0);
settings.request_timeout_secs = Some(0);
settings.last_provider = ProviderKind::OpenAiCompat;
assert_eq!(settings.effective_timeout_secs(), 30);
settings.last_provider = ProviderKind::Ollama;
assert_eq!(settings.effective_timeout_secs(), 5);
settings.request_timeout_secs = Some(60);
assert_eq!(settings.effective_timeout_secs(), 60);
settings.request_timeout_secs = Some(60);
settings.request_max_retries = Some(2);
assert_eq!(settings.effective_timeout_secs(), 60);
assert_eq!(settings.effective_max_retries(), 2);
}
}