vectrumcodePublic

Merge settings for every environment at once

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Browse Files

JjohannSocommitted 6 days ago2 parents 3d9f92e a3b190ecommit31037aa

Showing 20 changed files with 1325 additions and 156 deletions.

Merge commit — showing changes against the first parent.

+14−2README.mdView File

@@ -147,13 +147,25 @@ Gruvbox, Rosé Pine, Solarized and Dracula.
147	147	- Remote connections, like T3 Code's environments: turn on Allow remote connections on
148	148	one device, and paste its pairing code (address and key) under Settings → Connections on
149	149	another. The host's projects and threads appear in the sidebar tagged with its name; open,
150		- continue or start threads there and they run on the host. The connection is a WebSocket
151		- guarded by the key but not encrypted, so use it on trusted networks or over a VPN.
	150	+ continue or start threads there and they run on the host. The first time a device connects
	151	+ with settings that differ from yours, a dialog asks whether to give it your settings or
	152	+ leave its own as they are. The connection is a WebSocket guarded by the key but not
	153	+ encrypted, so use it on trusted networks or over a VPN.
152	154	- A settings view (Ctrl+, or Settings in the sidebar), laid out like T3 Code's: a
153	155	search field over the pages (press `/` to search, ↑/↓ and Enter to jump to a setting,
154	156	which scrolls into view and pulses), a "Settings / Page" breadcrumb, and every setting as
155	157	a row with its description, its control and, once changed, a button that resets it.
156	158	Restore device defaults on General lists what it will reset before it does.
	159	+ General, Integrations, Source Control and Storage open with T3 Code's "Applying settings
	160	+ for All projects across All environments": the settings that shape threads (new
	161	+ thread defaults, auto-settle, worktrees and their cleanup, branch naming, writing style,
	162	+ text generation, browser access) belong to the machine the threads run on, so you can edit
	163	+ this device's, one connected device's, or every connected device's at once. A Mixed tag
	164	+ shows where they disagree (hover for each one's value), and picking a value applies it to
	165	+ all of them; offline devices keep theirs. Pick a project to override settings for it on the
	166	+ selected devices: overridden rows say Override, and their reset button returns them to
	167	+ the environment's value. Device preferences, such as appearance and confirmations, ignore
	168	+ the selection.
157	169	- General: New threads (model and reasoning, permissions, workspace, submodules);
158	170	Organization (project grouping and order, auto-resume and snooze for usage-limited
159	171	threads, the Working section, auto-settling merged and inactive threads); Behavior

+20−1src/remote/mod.rsView File

@@ -8,7 +8,9 @@
8	8	//! [`ClientMessage::Hello`] with the key, gets the host's projects and
9	9	//! threads in [`ServerMessage::State`], subscribes to the threads it opens,
10	10	//! and receives each change as a [`ServerMessage::Thread`] carrying the
11		- //! transcript from the first item that changed.
	11	+ //! transcript from the first item that changed. The host also shares its
	12	+ //! environment settings in [`ServerMessage::Settings`], which clients can
	13	+ //! change with [`ClientMessage::UpdateSettings`].
12	14
13	15	pub mod client;
14	16	pub mod server;
@@ -20,6 +22,7 @@ use serde::{Deserialize, Serialize};
20	22	use crate::git::TurnChanges;
21	23	use crate::models::Provider;
22	24	use crate::session::{QueuedMessage, SavedItem};
	25	+ use crate::settings::SettingsPatch;
23	26	use crate::worktree::PullRequest;
24	27
25	28	/// The port a host listens on unless told otherwise.
@@ -165,6 +168,8 @@ pub enum ClientMessage {
165	168	text: String,
166	169	attachments: Vec<Upload>,
167	170	},
	171	+ /// Changes the host's environment settings or its projects' overrides.
	172	+ UpdateSettings { patch: SettingsPatch },
168	173	}
169	174
170	175	#[derive(Clone, Debug, Serialize, Deserialize)]
@@ -178,6 +183,9 @@ pub enum ServerMessage {
178	183	Thread { summary: ThreadSummary, detail: ThreadDetail, from: usize, len: usize, items: Vec<SavedItem> },
179	184	Created { reference: u64, thread: String },
180	185	Error { message: String },
	186	+ /// The host's environment settings and project overrides, sent on
	187	+ /// connecting and whenever they change. Older hosts don't send it.
	188	+ Settings { values: serde_json::Map<String, serde_json::Value> },
181	189	}
182	190
183	191	/// A new random key: 24 bytes, hex.
@@ -264,6 +272,17 @@ mod tests {
264	272	};
265	273	let text = serde_json::to_string(&message).unwrap();
266	274	assert_eq!(serde_json::from_str::<ClientMessage>(&text).unwrap(), message);
	275	+
	276	+ let patch: SettingsPatch = serde_json::from_str(r#"{"values": {"workspace": "worktree"}}"#).unwrap();
	277	+ let message = ClientMessage::UpdateSettings { patch };
	278	+ let text = serde_json::to_string(&message).unwrap();
	279	+ assert_eq!(serde_json::from_str::<ClientMessage>(&text).unwrap(), message);
	280	+ let values = crate::settings::Settings::default().environment_values();
	281	+ let text = serde_json::to_string(&ServerMessage::Settings { values: values.clone() }).unwrap();
	282	+ match serde_json::from_str::<ServerMessage>(&text).unwrap() {
	283	+ ServerMessage::Settings { values: received } => assert_eq!(received, values),
	284	+ _ => panic!("not settings"),
	285	+ }
267	286	}
268	287
269	288	#[::core::prelude::v1::test]

+11−7src/session.rsView File

@@ -720,7 +720,8 @@ impl Session {
720	720	permission_mode: self.permission_mode,
721	721	effort: self.reasoning.effort(),
722	722	resume: resume.clone(),
723		- browser_session: settings::get(\|settings\| settings.agent_browser).then(\|\| browser::session_name(&self.id)),
	723	+ browser_session: settings::get_for(&self.project, \|settings\| settings.agent_browser)
	724	+ .then(\|\| browser::session_name(&self.id)),
724	725	};
725	726	let process = match AgentProcess::spawn(&config, tx) {
726	727	Ok(process) => process,
@@ -1174,10 +1175,11 @@ impl Session {
1174	1175
1175	1176	/// Asks the text generation model for a title, in the background.
1176	1177	fn generate_title(&mut self, message: String, cx: &mut Context<Self>) {
1177		- if settings::get(\|settings\| settings.text_model.is_empty()) {
	1178	+ if settings::get_for(&self.project, \|settings\| settings.text_model.is_empty()) {
1178	1179	return;
1179	1180	}
1180		- let task = cx.background_executor().spawn(async move { crate::textgen::title(&message) });
	1181	+ let project = self.project.clone();
	1182	+ let task = cx.background_executor().spawn(async move { crate::textgen::title(&project, &message) });
1181	1183	cx.spawn(async move \|this, cx\| {
1182	1184	let Some(title) = task.await else { return };
1183	1185	let _ = this.update(cx, \|this, cx\| {
@@ -1270,15 +1272,16 @@ impl Session {
1270	1272	/// message, as Settings → Source Control → Worktree branch naming says.
1271	1273	/// The folder keeps its name.
1272	1274	fn name_branch(&mut self, worktree: &Worktree, message: String, cx: &mut Context<Self>) {
1273		- if settings::get(\|settings\| settings.text_model.is_empty()) \|\| message.trim().is_empty() {
	1275	+ if settings::get_for(&self.project, \|settings\| settings.text_model.is_empty()) \|\| message.trim().is_empty() {
1274	1276	return;
1275	1277	}
1276		- let (naming, prefix, instructions) = settings::get(\|settings\| {
	1278	+ let project = self.project.clone();
	1279	+ let (naming, prefix, instructions) = settings::get_for(&self.project, \|settings\| {
1277	1280	(settings.branch_naming, settings.branch_prefix.clone(), settings.branch_instructions.clone())
1278	1281	});
1279	1282	let worktree = worktree.clone();
1280	1283	let task = cx.background_executor().spawn(async move {
1281		- let suggestion = crate::textgen::branch_name(&message, naming, &instructions)?;
	1284	+ let suggestion = crate::textgen::branch_name(&project, &message, naming, &instructions)?;
1282	1285	let name = worktree::branch_from_suggestion(&suggestion, naming, &prefix);
1283	1286	worktree::rename_branch(&worktree, &name, naming != BranchNaming::Custom).ok()
1284	1287	});
@@ -1303,7 +1306,8 @@ impl Session {
1303	1306	}
1304	1307	self.regenerating_title = true;
1305	1308	cx.notify();
1306		- let task = cx.background_executor().spawn(async move { crate::textgen::title(&message) });
	1309	+ let project = self.project.clone();
	1310	+ let task = cx.background_executor().spawn(async move { crate::textgen::title(&project, &message) });
1307	1311	cx.spawn(async move \|this, cx\| {
1308	1312	let title = task.await;
1309	1313	let _ = this.update(cx, \|this, cx\| {

+226−4src/settings.rsView File

@@ -2,7 +2,10 @@
2	2	//! `$XDG_CONFIG_HOME/vectrum-code/settings.json` and edited in the settings
3	3	//! view. They're read once and cached, so rendering can consult them freely.
4	4
5		- use std::{path::PathBuf, sync::Mutex};
	5	+ use std::{
	6	+ path::{Path, PathBuf},
	7	+ sync::Mutex,
	8	+ };
6	9
7	10	use serde::{Deserialize, Serialize};
8	11
@@ -325,6 +328,9 @@ pub struct RemoteHost {
325	328	pub address: String,
326	329	pub key: String,
327	330	pub enabled: bool,
	331	+ /// Whether the user was asked, on first connecting, to give the device
	332	+ /// this one's environment settings.
	333	+ pub settings_offered: bool,
328	334	}
329	335
330	336	impl RemoteHost {
@@ -515,6 +521,10 @@ pub struct Settings {
515	521	/// Other devices' apps this one connects to.
516	522	pub remotes: Vec<RemoteHost>,
517	523
	524	+ /// Settings a project overrides, by project path: field names from
	525	+ /// [`PROJECT_KEYS`] and their values.
	526	+ pub project_overrides: std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
	527	+
518	528	/// Superseded by `providers`; read once to carry an old path override over.
519	529	#[serde(skip_serializing)]
520	530	claude_bin: Option<String>,
@@ -607,6 +617,7 @@ impl Default for Settings {
607	617	remote_port: crate::remote::DEFAULT_PORT,
608	618	remote_key: String::new(),
609	619	remotes: Vec::new(),
	620	+ project_overrides: std::collections::BTreeMap::new(),
610	621	claude_bin: None,
611	622	pi_bin: None,
612	623	colorway: None,
@@ -617,7 +628,7 @@ impl Default for Settings {
617	628	impl Settings {
618	629	/// Makes sure there's at least one instance of each kind, carrying old
619	630	/// binary overrides over, and turns an old colorway into a theme mode.
620		- fn normalize(&mut self) {
	631	+ pub(crate) fn normalize(&mut self) {
621	632	if let Some(colorway) = self.colorway.take() {
622	633	self.theme_mode = match colorway.as_str() {
623	634	"bone" => ThemeMode::Light,
@@ -708,6 +719,151 @@ impl Settings {
708	719	pub fn instance(&self, id: &str) -> Option<&ProviderInstance> {
709	720	self.providers.iter().find(\|instance\| instance.id == id)
710	721	}
	722	+
	723	+ /// These settings as one project sees them: with its overrides.
	724	+ pub fn for_project(&self, project: &Path) -> Settings {
	725	+ match self.project_overrides.get(&project.display().to_string()) {
	726	+ Some(overrides) => with_values(self, overrides),
	727	+ None => self.clone(),
	728	+ }
	729	+ }
	730	+
	731	+ /// The settings an environment shares with the devices connected to it:
	732	+ /// [`ENVIRONMENT_KEYS`] and the project overrides.
	733	+ pub fn environment_values(&self) -> serde_json::Map<String, serde_json::Value> {
	734	+ let serde_json::Value::Object(mut all) = serde_json::to_value(self).unwrap_or_default() else {
	735	+ return Default::default();
	736	+ };
	737	+ all.retain(\|key, _\| ENVIRONMENT_KEYS.contains(&key.as_str()) \|\| key == "project_overrides");
	738	+ all
	739	+ }
	740	+
	741	+ /// Applies a change from the settings view or another device, keeping
	742	+ /// to the fields a patch may touch.
	743	+ pub fn apply_patch(&mut self, patch: &SettingsPatch) {
	744	+ let values: serde_json::Map<_, _> = patch
	745	+ .values
	746	+ .iter()
	747	+ .filter(\|(key, _)\| ENVIRONMENT_KEYS.contains(&key.as_str()))
	748	+ .map(\|(key, value)\| (key.clone(), value.clone()))
	749	+ .collect();
	750	+ if !values.is_empty() {
	751	+ *self = with_values(self, &values);
	752	+ }
	753	+ for (project, changes) in &patch.projects {
	754	+ let overrides = self.project_overrides.entry(project.clone()).or_default();
	755	+ for (key, value) in changes {
	756	+ if !PROJECT_KEYS.contains(&key.as_str()) {
	757	+ continue;
	758	+ }
	759	+ match value {
	760	+ serde_json::Value::Null => overrides.remove(key),
	761	+ value => overrides.insert(key.clone(), value.clone()),
	762	+ };
	763	+ }
	764	+ if overrides.is_empty() {
	765	+ self.project_overrides.remove(project);
	766	+ }
	767	+ }
	768	+ self.normalize();
	769	+ }
	770	+ }
	771	+
	772	+ /// Settings an environment keeps for itself, as T3 Code's server settings:
	773	+ /// they shape the threads that run there, so they're edited on the machine
	774	+ /// the threads run on, one environment or all of them at once. Everything
	775	+ /// else is a preference of the device it was set on.
	776	+ pub const ENVIRONMENT_KEYS: &[&str] = &[
	777	+ "default_model",
	778	+ "default_reasoning",
	779	+ "default_access",
	780	+ "workspace",
	781	+ "submodules",
	782	+ "start_from_origin",
	783	+ "branch_naming",
	784	+ "branch_prefix",
	785	+ "branch_instructions",
	786	+ "writing_style",
	787	+ "writing_instructions",
	788	+ "follow_pr_templates",
	789	+ "worktrees_dir",
	790	+ "cleanup_deleted_worktrees",
	791	+ "cleanup_inactive_worktrees",
	792	+ "cleanup_merged_worktrees",
	793	+ "cleanup_unchanged_worktrees",
	794	+ "text_model",
	795	+ "text_reasoning",
	796	+ "auto_resume_limited",
	797	+ "snooze_limited",
	798	+ "auto_settle_merged",
	799	+ "auto_settle_inactive",
	800	+ "inactive_days",
	801	+ "continue_after_restart",
	802	+ "update_checks",
	803	+ "agent_browser",
	804	+ ];
	805	+
	806	+ /// The environment settings a project can override.
	807	+ pub const PROJECT_KEYS: &[&str] = &[
	808	+ "default_model",
	809	+ "default_reasoning",
	810	+ "default_access",
	811	+ "workspace",
	812	+ "submodules",
	813	+ "start_from_origin",
	814	+ "branch_naming",
	815	+ "branch_prefix",
	816	+ "branch_instructions",
	817	+ "writing_style",
	818	+ "writing_instructions",
	819	+ "follow_pr_templates",
	820	+ "cleanup_inactive_worktrees",
	821	+ "cleanup_merged_worktrees",
	822	+ "cleanup_unchanged_worktrees",
	823	+ "text_model",
	824	+ "text_reasoning",
	825	+ "auto_settle_merged",
	826	+ "auto_settle_inactive",
	827	+ "inactive_days",
	828	+ "agent_browser",
	829	+ ];
	830	+
	831	+ /// A change to an environment's settings: new values for its own fields,
	832	+ /// and per project path, overrides to set or (as `null`) to drop.
	833	+ #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
	834	+ #[serde(default)]
	835	+ pub struct SettingsPatch {
	836	+ pub values: serde_json::Map<String, serde_json::Value>,
	837	+ pub projects: std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
	838	+ }
	839	+
	840	+ impl SettingsPatch {
	841	+ pub fn is_empty(&self) -> bool {
	842	+ self.values.is_empty() && self.projects.values().all(serde_json::Map::is_empty)
	843	+ }
	844	+ }
	845	+
	846	+ /// `settings` with some fields replaced, by name.
	847	+ pub fn with_values(settings: &Settings, values: &serde_json::Map<String, serde_json::Value>) -> Settings {
	848	+ let mut all = serde_json::to_value(settings).unwrap_or_default();
	849	+ if let serde_json::Value::Object(all) = &mut all {
	850	+ for (key, value) in values {
	851	+ all.insert(key.clone(), value.clone());
	852	+ }
	853	+ }
	854	+ let mut merged: Settings = serde_json::from_value(all).unwrap_or_else(\|_\| settings.clone());
	855	+ merged.normalize();
	856	+ merged
	857	+ }
	858	+
	859	+ /// The fields that differ between `before` and `after`, with their new values.
	860	+ pub fn changed_values(before: &Settings, after: &Settings) -> serde_json::Map<String, serde_json::Value> {
	861	+ let (serde_json::Value::Object(before), serde_json::Value::Object(after)) =
	862	+ (serde_json::to_value(before).unwrap_or_default(), serde_json::to_value(after).unwrap_or_default())
	863	+ else {
	864	+ return Default::default();
	865	+ };
	866	+ after.into_iter().filter(\|(key, value)\| before.get(key) != Some(value)).collect()
711	867	}
712	868
713	869	static CACHE: Mutex<Option<Settings>> = Mutex::new(None);
@@ -749,6 +905,22 @@ pub fn load() -> Settings {
749	905	get(Settings::clone)
750	906	}
751	907
	908	+ /// Reads one value as a project sees it, with its overrides.
	909	+ pub fn get_for<T>(project: &Path, read: impl FnOnce(&Settings) -> T) -> T {
	910	+ let mut cache = CACHE.lock().unwrap_or_else(\|poisoned\| poisoned.into_inner());
	911	+ let settings = cache.get_or_insert_with(read_file);
	912	+ match settings.project_overrides.contains_key(&project.display().to_string()) {
	913	+ true => read(&settings.for_project(project)),
	914	+ false => read(settings),
	915	+ }
	916	+ }
	917	+
	918	+ /// Applies a change to this environment's settings, from the settings view
	919	+ /// or a connected device, and writes them back.
	920	+ pub fn apply(patch: &SettingsPatch) {
	921	+ update(\|settings\| settings.apply_patch(patch));
	922	+ }
	923	+
752	924	/// The configured agents, enabled or not.
753	925	pub fn instances() -> Vec<ProviderInstance> {
754	926	get(\|settings\| settings.providers.clone())
@@ -779,8 +951,8 @@ pub fn update(edit: impl FnOnce(&mut Settings)) {
779	951	}
780	952	}
781	953
782		- /// Puts everything but favorites and model preferences, agents, usage hubs
783		- /// and remote connections back to its default.
	954	+ /// Puts everything but favorites and model preferences, agents, usage hubs,
	955	+ /// remote connections and project overrides back to its default.
784	956	pub fn restore_defaults() {
785	957	update(\|settings\| {
786	958	let kept = Settings {
@@ -793,6 +965,7 @@ pub fn restore_defaults() {
793	965	remote_port: settings.remote_port,
794	966	remote_key: std::mem::take(&mut settings.remote_key),
795	967	remotes: std::mem::take(&mut settings.remotes),
	968	+ project_overrides: std::mem::take(&mut settings.project_overrides),
796	969	..Settings::default()
797	970	};
798	971	*settings = kept;
@@ -905,6 +1078,55 @@ mod tests {
905	1078	assert_eq!((fresh.send_shortcut, fresh.legacy_sidebar), (SendShortcut::Enter, false));
906	1079	}
907	1080
	1081	+ #[test]
	1082	+ fn patches_keep_to_environment_fields() {
	1083	+ let mut settings = parse("{}");
	1084	+ let patch: super::SettingsPatch = serde_json::from_str(
	1085	+ r#"{"values": {"workspace": "worktree", "remote_key": "stolen", "chat_width": "wide"},
	1086	+ "projects": {"/src/app": {"submodules": "skip", "worktrees_dir": "/tmp"}}}"#,
	1087	+ )
	1088	+ .unwrap();
	1089	+ settings.apply_patch(&patch);
	1090	+ assert_eq!(settings.workspace, super::WorkspaceMode::Worktree);
	1091	+ assert!(settings.remote_key.is_empty());
	1092	+ assert_eq!(settings.chat_width, super::ChatWidth::Comfortable);
	1093	+ let project = std::path::Path::new("/src/app");
	1094	+ assert_eq!(settings.for_project(project).submodules, super::Submodules::Skip);
	1095	+ assert_eq!(settings.for_project(project).worktrees_dir, "");
	1096	+ assert_eq!(settings.submodules, super::Submodules::Recursive);
	1097	+ // Null drops an override, and a project without any is forgotten.
	1098	+ let inherit: super::SettingsPatch =
	1099	+ serde_json::from_str(r#"{"projects": {"/src/app": {"submodules": null}}}"#).unwrap();
	1100	+ settings.apply_patch(&inherit);
	1101	+ assert!(settings.project_overrides.is_empty());
	1102	+ let values = settings.environment_values();
	1103	+ assert!(values.contains_key("workspace") && values.contains_key("project_overrides"));
	1104	+ assert!(!values.contains_key("remote_key") && !values.contains_key("theme_mode"));
	1105	+ }
	1106	+
	1107	+ #[test]
	1108	+ fn scoped_keys_are_fields() {
	1109	+ let all = serde_json::to_value(parse("{}")).unwrap();
	1110	+ for key in super::ENVIRONMENT_KEYS {
	1111	+ assert!(all.get(key).is_some(), "{key} isn't a setting");
	1112	+ }
	1113	+ for key in super::PROJECT_KEYS {
	1114	+ assert!(super::ENVIRONMENT_KEYS.contains(key), "{key} isn't an environment setting");
	1115	+ }
	1116	+ }
	1117	+
	1118	+ #[test]
	1119	+ fn changes_are_named_by_field() {
	1120	+ let before = parse("{}");
	1121	+ let mut after = before.clone();
	1122	+ after.inactive_days = 9;
	1123	+ after.cleanup_inactive_worktrees = Some(4);
	1124	+ let changed = super::changed_values(&before, &after);
	1125	+ assert_eq!(changed.len(), 2);
	1126	+ assert_eq!(changed["inactive_days"], 9);
	1127	+ assert_eq!(super::with_values(&before, &changed).cleanup_inactive_worktrees, Some(4));
	1128	+ }
	1129	+
908	1130	#[test]
909	1131	fn restore_lists_what_changed() {
910	1132	let mut settings = parse("{}");

+14−11src/textgen.rsView File

@@ -2,7 +2,7 @@
2	2	//! under Settings → General → Text generation. Each request is a one-off,
3	3	//! tool-less agent run. Everything here blocks; call it from a background task.
4	4
5		- use std::process::Stdio;
	5	+ use std::{path::Path, process::Stdio};
6	6
7	7	use crate::claude::{Effort, base_command};
8	8	use crate::models::{Provider, split_key};
@@ -14,16 +14,16 @@ sentence case, no quotes, no trailing period) for a conversation that starts wit
14	14
15	15	/// A title for a thread that starts with `message`, or `None` when text
16	16	/// generation is off or fails.
17		- pub fn title(message: &str) -> Option<String> {
	17	+ pub fn title(project: &Path, message: &str) -> Option<String> {
18	18	let message: String = message.chars().take(2_000).collect();
19		- clean_title(&generate(&format!("{TITLE_PROMPT}\n\n<message>\n{message}\n</message>"))?)
	19	+ clean_title(&generate(project, &format!("{TITLE_PROMPT}\n\n<message>\n{message}\n</message>"))?)
20	20	}
21	21
22	22	/// A branch name for a worktree whose thread starts with `message`, as
23	23	/// T3 Code asks for one: a fragment the configured prefix goes in front of,
24	24	/// one with a semantic prefix (`feat/…`), or a whole name following the
25	25	/// user's instructions. `None` when text generation is off or fails.
26		- pub fn branch_name(message: &str, naming: BranchNaming, instructions: &str) -> Option<String> {
	26	+ pub fn branch_name(project: &Path, message: &str, naming: BranchNaming, instructions: &str) -> Option<String> {
27	27	let mut rules = vec![
28	28	"Branch should describe the requested work from the user message.",
29	29	"Return a valid Git branch name without spaces.",
@@ -51,14 +51,14 @@ pub fn branch_name(message: &str, naming: BranchNaming, instructions: &str) -> O
51	51	if naming == BranchNaming::Custom && !instructions.trim().is_empty() {
52	52	prompt.push_str(&format!("\n\nAdditional instructions:\n{}", instructions.trim()));
53	53	}
54		- let value = json_reply(&generate(&prompt)?)?;
	54	+ let value = json_reply(&generate(project, &prompt)?)?;
55	55	let branch = value.get("branch")?.as_str()?.trim().to_string();
56	56	(!branch.is_empty()).then_some(branch)
57	57	}
58	58
59	59	/// A commit message for what's staged, as T3 Code asks for one: an
60	60	/// imperative subject of at most 72 characters and an optional body.
61		- pub fn commit_message(branch: Option<&str>, staged_summary: &str, staged_patch: &str, instructions: &str) -> Option<String> {
	61	+ pub fn commit_message(project: &Path, branch: Option<&str>, staged_summary: &str, staged_patch: &str, instructions: &str) -> Option<String> {
62	62	let mut prompt = [
63	63	"You write concise git commit messages.",
64	64	"Return a JSON object with keys: subject, body.",
@@ -77,7 +77,7 @@ pub fn commit_message(branch: Option<&str>, staged_summary: &str, staged_patch:
77	77	]
78	78	.join("\n");
79	79	push_instructions(&mut prompt, instructions);
80		- let value = json_reply(&generate(&prompt)?)?;
	80	+ let value = json_reply(&generate(project, &prompt)?)?;
81	81	let subject = value.get("subject")?.as_str()?.trim().trim_end_matches('.').to_string();
82	82	if subject.is_empty() {
83	83	return None;
@@ -88,6 +88,7 @@ pub fn commit_message(branch: Option<&str>, staged_summary: &str, staged_patch:
88	88
89	89	/// A pull request's title and body for a branch, as T3 Code asks for them.
90	90	pub fn pull_request_content(
	91	+ project: &Path,
91	92	base: &str,
92	93	head: &str,
93	94	commits: &str,
@@ -139,7 +140,7 @@ pub fn pull_request_content(
139	140	&limit(diff_patch, 40_000),
140	141	]
141	142	.join("\n");
142		- let value = json_reply(&generate(&prompt)?)?;
	143	+ let value = json_reply(&generate(project, &prompt)?)?;
143	144	let title = value.get("title")?.as_str()?.trim().to_string();
144	145	let body = value.get("body").and_then(\|body\| body.as_str()).unwrap_or_default().to_string();
145	146	(!title.is_empty()).then_some((title, body))
@@ -169,9 +170,11 @@ fn limit(text: &str, max: usize) -> String {
169	170	cut
170	171	}
171	172
172		- /// Runs `prompt` through the text generation model and returns its reply.
173		- fn generate(prompt: &str) -> Option<String> {
174		- let (key, reasoning) = settings::get(\|settings\| (settings.text_model.clone(), settings.text_reasoning.clone()));
	173	+ /// Runs `prompt` through the project's text generation model and returns
	174	+ /// its reply.
	175	+ fn generate(project: &Path, prompt: &str) -> Option<String> {
	176	+ let (key, reasoning) =
	177	+ settings::get_for(project, \|settings\| (settings.text_model.clone(), settings.text_reasoning.clone()));
175	178	let (instance_id, model) = split_key(&key)?;
176	179	let kind = settings::get(\|settings\| settings.instance(instance_id).map(\|instance\| instance.kind))
177	180	.or_else(\|\| Provider::from_key(instance_id))?;

+10−0src/ui/metal.rsView File

@@ -713,6 +713,8 @@ pub struct MetalButton {
713	713	size: CapSize,
714	714	icon: Option<Icon>,
715	715	icon_color: Option<Hsla>,
	716	+ /// Drawn where the icon goes, such as a project's badge.
	717	+ leading: Option<AnyElement>,
716	718	label: Option<SharedString>,
717	719	caret: bool,
718	720	stretch: bool,
@@ -730,6 +732,7 @@ impl MetalButton {
730	732	size: CapSize::Regular,
731	733	icon: None,
732	734	icon_color: None,
	735	+ leading: None,
733	736	label: None,
734	737	caret: false,
735	738	stretch: false,
@@ -772,6 +775,12 @@ impl MetalButton {
772	775	self
773	776	}
774	777
	778	+ /// Something other than an icon before the label.
	779	+ pub fn leading(mut self, element: impl IntoElement) -> Self {
	780	+ self.leading = Some(element.into_any_element());
	781	+ self
	782	+ }
	783	+
775	784	pub fn icon_color(mut self, color: Hsla) -> Self {
776	785	self.icon_color = Some(color);
777	786	self
@@ -895,6 +904,7 @@ impl RenderOnce for MetalButton {
895	904	None => icon,
896	905	})
897	906	})
	907	+ .children(self.leading)
898	908	.when_some(self.label, \|this, label\| {
899	909	this.child(
900	910	div()

+4−4src/ui/settings/appearance.rsView File

@@ -48,7 +48,7 @@ impl SettingsView {
48	48	SettingRow::new("Diff colors")
49	49	.id("diff-color-scheme")
50	50	.description("Choose colors for additions and deletions, including change counts.")
51		- .reset(reset(&view, \|s\| s.diff_colors, \|s, colors\| s.diff_colors = colors))
	51	+ .reset(reset(&view, cx, \|s\| s.diff_colors, \|s, colors\| s.diff_colors = colors))
52	52	.control(h_flex().gap(px(8.)).child(diff_dots).child(choice_of(
53	53	"diff-colors",
54	54	saved.diff_colors,
@@ -68,7 +68,7 @@ impl SettingsView {
68	68	SettingRow::new("Composer context")
69	69	.id("composer-context")
70	70	.description("Keep branch and worktree controls below the composer after a thread starts.")
71		- .reset(reset(&view, \|s\| s.composer_context, \|s, on\| s.composer_context = on))
	71	+ .reset(reset(&view, cx, \|s\| s.composer_context, \|s, on\| s.composer_context = on))
72	72	.control(switch("composer-context", saved.composer_context, &view, p, \|settings, on\| {
73	73	settings.composer_context = on
74	74	})),
@@ -77,7 +77,7 @@ impl SettingsView {
77	77	SettingRow::new("Chat width")
78	78	.id("chat-width")
79	79	.description("Set how wide messages and the composer can grow on large screens.")
80		- .reset(reset(&view, \|s\| s.chat_width, \|s, width\| s.chat_width = width))
	80	+ .reset(reset(&view, cx, \|s\| s.chat_width, \|s, width\| s.chat_width = width))
81	81	.control(choice("chat-width", saved.chat_width, CHAT_WIDTHS, &view, \|settings, width\| {
82	82	settings.chat_width = width
83	83	})),
@@ -86,7 +86,7 @@ impl SettingsView {
86	86	SettingRow::new("Thread cards")
87	87	.id("thread-cards")
88	88	.description("Comfortable cards show the project, branch and agent. Compact ones fit a thread on one line.")
89		- .reset(reset(&view, \|s\| s.compact_threads, \|s, compact\| s.compact_threads = compact))
	89	+ .reset(reset(&view, cx, \|s\| s.compact_threads, \|s, compact\| s.compact_threads = compact))
90	90	.control(choice("thread-density", saved.compact_threads, &[(false, "Comfortable"), (true, "Compact")], &view, {
91	91	\|settings, compact\| settings.compact_threads = compact
92	92	})),

+1−1src/ui/settings/connections.rsView File

@@ -71,7 +71,7 @@ impl SettingsView {
71	71	let name = value(&state.connect_name);
72	72	let ids: Vec<String> = settings::get(\|settings\| settings.remotes.iter().map(\|host\| host.id.clone()).collect());
73	73	let id = (1..).map(\|n\| format!("remote-{n}")).find(\|id\| !ids.contains(id)).unwrap_or_default();
74		- settings::update(\|settings\| settings.remotes.push(RemoteHost { id, name, address, key, enabled: true }));
	74	+ settings::update(\|settings\| settings.remotes.push(RemoteHost { id, name, address, key, enabled: true, settings_offered: false }));
75	75	for input in [&state.connect_name, &state.connect_address, &state.connect_key] {
76	76	input.update(cx, \|input, cx\| input.set_value("", window, cx));
77	77	}

+42−42src/ui/settings/general.rsView File

@@ -15,7 +15,7 @@ use crate::claude::PermissionMode;
15	15	use crate::models::Catalog;
16	16	use crate::session::Reasoning;
17	17	use crate::settings::{
18		- self, BackgroundActivity, FollowUp, ProjectOrder, QuitShortcut, SendShortcut, Streaming, Submodules,
	18	+ BackgroundActivity, FollowUp, ProjectOrder, QuitShortcut, SendShortcut, Streaming, Submodules,
19	19	TimeFormat, WorkspaceMode,
20	20	};
21	21	use crate::ui::metal::{self, MetalButton};
@@ -74,7 +74,7 @@ fn permission_description(mode: PermissionMode) -> &'static str {
74	74	impl SettingsView {
75	75	pub(super) fn render_general(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Vec<AnyElement> {
76	76	let p = metal::palette(cx);
77		- let saved = settings::load();
	77	+ let saved = super::scope::shown_settings(cx);
78	78	let view = cx.weak_entity();
79	79	let row = SettingRow::new;
80	80
@@ -82,7 +82,7 @@ impl SettingsView {
82	82	let model_pick = {
83	83	let view = view.clone();
84	84	move \|key: Option<String>, window: &mut Window, cx: &mut App\| {
85		- edit(&view, window, cx, move \|settings\| settings.default_model = key)
	85	+ edit(&view, window, cx, move \|settings\| settings.default_model = key.clone())
86	86	}
87	87	};
88	88	let reasoning_pick = {
@@ -113,7 +113,7 @@ impl SettingsView {
113	113	.id("default-model")
114	114	.description("Default model for new threads. Projects can override it.")
115	115	.when(saved.default_model.is_none(), \|row\| row.status("Automatic"))
116		- .reset(reset(&view, \|s\| (s.default_model.clone(), s.default_reasoning.clone()), \|s, (model, reasoning)\| {
	116	+ .reset(reset(&view, cx, \|s\| (s.default_model.clone(), s.default_reasoning.clone()), \|s, (model, reasoning)\| {
117	117	s.default_model = model;
118	118	s.default_reasoning = reasoning;
119	119	}))
@@ -133,7 +133,7 @@ impl SettingsView {
133	133	row("Permissions")
134	134	.id("default-permissions")
135	135	.description("Default permissions for new threads. Pi and jcode threads always run with full access.")
136		- .reset(reset(&view, \|s\| s.default_access.clone(), \|s, access\| s.default_access = access))
	136	+ .reset(reset(&view, cx, \|s\| s.default_access.clone(), \|s, access\| s.default_access = access))
137	137	.control(rich_choice("default-access", current_access, permissions, &view, \|settings, mode\| {
138	138	settings.default_access = mode.map(\|mode: PermissionMode\| mode.as_cli().to_string())
139	139	})),
@@ -142,14 +142,14 @@ impl SettingsView {
142	142	row("Workspace")
143	143	.id("new-threads")
144	144	.description("Where new threads start. The start screen can switch it for each thread.")
145		- .reset(reset(&view, \|s\| s.workspace, \|s, mode\| s.workspace = mode))
	145	+ .reset(reset(&view, cx, \|s\| s.workspace, \|s, mode\| s.workspace = mode))
146	146	.control(choice("workspace", saved.workspace, WORKSPACES, &view, \|settings, mode\| settings.workspace = mode)),
147	147	)
148	148	.row(
149	149	row("Submodules")
150	150	.id("worktree-submodules")
151	151	.description("How new worktrees populate git submodules.")
152		- .reset(reset(&view, \|s\| s.submodules, \|s, mode\| s.submodules = mode))
	152	+ .reset(reset(&view, cx, \|s\| s.submodules, \|s, mode\| s.submodules = mode))
153	153	.control(choice("submodules", saved.submodules, SUBMODULES, &view, \|settings, mode\| settings.submodules = mode)),
154	154	)
155	155	.render(cx);
@@ -160,7 +160,7 @@ impl SettingsView {
160	160	row("Project grouping")
161	161	.id("project-grouping")
162	162	.description("Combine matching repositories across environments.")
163		- .reset(reset(&view, \|s\| s.project_grouping, \|s, grouping\| s.project_grouping = grouping))
	163	+ .reset(reset(&view, cx, \|s\| s.project_grouping, \|s, grouping\| s.project_grouping = grouping))
164	164	// On groups by repository, as T3 Code's switch does; off keeps every project apart.
165	165	.control(switch(
166	166	"project-grouping",
@@ -180,7 +180,7 @@ impl SettingsView {
180	180	row("Project order")
181	181	.id("project-order")
182	182	.description("Order of projects in the sidebar project picker and command palette.")
183		- .reset(reset(&view, \|s\| s.project_order, \|s, order\| s.project_order = order))
	183	+ .reset(reset(&view, cx, \|s\| s.project_order, \|s, order\| s.project_order = order))
184	184	.control(choice("project-order", saved.project_order, PROJECT_ORDERS, &view, \|settings, order\| {
185	185	settings.project_order = order
186	186	})),
@@ -191,7 +191,7 @@ impl SettingsView {
191	191	.description(
192	192	"Resume usage-limit stops at the reported reset time. Each thread can cancel its scheduled continuation.",
193	193	)
194		- .reset(reset(&view, \|s\| s.auto_resume_limited, \|s, on\| s.auto_resume_limited = on))
	194	+ .reset(reset(&view, cx, \|s\| s.auto_resume_limited, \|s, on\| s.auto_resume_limited = on))
195	195	.control(switch("auto-resume", saved.auto_resume_limited, &view, p, \|settings, on\| {
196	196	settings.auto_resume_limited = on
197	197	})),
@@ -202,7 +202,7 @@ impl SettingsView {
202	202	.description(
203	203	"Snooze usage-limit stops until the reported reset time. Combine with auto-resume to continue when they wake.",
204	204	)
205		- .reset(reset(&view, \|s\| s.snooze_limited, \|s, on\| s.snooze_limited = on))
	205	+ .reset(reset(&view, cx, \|s\| s.snooze_limited, \|s, on\| s.snooze_limited = on))
206	206	.control(switch("snooze-limited", saved.snooze_limited, &view, p, \|settings, on\| settings.snooze_limited = on)),
207	207	)
208	208	.row(
@@ -211,7 +211,7 @@ impl SettingsView {
211	211	.description(
212	212	"Fold working and monitoring threads into a Working section. They return to the top of the inbox when they need you.",
213	213	)
214		- .reset(reset(&view, \|s\| s.working_section, \|s, on\| s.working_section = on))
	214	+ .reset(reset(&view, cx, \|s\| s.working_section, \|s, on\| s.working_section = on))
215	215	.control(switch("working-section", saved.working_section, &view, p, \|settings, on\| {
216	216	settings.working_section = on
217	217	})),
@@ -220,7 +220,7 @@ impl SettingsView {
220	220	row("Auto-settle merged threads")
221	221	.id("auto-settle-merged-threads")
222	222	.description("Settle a thread when its pull request merges. Closed pull requests still settle automatically.")
223		- .reset(reset(&view, \|s\| s.auto_settle_merged, \|s, on\| s.auto_settle_merged = on))
	223	+ .reset(reset(&view, cx, \|s\| s.auto_settle_merged, \|s, on\| s.auto_settle_merged = on))
224	224	.control(switch("auto-settle-merged", saved.auto_settle_merged, &view, p, \|settings, on\| {
225	225	settings.auto_settle_merged = on
226	226	})),
@@ -229,7 +229,7 @@ impl SettingsView {
229	229	row("Auto-settle inactive threads")
230	230	.id("auto-settle-inactive-threads")
231	231	.description("Sidebar threads with no activity for this long settle automatically.")
232		- .reset(reset(&view, \|s\| (s.auto_settle_inactive, s.inactive_days), \|s, (on, days)\| {
	232	+ .reset(reset(&view, cx, \|s\| (s.auto_settle_inactive, s.inactive_days), \|s, (on, days)\| {
233	233	s.auto_settle_inactive = on;
234	234	s.inactive_days = days;
235	235	}))
@@ -286,7 +286,7 @@ impl SettingsView {
286	286	} else {
287	287	"Notifications need notify-send (libnotify), which isn't installed. Sound only is still available."
288	288	})
289		- .reset(reset(&view, \|s\| (s.notify, s.notify_sound), \|s, (notify, sound)\| {
	289	+ .reset(reset(&view, cx, \|s\| (s.notify, s.notify_sound), \|s, (notify, sound)\| {
290	290	s.notify = notify;
291	291	s.notify_sound = sound;
292	292	}))
@@ -309,7 +309,7 @@ impl SettingsView {
309	309	row("Time format")
310	310	.id("time-format")
311	311	.description("System default follows your OS clock preference.")
312		- .reset(reset(&view, \|s\| s.time_format, \|s, format\| s.time_format = format))
	312	+ .reset(reset(&view, cx, \|s\| s.time_format, \|s, format\| s.time_format = format))
313	313	.control(choice("time-format", saved.time_format, TIME_FORMATS, &view, \|settings, format\| {
314	314	settings.time_format = format
315	315	})),
@@ -318,7 +318,7 @@ impl SettingsView {
318	318	row("Response streaming")
319	319	.id("response-streaming")
320	320	.description(streaming_description)
321		- .reset(reset(&view, \|s\| s.streaming, \|s, streaming\| s.streaming = streaming))
	321	+ .reset(reset(&view, cx, \|s\| s.streaming, \|s, streaming\| s.streaming = streaming))
322	322	.control(choice("streaming", saved.streaming, STREAMING, &view, \|settings, streaming\| {
323	323	settings.streaming = streaming
324	324	})),
@@ -327,21 +327,21 @@ impl SettingsView {
327	327	row("Fold finished turns")
328	328	.id("fold-turns")
329	329	.description("Tuck a finished turn's tool calls and interim messages into one \u{201c}Worked for\u{201d} row.")
330		- .reset(reset(&view, \|s\| s.fold_turns, \|s, on\| s.fold_turns = on))
	330	+ .reset(reset(&view, cx, \|s\| s.fold_turns, \|s, on\| s.fold_turns = on))
331	331	.control(switch("fold-turns", saved.fold_turns, &view, p, \|settings, on\| settings.fold_turns = on)),
332	332	)
333	333	.row(
334	334	row("Show costs")
335	335	.id("show-costs")
336	336	.description("What each turn and thread cost, in the transcript and the project panel.")
337		- .reset(reset(&view, \|s\| s.show_costs, \|s, on\| s.show_costs = on))
	337	+ .reset(reset(&view, cx, \|s\| s.show_costs, \|s, on\| s.show_costs = on))
338	338	.control(switch("show-costs", saved.show_costs, &view, p, \|settings, on\| settings.show_costs = on)),
339	339	)
340	340	.row(
341	341	row("Hide whitespace changes")
342	342	.id("hide-whitespace-changes")
343	343	.description("Set whether the diff panel ignores whitespace-only edits by default.")
344		- .reset(reset(&view, \|s\| s.hide_whitespace, \|s, on\| s.hide_whitespace = on))
	344	+ .reset(reset(&view, cx, \|s\| s.hide_whitespace, \|s, on\| s.hide_whitespace = on))
345	345	.control(switch("hide-whitespace", saved.hide_whitespace, &view, p, \|settings, on\| {
346	346	settings.hide_whitespace = on
347	347	})),
@@ -350,7 +350,7 @@ impl SettingsView {
350	350	row("Default diff file state")
351	351	.id("default-diff-file-state")
352	352	.description("Start with files expanded or collapsed when opening diffs.")
353		- .reset(reset(&view, \|s\| s.diff_collapsed, \|s, collapsed\| s.diff_collapsed = collapsed))
	353	+ .reset(reset(&view, cx, \|s\| s.diff_collapsed, \|s, collapsed\| s.diff_collapsed = collapsed))
354	354	.control(choice("diff-collapsed", saved.diff_collapsed, DIFF_STATES, &view, \|settings, collapsed\| {
355	355	settings.diff_collapsed = collapsed
356	356	})),
@@ -359,7 +359,7 @@ impl SettingsView {
359	359	row("Diff layout")
360	360	.id("diff-layout")
361	361	.description("Show diffs stacked or side by side. The toggle in the diff toolbar changes this too.")
362		- .reset(reset(&view, \|s\| s.diff_side_by_side, \|s, split\| s.diff_side_by_side = split))
	362	+ .reset(reset(&view, cx, \|s\| s.diff_side_by_side, \|s, split\| s.diff_side_by_side = split))
363	363	.control(choice("diff-layout", saved.diff_side_by_side, DIFF_LAYOUTS, &view, \|settings, split\| {
364	364	settings.diff_side_by_side = split
365	365	})),
@@ -368,7 +368,7 @@ impl SettingsView {
368	368	row("Proactive panels")
369	369	.id("proactive-panels")
370	370	.description("Open Changes for edits to at least 3 files or 50 lines.")
371		- .reset(reset(&view, \|s\| s.proactive_panels, \|s, on\| s.proactive_panels = on))
	371	+ .reset(reset(&view, cx, \|s\| s.proactive_panels, \|s, on\| s.proactive_panels = on))
372	372	.control(switch("proactive-panels", saved.proactive_panels, &view, p, \|settings, on\| {
373	373	settings.proactive_panels = on
374	374	})),
@@ -377,14 +377,14 @@ impl SettingsView {
377	377	row("Show skills in slash menu")
378	378	.id("skills-in-slash-menu")
379	379	.description("Also include skills in the / command menu. Skills always appear when you type $.")
380		- .reset(reset(&view, \|s\| s.slash_skills, \|s, on\| s.slash_skills = on))
	380	+ .reset(reset(&view, cx, \|s\| s.slash_skills, \|s, on\| s.slash_skills = on))
381	381	.control(switch("slash-skills", saved.slash_skills, &view, p, \|settings, on\| settings.slash_skills = on)),
382	382	)
383	383	.row(
384	384	row("Rich text composer")
385	385	.id("composer-rich-text")
386	386	.description("Show formatted Markdown as you type.")
387		- .reset(reset(&view, \|s\| s.rich_composer, \|s, on\| s.rich_composer = on))
	387	+ .reset(reset(&view, cx, \|s\| s.rich_composer, \|s, on\| s.rich_composer = on))
388	388	.control(switch("rich-composer", saved.rich_composer, &view, p, \|settings, on\| settings.rich_composer = on)),
389	389	)
390	390	.row(
@@ -393,7 +393,7 @@ impl SettingsView {
393	393	.description(
394	394	"Rest the composer of an existing thread into a single line when you scroll the conversation. Focus the composer or start typing to expand it again.",
395	395	)
396		- .reset(reset(&view, \|s\| s.collapse_composer, \|s, on\| s.collapse_composer = on))
	396	+ .reset(reset(&view, cx, \|s\| s.collapse_composer, \|s, on\| s.collapse_composer = on))
397	397	.control(switch("collapse-composer", saved.collapse_composer, &view, p, \|settings, on\| {
398	398	settings.collapse_composer = on
399	399	})),
@@ -402,7 +402,7 @@ impl SettingsView {
402	402	row("Send shortcut")
403	403	.id("send-shortcut")
404	404	.description("Choose when Enter sends a prompt or inserts a new line")
405		- .reset(reset(&view, \|s\| s.send_shortcut, \|s, shortcut\| s.send_shortcut = shortcut))
	405	+ .reset(reset(&view, cx, \|s\| s.send_shortcut, \|s, shortcut\| s.send_shortcut = shortcut))
406	406	.control(choice("send-shortcut", saved.send_shortcut, SEND_SHORTCUTS, &view, \|settings, shortcut\| {
407	407	settings.send_shortcut = shortcut
408	408	})),
@@ -411,7 +411,7 @@ impl SettingsView {
411	411	row("Follow-up behavior")
412	412	.id("follow-up-behavior")
413	413	.description(follow_up_description)
414		- .reset(reset(&view, \|s\| s.follow_up, \|s, follow_up\| s.follow_up = follow_up))
	414	+ .reset(reset(&view, cx, \|s\| s.follow_up, \|s, follow_up\| s.follow_up = follow_up))
415	415	.control(choice("follow-up", saved.follow_up, FOLLOW_UPS, &view, \|settings, follow_up\| {
416	416	settings.follow_up = follow_up
417	417	})),
@@ -420,7 +420,7 @@ impl SettingsView {
420	420	row("Provider update checks")
421	421	.id("provider-update-checks")
422	422	.description("Check installed provider CLIs for newer available versions.")
423		- .reset(reset(&view, \|s\| s.update_checks, \|s, on\| s.update_checks = on))
	423	+ .reset(reset(&view, cx, \|s\| s.update_checks, \|s, on\| s.update_checks = on))
424	424	.control(switch_then(
425	425	"update-checks",
426	426	saved.update_checks,
@@ -434,7 +434,7 @@ impl SettingsView {
434	434	row("Continue threads after restarts")
435	435	.id("continue-threads-after-server-update")
436	436	.description("Automatically resume interrupted threads after an update, crash, or machine restart.")
437		- .reset(reset(&view, \|s\| s.continue_after_restart, \|s, on\| s.continue_after_restart = on))
	437	+ .reset(reset(&view, cx, \|s\| s.continue_after_restart, \|s, on\| s.continue_after_restart = on))
438	438	.control(switch("continue-after-restart", saved.continue_after_restart, &view, p, \|settings, on\| {
439	439	settings.continue_after_restart = on
440	440	})),
@@ -443,7 +443,7 @@ impl SettingsView {
443	443	row("Background activity")
444	444	.id("background-activity")
445	445	.description(background_description)
446		- .reset(reset(&view, \|s\| s.background_activity, \|s, activity\| s.background_activity = activity))
	446	+ .reset(reset(&view, cx, \|s\| s.background_activity, \|s, activity\| s.background_activity = activity))
447	447	.control(choice("background-activity", saved.background_activity, BACKGROUND, &view, \|settings, activity\| {
448	448	settings.background_activity = activity
449	449	})),
@@ -456,7 +456,7 @@ impl SettingsView {
456	456	row("Start from origin")
457	457	.id("start-from-origin")
458	458	.description("Creates the worktree from the latest matching branch on origin instead of your local branch.")
459		- .reset(reset(&view, \|s\| s.start_from_origin, \|s, on\| s.start_from_origin = on))
	459	+ .reset(reset(&view, cx, \|s\| s.start_from_origin, \|s, on\| s.start_from_origin = on))
460	460	.control(switch("start-from-origin", saved.start_from_origin, &view, p, \|settings, on\| {
461	461	settings.start_from_origin = on
462	462	})),
@@ -465,7 +465,7 @@ impl SettingsView {
465	465	row("Add project starts in")
466	466	.id("add-project-starts-in")
467	467	.description("Leave empty to use \u{201c}~/\u{201d} when the Add Project browser opens.")
468		- .reset(reset(&view, \|s\| s.add_project_dir.clone(), \|s, dir\| s.add_project_dir = dir))
	468	+ .reset(reset(&view, cx, \|s\| s.add_project_dir.clone(), \|s, dir\| s.add_project_dir = dir))
469	469	.control(text_field(&self.add_project_dir, 288., window, cx)),
470	470	)
471	471	.render(cx);
@@ -476,28 +476,28 @@ impl SettingsView {
476	476	row("Unpin confirmation")
477	477	.id("unpin-confirmation")
478	478	.description("Ask before unpinning a thread from the pinned section.")
479		- .reset(reset(&view, \|s\| s.confirm_unpin, \|s, on\| s.confirm_unpin = on))
	479	+ .reset(reset(&view, cx, \|s\| s.confirm_unpin, \|s, on\| s.confirm_unpin = on))
480	480	.control(switch("confirm-unpin", saved.confirm_unpin, &view, p, \|settings, on\| settings.confirm_unpin = on)),
481	481	)
482	482	.row(
483	483	row("Archive confirmation")
484	484	.id("archive-confirmation")
485	485	.description("Require a second click on the inline archive action before a thread is archived.")
486		- .reset(reset(&view, \|s\| s.confirm_settle, \|s, on\| s.confirm_settle = on))
	486	+ .reset(reset(&view, cx, \|s\| s.confirm_settle, \|s, on\| s.confirm_settle = on))
487	487	.control(switch("confirm-settle", saved.confirm_settle, &view, p, \|settings, on\| settings.confirm_settle = on)),
488	488	)
489	489	.row(
490	490	row("Delete confirmation")
491	491	.id("delete-confirmation")
492	492	.description("Ask before deleting a thread and its chat history.")
493		- .reset(reset(&view, \|s\| s.confirm_delete, \|s, on\| s.confirm_delete = on))
	493	+ .reset(reset(&view, cx, \|s\| s.confirm_delete, \|s, on\| s.confirm_delete = on))
494	494	.control(switch("confirm-delete", saved.confirm_delete, &view, p, \|settings, on\| settings.confirm_delete = on)),
495	495	)
496	496	.row(
497	497	row("Quit shortcut")
498	498	.id("quit-confirmation")
499	499	.description("Hold mode also quits on two quick presses.")
500		- .reset(reset(&view, \|s\| s.quit_shortcut, \|s, shortcut\| s.quit_shortcut = shortcut))
	500	+ .reset(reset(&view, cx, \|s\| s.quit_shortcut, \|s, shortcut\| s.quit_shortcut = shortcut))
501	501	.control(choice("quit-shortcut", saved.quit_shortcut, QUIT_SHORTCUTS, &view, \|settings, shortcut\| {
502	502	settings.quit_shortcut = shortcut
503	503	})),
@@ -508,7 +508,7 @@ impl SettingsView {
508	508	let text_pick = {
509	509	let view = view.clone();
510	510	move \|key: Option<String>, window: &mut Window, cx: &mut App\| {
511		- edit(&view, window, cx, move \|settings\| settings.text_model = key.unwrap_or_default())
	511	+ edit(&view, window, cx, move \|settings\| settings.text_model = key.clone().unwrap_or_default())
512	512	}
513	513	};
514	514	let text_reasoning_pick = {
@@ -525,7 +525,7 @@ impl SettingsView {
525	525	row("Text generation model")
526	526	.id("text-generation-model")
527	527	.description("Used for thread titles and worktree branch names. Off keeps the first line of the first message.")
528		- .reset(reset(&view, \|s\| (s.text_model.clone(), s.text_reasoning.clone()), \|s, (model, reasoning)\| {
	528	+ .reset(reset(&view, cx, \|s\| (s.text_model.clone(), s.text_reasoning.clone()), \|s, (model, reasoning)\| {
529	529	s.text_model = model;
530	530	s.text_reasoning = reasoning;
531	531	}))
@@ -590,19 +590,19 @@ impl SettingsView {
590	590	row("Plan mode (legacy)")
591	591	.id("legacy-plan-mode")
592	592	.description("Restore Build/Plan, /plan, /default, and Shift+Tab. Off uses build mode.")
593		- .reset(reset(&view, \|s\| s.plan_mode, \|s, on\| s.plan_mode = on))
	593	+ .reset(reset(&view, cx, \|s\| s.plan_mode, \|s, on\| s.plan_mode = on))
594	594	.control(switch("plan-mode", saved.plan_mode, &view, p, \|settings, on\| settings.plan_mode = on))
595	595	.into_any_element(),
596	596	row("Context window indicator (legacy)")
597	597	.id("legacy-context-window-indicator")
598	598	.description("Shows context window usage as a circular indicator in the composer.")
599		- .reset(reset(&view, \|s\| s.context_meter, \|s, on\| s.context_meter = on))
	599	+ .reset(reset(&view, cx, \|s\| s.context_meter, \|s, on\| s.context_meter = on))
600	600	.control(switch("context-meter", saved.context_meter, &view, p, \|settings, on\| settings.context_meter = on))
601	601	.into_any_element(),
602	602	row("Sidebar (legacy)")
603	603	.id("legacy-sidebar")
604	604	.description("Restore per-project thread trees instead of the default flat sidebar.")
605		- .reset(reset(&view, \|s\| s.legacy_sidebar, \|s, on\| s.legacy_sidebar = on))
	605	+ .reset(reset(&view, cx, \|s\| s.legacy_sidebar, \|s, on\| s.legacy_sidebar = on))
606	606	.control(switch("legacy-sidebar", saved.legacy_sidebar, &view, p, \|settings, on\| settings.legacy_sidebar = on))
607	607	.into_any_element(),
608	608	],

+2−3src/ui/settings/integrations.rsView File

@@ -8,7 +8,6 @@ use gpui_kit::*;
8	8	use super::SettingsView;
9	9	use super::widgets::{Section, SettingRow, reset, switch};
10	10	use crate::browser;
11		- use crate::settings;
12	11	use crate::ui::icons::Lucide;
13	12	use crate::ui::metal::{self, MetalButton};
14	13
@@ -16,7 +15,7 @@ impl SettingsView {
16	15	pub(super) fn render_integrations(&mut self, cx: &mut Context<Self>) -> Vec<AnyElement> {
17	16	let p = metal::palette(cx);
18	17	let view = cx.weak_entity();
19		- let on = settings::get(\|settings\| settings.agent_browser);
	18	+ let on = super::scope::shown_settings(cx).agent_browser;
20	19	let installed = browser::find_binary().is_some();
21	20
22	21	let browser = Section::new("Browser")
@@ -29,7 +28,7 @@ impl SettingsView {
29	28	row.status("agent-browser isn't installed: npm install -g agent-browser && agent-browser install")
30	29	})
31	30	.dimmed(!installed)
32		- .reset(reset(&view, \|s\| s.agent_browser, \|s, on\| s.agent_browser = on))
	31	+ .reset(reset(&view, cx, \|s\| s.agent_browser, \|s, on\| s.agent_browser = on))
33	32	.control(switch("agent-browser", on, &view, p, \|settings, on\| settings.agent_browser = on)),
34	33	)
35	34	.render(cx);

+25−17src/ui/settings/mod.rsView File

@@ -12,6 +12,7 @@ mod integrations;
12	12	mod keybindings;
13	13	mod licenses;
14	14	mod providers;
	15	+ mod scope;
15	16	mod search;
16	17	mod source_control;
17	18	mod storage;
@@ -35,6 +36,7 @@ use crate::ui::metal::{self, MetalButton, MetalStyled as _};
35	36	use crate::ui::usage::{HubSettings, UsageView};
36	37	use crate::ui::workspace::{SHEET_INSET, SHEET_RADIUS, SIDEBAR_WIDTH, Workspace};
37	38
	39	+ pub(crate) use scope::row_titles;
38	40	pub(crate) use widgets::{card, radio, section, section_title};
39	41	use widgets::{EXPANDED_WIDTH, PAGE_PADDING, READABLE_WIDTH, Target, WIDE_WIDTH};
40	42
@@ -149,6 +151,10 @@ pub struct SettingsView {
149	151	source_control: source_control::SourceControlState,
150	152	diagnostics: diagnostics::DiagnosticsState,
151	153	licenses: licenses::LicensesState,
	154	+ /// Which environments and project the environment settings edit.
	155	+ scope: scope::Scope,
	156	+ /// The text settings last put into their fields, for the selection.
	157	+ scoped_inputs: Option<[String; 4]>,
152	158	focus_handle: FocusHandle,
153	159	_subscriptions: Vec<Subscription>,
154	160	}
@@ -203,18 +209,16 @@ impl SettingsView {
203	209	cx.subscribe_in(&writing_instructions, window, \|this, input, event: &InputEvent, window, cx\| {
204	210	if matches!(event, InputEvent::Blur) {
205	211	let value = input.read(cx).value().trim().to_string();
206		- if settings::get(\|settings\| settings.writing_instructions != value) {
207		- settings::update(\|settings\| settings.writing_instructions = value);
208		- this.changed(window, cx);
	212	+ if this.compute_shown(cx).settings.writing_instructions != value {
	213	+ this.apply(\|settings\| settings.writing_instructions = value.clone(), window, cx);
209	214	}
210	215	}
211	216	}),
212	217	cx.subscribe_in(&branch_instructions, window, \|this, input, event: &InputEvent, window, cx\| {
213	218	if matches!(event, InputEvent::Blur) {
214	219	let value = input.read(cx).value().trim().to_string();
215		- if settings::get(\|settings\| settings.branch_instructions != value) {
216		- settings::update(\|settings\| settings.branch_instructions = value);
217		- this.changed(window, cx);
	220	+ if this.compute_shown(cx).settings.branch_instructions != value {
	221	+ this.apply(\|settings\| settings.branch_instructions = value.clone(), window, cx);
218	222	}
219	223	}
220	224	}),
@@ -242,6 +246,8 @@ impl SettingsView {
242	246	source_control: source_control::SourceControlState::default(),
243	247	diagnostics: diagnostics::DiagnosticsState::default(),
244	248	licenses: licenses::LicensesState::new(window, cx),
	249	+ scope: scope::Scope::default(),
	250	+ scoped_inputs: None,
245	251	focus_handle: cx.focus_handle(),
246	252	_subscriptions: subscriptions,
247	253	};
@@ -275,12 +281,8 @@ impl SettingsView {
275	281	input.update(cx, \|input, cx\| input.set_value(value, window, cx));
276	282	};
277	283	set(&self.add_project_dir, saved.add_project_dir.clone(), window, cx);
278		- set(&self.branch_prefix, saved.branch_prefix.clone(), window, cx);
279		- set(&self.worktrees_dir, saved.worktrees_dir.clone(), window, cx);
280		- self.branch_instructions
281		- .update(cx, \|input, cx\| input.set_value(saved.branch_instructions.clone(), window, cx));
282		- self.writing_instructions
283		- .update(cx, \|input, cx\| input.set_value(saved.writing_instructions.clone(), window, cx));
	284	+ self.scoped_inputs = None;
	285	+ self.sync_scoped_inputs(window, cx);
284	286	self.connections.reload(&saved, window, cx);
285	287	self.reload_provider_form(window, cx);
286	288	}
@@ -736,7 +738,8 @@ impl SettingsView {
736	738	}
737	739	}
738	740
739		- /// Saves a text field when it loses focus or Enter is pressed, if it changed.
	741	+ /// Saves a text field when it loses focus or Enter is pressed, if it changed,
	742	+ /// to the selected environments when it's one of their settings.
740	743	fn commit_on_blur(
741	744	input: &Entity<InputState>,
742	745	window: &mut Window,
@@ -747,9 +750,8 @@ fn commit_on_blur(
747	750	cx.subscribe_in(input, window, move \|this, input, event: &InputEvent, window, cx\| {
748	751	if matches!(event, InputEvent::Blur \| InputEvent::PressEnter { .. }) {
749	752	let value = input.read(cx).value().trim().to_string();
750		- if settings::get(\|settings\| get(settings) != value) {
751		- settings::update(\|settings\| set(settings, value));
752		- this.changed(window, cx);
	753	+ if get(&this.compute_shown(cx).settings) != value {
	754	+ this.apply(\|settings\| set(settings, value.clone()), window, cx);
753	755	}
754	756	}
755	757	})
@@ -764,7 +766,13 @@ impl Focusable for SettingsView {
764	766	impl Render for SettingsView {
765	767	fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
766	768	let p = metal::palette(cx);
767		- let page = self.render_page(window, cx);
	769	+ let shown = self.compute_shown(cx);
	770	+ cx.set_global(shown);
	771	+ self.sync_scoped_inputs(window, cx);
	772	+ let mut page = self.render_page(window, cx);
	773	+ if self.page_scoped() {
	774	+ page.insert(0, self.render_scope_sentence(cx));
	775	+ }
768	776	let width = self.page.width();
769	777	let wizard = self.render_add_provider(window, cx);
770	778	h_flex()

+1−1src/ui/settings/providers.rsView File

@@ -658,7 +658,7 @@ impl SettingsView {
658	658	.id("provider-health-check-interval")
659	659	.page_width(WIDE_WIDTH)
660	660	.description("Refresh provider status, versions, and models in the background. Set to 0 to disable.")
661		- .reset(reset(&view, \|s\| s.health_check_secs, \|s, secs\| s.health_check_secs = secs))
	661	+ .reset(reset(&view, cx, \|s\| s.health_check_secs, \|s, secs\| s.health_check_secs = secs))
662	662	.control(stepper("health-interval", health, 30, (0, 86_400), "seconds", &view, p, \|settings, secs\| {
663	663	settings.health_check_secs = secs
664	664	})),

+641−0src/ui/settings/scope.rsaddedView File

++ //! T3 Code's settings scope: "Applying settings for <project> across
++ //! <environment>" at the top of the pages with environment settings. The
++ //! environment picker edits this device, one connected device, or all of
++ //! them at once; the project picker edits a project's overrides on them.
++ //! Rows that are a preference of this device ignore the selection.
++ //!
++ //! Each render works out what the selection shows ([`Shown`]): the values
++ //! the controls display, where the selected environments disagree, and
++ //! which settings the project overrides. Rows read it by their anchor, and
++ //! every change is turned into a [`SettingsPatch`] for each environment.
++ use std::{
++     collections::{BTreeMap, HashMap, HashSet},
++     path::PathBuf,
++     rc::Rc,
++ };
++ use gpui_kit::component::{
++     Icon, h_flex,
++     menu::{DropdownMenu as _, PopupMenuItem},
++     v_flex,
++ };
++ use gpui_kit::prelude::FluentBuilder as _;
++ use gpui_kit::*;
++ use super::SettingsView;
++ use crate::settings::{self, ENVIRONMENT_KEYS, PROJECT_KEYS, Settings, SettingsPatch};
++ use crate::ui::icons::Lucide;
++ use crate::ui::metal::{self, MetalButton};
++ use crate::ui::workspace::{self, SettingsEnvironment};
++ /// The rows that edit environment settings, by anchor: their title and the
++ /// settings they show.
++ pub(crate) const SCOPED_ROWS: &[(&str, &str, &[&str])] = &[
++     ("default-model", "Default model", &["default_model", "default_reasoning"]),
++     ("default-permissions", "Permissions", &["default_access"]),
++     ("new-threads", "Workspace", &["workspace"]),
++     ("worktree-submodules", "Submodules", &["submodules"]),
++     ("auto-resume-limited-threads", "Auto-resume limited threads", &["auto_resume_limited"]),
++     ("snooze-limited-threads", "Snooze limited threads", &["snooze_limited"]),
++     ("auto-settle-merged-threads", "Auto-settle merged threads", &["auto_settle_merged"]),
++     ("auto-settle-inactive-threads", "Auto-settle inactive threads", &["auto_settle_inactive"]),
++     ("days-before-auto-settle", "Days of inactivity before auto-settle", &["inactive_days"]),
++     ("provider-update-checks", "Provider update checks", &["update_checks"]),
++     ("continue-threads-after-server-update", "Continue threads after restarts", &["continue_after_restart"]),
++     ("start-from-origin", "Start from origin", &["start_from_origin"]),
++     ("text-generation-model", "Text generation model", &["text_model", "text_reasoning"]),
++     ("agent-browser-access", "Agent browser access", &["agent_browser"]),
++     ("worktree-branch-naming", "Worktree branch naming", &["branch_naming"]),
++     ("branch-prefix", "Branch prefix", &["branch_prefix"]),
++     ("branch-naming-instructions", "Branch naming instructions", &["branch_instructions"]),
++     ("source-control-writing-style", "Source control writing style", &["writing_style", "writing_instructions"]),
++     ("follow-change-request-templates", "Follow change request templates", &["follow_pr_templates"]),
++     ("storage-worktrees-location", "Worktree location", &["worktrees_dir"]),
++     ("storage-worktrees-deleted", "Delete worktrees with deleted threads", &["cleanup_deleted_worktrees"]),
++     ("storage-worktrees-inactive", "Delete inactive worktrees", &["cleanup_inactive_worktrees"]),
++     ("storage-worktrees-merged", "Delete merged worktrees", &["cleanup_merged_worktrees"]),
++     ("storage-worktrees-unchanged", "Delete unchanged worktrees", &["cleanup_unchanged_worktrees"]),
++ ];
++ /// What the open settings page shows: the selection's values where it
++ /// applies, this device's elsewhere.
++ pub(crate) fn shown_settings(cx: &App) -> Settings {
++     cx.try_global::<Shown>().map(|shown| shown.settings.clone()).unwrap_or_else(settings::load)
++ }
++ fn row_keys(id: &str) -> Option<&'static [&'static str]> {
++     SCOPED_ROWS.iter().find(|(row, _, _)| *row == id).map(|(_, _, keys)| *keys)
++ }
++ /// The titles of the rows showing any of `keys`, for saying what differs.
++ pub(crate) fn row_titles(keys: &[String]) -> Vec<&'static str> {
++     SCOPED_ROWS
++         .iter()
++         .filter(|(_, _, row_keys)| row_keys.iter().any(|key| keys.iter().any(|candidate| candidate == key)))
++         .map(|(_, title, _)| *title)
++         .collect()
++ }
++ /// Which environments a change goes to.
++ #[derive(Clone, Debug, Default, PartialEq, Eq)]
++ pub(crate) enum EnvironmentPick {
++     #[default]
++     All,
++     /// One environment: this device (`None`) or a connection, by id.
++     One(Option<String>),
++ }
++ /// The settings view's selection, kept as pages change.
++ #[derive(Clone, Debug, Default, PartialEq, Eq)]
++ pub(crate) struct Scope {
++     pub environment: EnvironmentPick,
++     /// A project by name: the same project on every environment.
++     pub project: Option<String>,
++ }
++ /// One place a change is written: an environment, and the project's path
++ /// there when a project is picked.
++ #[derive(Clone, Debug)]
++ pub(crate) struct WriteTarget {
++     pub environment: Option<String>,
++     pub name: String,
++     pub project: Option<PathBuf>,
++     /// This device's preferences with the target's settings, as an edit
++     /// there starts from.
++     pub settings: Settings,
++ }
++ /// What the open page shows for the selection. Rows find it as a global.
++ pub(crate) struct Shown {
++     pub view: WeakEntity<SettingsView>,
++     /// The page edits environment settings, so rows apply the selection.
++     pub scoped: bool,
++     /// This device's preferences, with the first selected environment's
++     /// settings (and the project's overrides) in place.
++     pub settings: Settings,
++     pub project: Option<String>,
++     pub targets: Vec<WriteTarget>,
++     /// Why environment settings can't change right now.
++     pub locked: Option<SharedString>,
++     /// Settings the selected environments disagree on: each one's value.
++     pub mixed: HashMap<String, Vec<(String, String)>>,
++     /// Settings the picked project overrides on any selected environment.
++     pub overridden: HashSet<String>,
++ }
++ impl Global for Shown {}
++ impl Shown {
++     pub fn compute(
++         view: WeakEntity<SettingsView>,
++         scope: &Scope,
++         scoped: bool,
++         environments: &[SettingsEnvironment],
++     ) -> Self {
++         let local = settings::load();
++         let mut shown = Shown {
++             view,
++             scoped,
++             settings: local.clone(),
++             project: scope.project.clone(),
++             targets: vec![WriteTarget { environment: None, name: String::new(), project: None, settings: local.clone() }],
++             locked: None,
++             mixed: HashMap::new(),
++             overridden: HashSet::new(),
++         };
++         if !scoped {
++             return shown;
++         }
++         let selected: Vec<&SettingsEnvironment> = match &scope.environment {
++             EnvironmentPick::All => environments.iter().filter(|env| env.connected && env.settings.is_some()).collect(),
++             EnvironmentPick::One(id) => match environments.iter().find(|env| env.id == *id) {
++                 None => {
++                     shown.locked = Some("That environment is no longer connected.".into());
++                     Vec::new()
++                 }
++                 Some(env) if !env.connected => {
++                     shown.locked = Some(format!("{} is offline; its settings stay as they are.", env.name).into());
++                     Vec::new()
++                 }
++                 Some(env) if env.settings.is_none() => {
++                     shown.locked = Some(
++                         format!("{} doesn't share its settings yet. Update the app there to edit them here.", env.name)
++                             .into(),
++                     );
++                     Vec::new()
++                 }
++                 Some(env) => vec![env],
++             },
++         };
++         // Each selected environment's settings as the selection sees them.
++         let mut effective: Vec<(WriteTarget, Settings, Option<serde_json::Map<String, serde_json::Value>>)> = Vec::new();
++         for env in selected {
++             let Some(settings) = env.settings.as_ref() else { continue };
++             let target = |project: Option<PathBuf>| WriteTarget {
++                 environment: env.id.clone(),
++                 name: env.name.clone(),
++                 project,
++                 settings: Settings::default(),
++             };
++             match &scope.project {
++                 None => effective.push((target(None), settings.clone(), None)),
++                 Some(name) => {
++                     for (_, path) in env.projects.iter().filter(|(project, _)| project == name) {
++                         let overrides = settings.project_overrides.get(&path.display().to_string()).cloned();
++                         effective.push((target(Some(path.clone())), settings.for_project(path), overrides));
++                     }
++                 }
++             }
++         }
++         if effective.is_empty() {
++             if shown.locked.is_none() {
++                 shown.locked = Some(match &scope.project {
++                     Some(name) => format!("{name} isn't a project on the selected environments.").into(),
++                     None => "No connected environment shares its settings.".into(),
++                 });
++             }
++             shown.targets.clear();
++             return shown;
++         }
++         let values: Vec<serde_json::Map<String, serde_json::Value>> =
++             effective.iter().map(|(_, settings, _)| without_overrides(settings.environment_values())).collect();
++         shown.settings = settings::with_values(&local, &values[0]);
++         shown.settings.project_overrides = local.project_overrides.clone();
++         for key in ENVIRONMENT_KEYS {
++             let first = values[0].get(*key);
++             if values.iter().any(|other| other.get(*key) != first) {
++                 let list = effective
++                     .iter()
++                     .zip(&values)
++                     .map(|((target, _, _), values)| {
++                         (target.name.clone(), describe(values.get(*key).unwrap_or(&serde_json::Value::Null)))
++                     })
++                     .collect();
++                 shown.mixed.insert(key.to_string(), list);
++             }
++         }
++         shown.overridden = effective.iter().flat_map(|(_, _, overrides)| overrides.iter().flat_map(|map| map.keys().cloned())).collect();
++         shown.targets = effective
++             .into_iter()
++             .zip(&values)
++             .map(|((target, _, _), values)| WriteTarget { settings: settings::with_values(&local, values), ..target })
++             .collect();
++         shown
++     }
++     /// How a row with anchor `id` appears, when the selection touches it.
++     pub fn row(&self, id: &str) -> Option<RowScope> {
++         if !self.scoped {
++             return None;
++         }
++         let keys = row_keys(id)?;
++         let overridable = keys.iter().all(|key| PROJECT_KEYS.contains(key));
++         let locked = self.locked.clone().or_else(|| {
++             (self.project.is_some() && !overridable)
++                 .then(|| "Applies to the whole environment. Pick All projects to change it.".into())
++         });
++         let mixed: Vec<(String, String)> = keys.iter().filter_map(|key| self.mixed.get(*key)).flatten().cloned().collect();
++         Some(RowScope {
++             keys,
++             locked,
++             mixed: (!mixed.is_empty()).then_some(mixed),
++             project: self.project.is_some() && overridable,
++             overridden: keys.iter().any(|key| self.overridden.contains(*key)),
++             view: self.view.clone(),
++         })
++     }
++ }
++ /// What the selection means for one row.
++ pub(crate) struct RowScope {
++     pub keys: &'static [&'static str],
++     pub locked: Option<SharedString>,
++     /// Each selected environment's value, when they differ.
++     pub mixed: Option<Vec<(String, String)>>,
++     /// The row edits the picked project's override.
++     pub project: bool,
++     pub overridden: bool,
++     pub view: WeakEntity<SettingsView>,
++ }
++ fn without_overrides(mut values: serde_json::Map<String, serde_json::Value>) -> serde_json::Map<String, serde_json::Value> {
++     values.remove("project_overrides");
++     values
++ }
++ /// A setting's value in a few words, for the Mixed tooltip.
++ fn describe(value: &serde_json::Value) -> String {
++     match value {
++         serde_json::Value::Null => "Automatic".into(),
++         serde_json::Value::Bool(true) => "On".into(),
++         serde_json::Value::Bool(false) => "Off".into(),
++         serde_json::Value::String(text) if text.is_empty() => "Empty".into(),
++         serde_json::Value::String(text) => {
++             let text = text.replace('_', " ");
++             let mut chars = text.chars();
++             match chars.next() {
++                 Some(first) => first.to_uppercase().chain(chars).collect(),
++                 None => text,
++             }
++         }
++         other => other.to_string(),
++     }
++ }
++ /// The patch writing `values` to `target`: environment settings, or the
++ /// project's overrides of them.
++ fn patch_for(target: &WriteTarget, values: &serde_json::Map<String, serde_json::Value>) -> SettingsPatch {
++     match &target.project {
++         None => SettingsPatch { values: values.clone(), projects: BTreeMap::new() },
++         Some(path) => {
++             let overrides = values.iter().filter(|(key, _)| PROJECT_KEYS.contains(&key.as_str())).map(|(k, v)| (k.clone(), v.clone()));
++             SettingsPatch { values: Default::default(), projects: BTreeMap::from([(path.display().to_string(), overrides.collect())]) }
++         }
++     }
++ }
++ impl SettingsView {
++     /// Whether the open page has environment settings, and so the sentence.
++     pub(super) fn page_scoped(&self) -> bool {
++         use super::Page;
++         matches!(self.page, Page::General | Page::Integrations | Page::SourceControl | Page::Storage)
++     }
++     fn environments(&self, cx: &App) -> Vec<SettingsEnvironment> {
++         self.workspace
++             .upgrade()
++             .map(|workspace| workspace.read(cx).settings_environments())
++             .unwrap_or_default()
++     }
++     /// Works the selection out afresh.
++     pub(super) fn compute_shown(&self, cx: &mut Context<Self>) -> Shown {
++         let environments = self.environments(cx);
++         Shown::compute(cx.weak_entity(), &self.scope, self.page_scoped(), &environments)
++     }
++     /// Applies an edit made on a page: this device's preferences here, and
++     /// environment settings to each selected environment (or the project's
++     /// overrides there). The edit runs on each environment's own settings,
++     /// so picking the shown value of a Mixed setting still reaches the
++     /// environments that differ.
++     pub(super) fn apply(&mut self, change: impl Fn(&mut Settings), window: &mut Window, cx: &mut Context<Self>) {
++         let shown = self.compute_shown(cx);
++         let environment_key = |key: &String| shown.scoped && ENVIRONMENT_KEYS.contains(&key.as_str());
++         let changes = |before: &Settings| {
++             let mut after = before.clone();
++             change(&mut after);
++             after.normalize();
++             settings::changed_values(before, &after)
++         };
++         let device: serde_json::Map<_, _> = changes(&shown.settings)
++             .into_iter()
++             .filter(|(key, _)| key != "project_overrides" && !environment_key(key))
++             .collect();
++         if !device.is_empty() {
++             settings::update(|settings| *settings = settings::with_values(settings, &device));
++         }
++         if shown.scoped && shown.locked.is_none() {
++             let patches: Vec<(Option<String>, SettingsPatch)> = shown
++                 .targets
++                 .iter()
++                 .map(|target| {
++                     let values = changes(&target.settings).into_iter().filter(|(key, _)| environment_key(key)).collect();
++                     (target.environment.clone(), patch_for(target, &values))
++                 })
++                 .collect();
++             let _ = self.workspace.update(cx, |workspace, cx| {
++                 for (environment, patch) in patches {
++                     workspace.write_settings(environment.as_deref(), patch, cx);
++                 }
++             });
++         }
++         self.changed(window, cx);
++     }
++     /// Lets the picked project follow its environments again for `keys`.
++     pub(crate) fn inherit(&mut self, keys: &[&str], window: &mut Window, cx: &mut Context<Self>) {
++         let shown = self.compute_shown(cx);
++         let _ = self.workspace.update(cx, |workspace, cx| {
++             for target in &shown.targets {
++                 let Some(path) = &target.project else { continue };
++                 let drop = keys.iter().map(|key| (key.to_string(), serde_json::Value::Null)).collect();
++                 let patch = SettingsPatch { values: Default::default(), projects: BTreeMap::from([(path.display().to_string(), drop)]) };
++                 workspace.write_settings(target.environment.as_deref(), patch, cx);
++             }
++         });
++         self.changed(window, cx);
++     }
++     fn set_scope(&mut self, scope: Scope, window: &mut Window, cx: &mut Context<Self>) {
++         let _ = window;
++         self.scope = scope;
++         // The next render puts the new selection's values in the fields.
++         self.scoped_inputs = None;
++         cx.notify();
++     }
++     /// "Applying settings for <project> across <environment>".
++     pub(super) fn render_scope_sentence(&self, cx: &mut Context<Self>) -> AnyElement {
++         let p = metal::palette(cx);
++         let environments = self.environments(cx);
++         let view = cx.weak_entity();
++         // Projects by name, across every environment.
++         let mut projects: Vec<String> = Vec::new();
++         for (name, _) in environments.iter().flat_map(|env| &env.projects) {
++             if !projects.contains(name) {
++                 projects.push(name.clone());
++             }
++         }
++         let project_icon = |name: &str| metal::badge(workspace::initials(name), workspace::tint_for(name), p);
++         let project_label: SharedString = match &self.scope.project {
++             Some(name) if projects.contains(name) => name.clone().into(),
++             Some(_) => "Unavailable project".into(),
++             None => "All projects".into(),
++         };
++         let project_menu = {
++             let view = view.clone();
++             let scope = self.scope.clone();
++             let projects = projects.clone();
++             picker("scope-project", self.scope.project.as_deref().map(|name| project_icon(name).into_any_element()), project_label)
++                 .dropdown_menu_with_anchor(Anchor::TopLeft, move |mut menu, _, cx| {
++                     let p = metal::palette(cx);
++                     let pick = |project: Option<String>| {
++                         let view = view.clone();
++                         let scope = Scope { project, ..scope.clone() };
++                         move |_: &ClickEvent, window: &mut Window, cx: &mut App| {
++                             let scope = scope.clone();
++                             let _ = view.update(cx, |view, cx| view.set_scope(scope, window, cx));
++                         }
++                     };
++                     menu = menu
++                         .min_w(px(220.))
++                         .max_h(px(420.))
++                         .scrollable(true)
++                         .item(PopupMenuItem::new("All projects").checked(scope.project.is_none()).on_click(pick(None)));
++                     if !projects.is_empty() {
++                         menu = menu.separator();
++                     }
++                     for name in &projects {
++                         let label = name.clone();
++                         let (initials, tint) = (workspace::initials(name), workspace::tint_for(name));
++                         menu = menu.item(
++                             PopupMenuItem::element(move |_, _| {
++                                 h_flex()
++                                     .gap(px(8.))
++                                     .child(metal::badge(initials.clone(), tint, p))
++                                     .child(div().text_size(px(13.)).child(label.clone()))
++                             })
++                             .checked(scope.project.as_deref() == Some(name.as_str()))
++                             .on_click(pick(Some(name.clone()))),
++                         );
++                     }
++                     menu
++                 })
++         };
++         let single = environments.len() < 2;
++         let selected = match &self.scope.environment {
++             EnvironmentPick::One(id) => Some(environments.iter().find(|env| env.id == *id)),
++             EnvironmentPick::All => None,
++         };
++         let environment_label: SharedString = match selected {
++             Some(Some(env)) => env.name.clone().into(),
++             Some(None) => "Unavailable environment".into(),
++             None if single => environments.first().map(|env| env.name.clone()).unwrap_or_default().into(),
++             None => "All environments".into(),
++         };
++         let environment_icon = match selected {
++             Some(Some(env)) => Some(machine_icon(env.id.is_none())),
++             None if single => Some(machine_icon(true)),
++             _ => None,
++         };
++         let entries: Rc<Vec<(Option<String>, String, bool)>> =
++             Rc::new(environments.iter().map(|env| (env.id.clone(), env.name.clone(), env.connected)).collect());
++         let environment_menu = {
++             let view = view.clone();
++             let scope = self.scope.clone();
++             let entries = entries.clone();
++             picker("scope-environment", environment_icon.map(|icon| icon.size(px(13.)).text_color(p.ink2).into_any_element()), environment_label)
++                 .dropdown_menu_with_anchor(Anchor::TopLeft, move |mut menu, _, cx| {
++                     let p = metal::palette(cx);
++                     let pick = |environment: EnvironmentPick| {
++                         let view = view.clone();
++                         let scope = Scope { environment, ..scope.clone() };
++                         move |_: &ClickEvent, window: &mut Window, cx: &mut App| {
++                             let scope = scope.clone();
++                             let _ = view.update(cx, |view, cx| view.set_scope(scope, window, cx));
++                         }
++                     };
++                     menu = menu.min_w(px(240.));
++                     if entries.len() > 1 {
++                         menu = menu
++                             .item(
++                                 PopupMenuItem::new("All environments")
++                                     .icon(Icon::new(Lucide::Layers))
++                                     .checked(scope.environment == EnvironmentPick::All)
++                                     .on_click(pick(EnvironmentPick::All)),
++                             )
++                             .separator();
++                     }
++                     for (id, name, connected) in entries.iter() {
++                         let (label, connected, local) = (name.clone(), *connected, id.is_none());
++                         let checked = scope.environment == EnvironmentPick::One(id.clone())
++                             || (entries.len() == 1 && scope.environment == EnvironmentPick::All);
++                         menu = menu.item(
++                             PopupMenuItem::element(move |_, _| {
++                                 h_flex()
++                                     .w_full()
++                                     .gap(px(8.))
++                                     .child(machine_icon(local).size(px(13.)).text_color(p.ink2))
++                                     .child(div().flex_1().text_size(px(13.)).child(label.clone()))
++                                     .when(!connected, |this| {
++                                         this.child(div().text_size(px(11.5)).text_color(p.ink3).child("Offline"))
++                                     })
++                             })
++                             .checked(checked)
++                             .on_click(pick(EnvironmentPick::One(id.clone()))),
++                         );
++                     }
++                     menu
++                 })
++         };
++         let connective = if matches!(self.scope.environment, EnvironmentPick::One(_)) || single { "on" } else { "across" };
++         let text = |text: &'static str| div().flex_none().text_size(px(14.)).text_color(p.ink3).child(text);
++         v_flex()
++             .gap(px(6.))
++             .child(
++                 h_flex()
++                     .id("settings-scope")
++                     .flex_wrap()
++                     .px(px(16.))
++                     .gap(px(6.))
++                     .child(h_flex().gap(px(4.)).child(text("Applying settings for")).child(project_menu))
++                     .child(h_flex().gap(px(4.)).child(text(connective)).child(environment_menu)),
++             )
++             .into_any_element()
++     }
++     /// Puts the selection's text settings into their fields when they
++     /// changed: on picking another scope, or when another device changed them.
++     /// Reads what the last render worked out, as the workspace may be busy.
++     pub(super) fn sync_scoped_inputs(&mut self, window: &mut Window, cx: &mut Context<Self>) {
++         let shown = shown_settings(cx);
++         let values = [
++             shown.branch_prefix.clone(),
++             shown.worktrees_dir.clone(),
++             shown.branch_instructions.clone(),
++             shown.writing_instructions.clone(),
++         ];
++         if self.scoped_inputs.as_ref() == Some(&values) {
++             return;
++         }
++         let [prefix, worktrees, branch_instructions, writing_instructions] = values.clone();
++         self.branch_prefix.update(cx, |input, cx| input.set_value(prefix, window, cx));
++         self.worktrees_dir.update(cx, |input, cx| input.set_value(worktrees, window, cx));
++         self.branch_instructions.update(cx, |input, cx| input.set_value(branch_instructions, window, cx));
++         self.writing_instructions.update(cx, |input, cx| input.set_value(writing_instructions, window, cx));
++         self.scoped_inputs = Some(values);
++     }
++ }
++ /// The laptop for this device, a server for the others.
++ fn machine_icon(local: bool) -> Icon {
++     Icon::new(if local { Lucide::Laptop } else { Lucide::Server })
++ }
++ /// One of the sentence's pickers: a quiet button with a caret.
++ fn picker(id: &'static str, icon: Option<AnyElement>, label: SharedString) -> MetalButton {
++     let button = MetalButton::new(id).ghost().compact().label(label).caret().max_w(px(288.));
++     match icon {
++         Some(icon) => button.leading(icon),
++         None => button,
++     }
++ }
++ #[cfg(test)]
++ mod tests {
++     use super::*;
++     use crate::ui::settings::search::ITEMS;
++     #[::core::prelude::v1::test]
++     fn scoped_rows_cover_the_environment_settings() {
++         for (id, _, keys) in SCOPED_ROWS {
++             assert!(ITEMS.iter().any(|item| item.id == *id), "{id} isn't a settings row");
++             for key in *keys {
++                 assert!(ENVIRONMENT_KEYS.contains(key), "{key} isn't an environment setting");
++             }
++         }
++         for key in ENVIRONMENT_KEYS {
++             assert!(SCOPED_ROWS.iter().any(|(_, _, keys)| keys.contains(key)), "no row shows {key}");
++         }
++     }
++     fn environment(id: Option<&str>, settings: Settings, projects: &[(&str, &str)]) -> SettingsEnvironment {
++         SettingsEnvironment {
++             id: id.map(str::to_string),
++             name: id.unwrap_or("here").to_string(),
++             connected: true,
++             settings: Some(settings),
++             projects: projects.iter().map(|(name, path)| (name.to_string(), PathBuf::from(path))).collect(),
++         }
++     }
++     #[::core::prelude::v1::test]
++     fn environments_disagreeing_show_as_mixed() {
++         let mut other = Settings::default();
++         other.workspace = settings::WorkspaceMode::Worktree;
++         let environments = [environment(None, Settings::default(), &[]), environment(Some("box"), other, &[])];
++         let shown = Shown::compute(WeakEntity::new_invalid(), &Scope::default(), true, &environments);
++         assert_eq!(shown.targets.len(), 2);
++         assert_eq!(shown.mixed["workspace"], [("here".to_string(), "Local".to_string()), ("box".into(), "Worktree".into())]);
++         assert!(shown.row("new-threads").unwrap().mixed.is_some());
++         assert!(shown.row("worktree-submodules").unwrap().mixed.is_none());
++         // A device preference is no environment's business.
++         assert!(shown.row("time-format").is_none());
++     }
++     #[::core::prelude::v1::test]
++     fn a_project_writes_its_overrides_where_it_exists() {
++         let mut box_settings = Settings::default();
++         box_settings
++             .project_overrides
++             .insert("/srv/app".into(), serde_json::Map::from_iter([("submodules".to_string(), serde_json::json!("skip"))]));
++         let environments = [
++             environment(None, Settings::default(), &[("app", "/home/me/app")]),
++             environment(Some("box"), box_settings, &[("app", "/srv/app"), ("other", "/srv/other")]),
++         ];
++         let scope = Scope { environment: EnvironmentPick::All, project: Some("app".into()) };
++         let shown = Shown::compute(WeakEntity::new_invalid(), &scope, true, &environments);
++         let paths: Vec<_> = shown.targets.iter().filter_map(|target| target.project.clone()).collect();
++         assert_eq!(paths, [PathBuf::from("/home/me/app"), PathBuf::from("/srv/app")]);
++         assert!(shown.overridden.contains("submodules"));
++         let row = shown.row("worktree-submodules").unwrap();
++         assert!(row.project && row.overridden && row.mixed.is_some() && row.locked.is_none());
++         // Environment-wide settings can't be overridden.
++         assert!(shown.row("storage-worktrees-location").unwrap().locked.is_some());
++         let values = serde_json::Map::from_iter([
++             ("workspace".to_string(), serde_json::json!("worktree")),
++             ("worktrees_dir".to_string(), serde_json::json!("/tmp")),
++         ]);
++         let patch = patch_for(&shown.targets[1], &values);
++         assert!(patch.values.is_empty());
++         assert_eq!(patch.projects["/srv/app"].keys().collect::<Vec<_>>(), ["workspace"]);
++     }
++     #[::core::prelude::v1::test]
++     fn an_offline_environment_is_left_alone() {
++         let mut offline = environment(Some("box"), Settings::default(), &[]);
++         offline.connected = false;
++         let environments = [environment(None, Settings::default(), &[]), offline];
++         let all = Shown::compute(WeakEntity::new_invalid(), &Scope::default(), true, &environments);
++         assert_eq!(all.targets.len(), 1);
++         let one = Scope { environment: EnvironmentPick::One(Some("box".into())), project: None };
++         let shown = Shown::compute(WeakEntity::new_invalid(), &one, true, &environments);
++         assert!(shown.targets.is_empty() && shown.locked.is_some());
++     }
++ }

+7−7src/ui/settings/source_control.rsView File

@@ -10,7 +10,7 @@ use gpui_kit::*;
10	10
11	11	use super::SettingsView;
12	12	use super::widgets::{Section, SettingRow, choice, code, empty_row, reset, switch, text_field};
13		- use crate::settings::{self, BranchNaming, WritingStyle};
	13	+ use crate::settings::{BranchNaming, WritingStyle};
14	14	use crate::ui::icons::Lucide;
15	15	use crate::ui::metal::{self, Led, MetalButton, MetalStyled as _};
16	16	use crate::ui::workspace;
@@ -96,7 +96,7 @@ impl SettingsView {
96	96
97	97	pub(super) fn render_source_control(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Vec<AnyElement> {
98	98	let p = metal::palette(cx);
99		- let saved = settings::load();
	99	+ let saved = super::scope::shown_settings(cx);
100	100	let view = cx.weak_entity();
101	101	if self.source_control.git.is_none() && !self.source_control.scanning {
102	102	self.scan_source_control(cx);
@@ -138,7 +138,7 @@ impl SettingsView {
138	138	"The model chooses a prefix that describes the work, such as feat/add-search, fix/login-timeout, or refactor/auth.",
139	139	)
140	140	})
141		- .reset(reset(&view, \|s\| s.branch_naming, \|s, naming\| s.branch_naming = naming))
	141	+ .reset(reset(&view, cx, \|s\| s.branch_naming, \|s, naming\| s.branch_naming = naming))
142	142	.control(choice("branch-naming", saved.branch_naming, BRANCH_NAMING, &view, \|settings, naming\| {
143	143	settings.branch_naming = naming
144	144	})),
@@ -149,7 +149,7 @@ impl SettingsView {
149	149	SettingRow::new("Branch prefix")
150	150	.id("branch-prefix")
151	151	.description("For example, vectrum or vectrum/ produces vectrum/add-search. Leave empty for no prefix.")
152		- .reset(reset(&view, \|s\| s.branch_prefix.clone(), \|s, prefix\| s.branch_prefix = prefix))
	152	+ .reset(reset(&view, cx, \|s\| s.branch_prefix.clone(), \|s, prefix\| s.branch_prefix = prefix))
153	153	.control(text_field(&self.branch_prefix, 224., window, cx)),
154	154	);
155	155	}
@@ -160,7 +160,7 @@ impl SettingsView {
160	160	.description(
161	161	"Appended to the naming prompt. The model returns the complete branch name; no prefix or suffix is added.",
162	162	)
163		- .reset(reset(&view, \|s\| s.branch_instructions.clone(), \|s, text\| s.branch_instructions = text))
	163	+ .reset(reset(&view, cx, \|s\| s.branch_instructions.clone(), \|s, text\| s.branch_instructions = text))
164	164	.below(
165	165	div()
166	166	.px(px(2.))
@@ -185,7 +185,7 @@ impl SettingsView {
185	185	WritingStyle::Conventional => "Use Conventional Commit prefixes and keep change request text concise.",
186	186	WritingStyle::Custom => "Use your instructions for change descriptions and change requests in every project.",
187	187	})
188		- .reset(reset(&view, \|s\| s.writing_style, \|s, style\| s.writing_style = style))
	188	+ .reset(reset(&view, cx, \|s\| s.writing_style, \|s, style\| s.writing_style = style))
189	189	.control(choice("writing-style", saved.writing_style, WRITING_STYLES, &view, \|settings, style\| {
190	190	settings.writing_style = style
191	191	}))
@@ -206,7 +206,7 @@ impl SettingsView {
206	206	SettingRow::new("Follow change request templates")
207	207	.id("follow-change-request-templates")
208	208	.description("Use the repository's template for change request descriptions when available.")
209		- .reset(reset(&view, \|s\| s.follow_pr_templates, \|s, on\| s.follow_pr_templates = on))
	209	+ .reset(reset(&view, cx, \|s\| s.follow_pr_templates, \|s, on\| s.follow_pr_templates = on))
210	210	.control(switch("follow-pr-templates", saved.follow_pr_templates, &view, p, \|settings, on\| {
211	211	settings.follow_pr_templates = on
212	212	})),

+7−7src/ui/settings/storage.rsView File

@@ -20,7 +20,7 @@ impl SettingsView {
20	20	pub(super) fn render_storage(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Vec<AnyElement> {
21	21	let view = cx.weak_entity();
22	22	let p = metal::palette(cx);
23		- let saved = settings::load();
	23	+ let saved = super::scope::shown_settings(cx);
24	24	let data = settings::data_dir();
25	25	let default_worktrees = data.as_ref().map(\|data\| data.join("worktrees"));
26	26	let worktrees = Section::new("Worktrees")
@@ -32,12 +32,12 @@ impl SettingsView {
32	32	"Folder where new worktrees are created, on any drive, such as ~/worktrees. Existing worktrees stay where they are. Leave empty to use the app's data folder.",
33	33	)
34	34	.status(match &default_worktrees {
35		- Some(path) if settings::get(\|settings\| settings.worktrees_dir.trim().is_empty()) => {
	35	+ Some(path) if saved.worktrees_dir.trim().is_empty() => {
36	36	format!("Default: {}", display_path(path))
37	37	}
38	38	_ => String::new(),
39	39	})
40		- .reset(reset(&view, \|s\| s.worktrees_dir.clone(), \|s, dir\| s.worktrees_dir = dir))
	40	+ .reset(reset(&view, cx, \|s\| s.worktrees_dir.clone(), \|s, dir\| s.worktrees_dir = dir))
41	41	.control(text_field(&self.worktrees_dir, 288., window, cx)),
42	42	)
43	43	.row(
@@ -46,7 +46,7 @@ impl SettingsView {
46	46	.description(
47	47	"Remove unused worktrees when active or archived threads are deleted. Worktrees with local changes are kept.",
48	48	)
49		- .reset(reset(&view, \|s\| s.cleanup_deleted_worktrees, \|s, on\| s.cleanup_deleted_worktrees = on))
	49	+ .reset(reset(&view, cx, \|s\| s.cleanup_deleted_worktrees, \|s, on\| s.cleanup_deleted_worktrees = on))
50	50	.control(switch("cleanup-deleted", saved.cleanup_deleted_worktrees, &view, p, \|settings, on\| {
51	51	settings.cleanup_deleted_worktrees = on
52	52	})),
@@ -57,14 +57,14 @@ impl SettingsView {
57	57	.description(
58	58	"Remove worktrees after their threads have been inactive for this many days. Branches and thread history are kept.",
59	59	)
60		- .reset(reset(&view, \|s\| s.cleanup_inactive_worktrees, \|s, days\| s.cleanup_inactive_worktrees = days))
	60	+ .reset(reset(&view, cx, \|s\| s.cleanup_inactive_worktrees, \|s, days\| s.cleanup_inactive_worktrees = days))
61	61	.control(retention("cleanup-inactive", saved.cleanup_inactive_worktrees, &view, p)),
62	62	)
63	63	.row(
64	64	SettingRow::new("Delete merged worktrees")
65	65	.id("storage-worktrees-merged")
66	66	.description("Remove worktrees whose pull request is merged and whose commits are included in the default branch.")
67		- .reset(reset(&view, \|s\| s.cleanup_merged_worktrees, \|s, on\| s.cleanup_merged_worktrees = on))
	67	+ .reset(reset(&view, cx, \|s\| s.cleanup_merged_worktrees, \|s, on\| s.cleanup_merged_worktrees = on))
68	68	.control(switch("cleanup-merged", saved.cleanup_merged_worktrees, &view, p, \|settings, on\| {
69	69	settings.cleanup_merged_worktrees = on
70	70	})),
@@ -73,7 +73,7 @@ impl SettingsView {
73	73	SettingRow::new("Delete unchanged worktrees")
74	74	.id("storage-worktrees-unchanged")
75	75	.description("Remove worktrees with no commits beyond the default branch.")
76		- .reset(reset(&view, \|s\| s.cleanup_unchanged_worktrees, \|s, on\| s.cleanup_unchanged_worktrees = on))
	76	+ .reset(reset(&view, cx, \|s\| s.cleanup_unchanged_worktrees, \|s, on\| s.cleanup_unchanged_worktrees = on))
77	77	.control(switch("cleanup-unchanged", saved.cleanup_unchanged_worktrees, &view, p, \|settings, on\| {
78	78	settings.cleanup_unchanged_worktrees = on
79	79	})),

+68−10src/ui/settings/widgets.rsView File

@@ -21,7 +21,7 @@ use super::SettingsView;
21	21	use crate::claude::Effort;
22	22	use crate::models::{Catalog, ProbeStatus, Provider, split_key};
23	23	use crate::session::Reasoning;
24		- use crate::settings::{self, Settings};
	24	+ use crate::settings::Settings;
25	25	use crate::ui::icons::Lucide;
26	26	use crate::ui::metal::{self, MetalButton, MetalStyled as _, Palette};
27	27	use crate::ui::pickers;
@@ -196,10 +196,38 @@ impl SettingRow {
196	196	}
197	197
198	198	impl RenderOnce for SettingRow {
199		- fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
	199	+ fn render(mut self, window: &mut Window, cx: &mut App) -> impl IntoElement {
200	200	let p = metal::palette(cx);
201	201	let stacked = stacked(window, self.max_width);
202	202	let title = self.title.clone();
	203	+ // The settings scope: whether the row can change, and where its value comes from.
	204	+ let scope = self.id.and_then(\|id\| cx.try_global::<super::scope::Shown>()?.row(id));
	205	+ let mut scope_tags: Vec<AnyElement> = Vec::new();
	206	+ let mut lock_note = None;
	207	+ if let Some(scope) = &scope {
	208	+ if scope.project {
	209	+ // Reset means following the environments again.
	210	+ self.reset = scope.overridden.then(\|\| -> Reset {
	211	+ let (view, keys) = (scope.view.clone(), scope.keys);
	212	+ Rc::new(move \|window, cx\| {
	213	+ let _ = view.update(cx, \|view, cx\| view.inherit(keys, window, cx));
	214	+ })
	215	+ });
	216	+ if scope.overridden {
	217	+ scope_tags.push(scope_tag("Override", "This project overrides the environment's value.".into(), p.blue_ink, p));
	218	+ }
	219	+ }
	220	+ if let Some(values) = &scope.mixed {
	221	+ let list = values.iter().map(\|(env, value)\| format!("{env}: {value}")).collect::<Vec<_>>().join("\n");
	222	+ scope_tags.push(scope_tag("Mixed", format!("The selected environments differ. Picking a value applies it to all of them.\n{list}").into(), p.amber_ink, p));
	223	+ }
	224	+ if let Some(reason) = &scope.locked {
	225	+ self.reset = None;
	226	+ self.dimmed = true;
	227	+ lock_note = Some(reason.clone());
	228	+ }
	229	+ }
	230	+ let reset_tooltip = if scope.as_ref().is_some_and(\|scope\| scope.project) { "Use the environment's value" } else { "Reset to default" };
203	231	let text = v_flex()
204	232	.flex_1()
205	233	.min_w_0()
@@ -214,7 +242,8 @@ impl RenderOnce for SettingRow {
214	242	this.child(div().text_size(px(14.)).font_weight(FontWeight::MEDIUM).text_color(p.ink).child(self.title))
215	243	})
216	244	.children(self.title_suffix)
217		- .when_some(self.reset, \|this, reset\| this.child(reset_button(&title, reset, p))),
	245	+ .children(scope_tags)
	246	+ .when_some(self.reset, \|this, reset\| this.child(reset_button(&title, reset_tooltip, reset, p))),
218	247	)
219	248	.when_some(self.description, \|this, description\| {
220	249	this.child(
@@ -228,12 +257,19 @@ impl RenderOnce for SettingRow {
228	257	})
229	258	.when_some(self.status, \|this, status\| {
230	259	this.child(div().pt(px(2.)).text_size(px(12.)).line_height(px(17.)).text_color(p.ink3).child(status))
	260	+ })
	261	+ .when_some(lock_note.clone(), \|this, note\| {
	262	+ this.child(div().pt(px(2.)).text_size(px(12.)).line_height(px(17.)).text_color(p.ink2).child(note))
231	263	});
	264	+ let locked = lock_note.is_some();
232	265	let control = self.control.map(\|control\| {
233	266	h_flex()
234	267	.gap(px(8.))
235	268	.map(\|this\| if stacked { this.w_full() } else { this.flex_none().justify_end() })
	269	+ .when(locked, \|this\| this.relative().opacity(0.5))
236	270	.child(control)
	271	+ // A locked row's control can't be used.
	272	+ .when(locked, \|this\| this.child(div().id("locked").absolute().inset_0().occlude().cursor_not_allowed()))
237	273	});
238	274	let row = div()
239	275	.px(px(16.))
@@ -257,8 +293,29 @@ impl RenderOnce for SettingRow {
257	293	}
258	294	}
259	295
	296	+ /// A small tag after a row's title about where its value comes from.
	297	+ fn scope_tag(label: &'static str, tooltip: SharedString, color: Hsla, p: &Palette) -> AnyElement {
	298	+ div()
	299	+ .id(SharedString::from(format!("scope-tag-{label}")))
	300	+ .flex()
	301	+ .flex_none()
	302	+ .items_center()
	303	+ .gap(px(4.))
	304	+ .h(px(18.))
	305	+ .px(px(6.))
	306	+ .rounded(px(6.))
	307	+ .bg(color.opacity(if p.dark { 0.16 } else { 0.1 }))
	308	+ .text_size(px(11.))
	309	+ .font_weight(FontWeight::MEDIUM)
	310	+ .text_color(color)
	311	+ .tooltip(move \|window, cx\| Tooltip::new(tooltip.clone()).build(window, cx))
	312	+ .child(Icon::new(Lucide::Layers).size(px(11.)))
	313	+ .child(label)
	314	+ .into_any_element()
	315	+ }
	316	+
260	317	/// T3 Code's per-row reset: a small ghost button with an undo arrow.
261		- fn reset_button(title: &SharedString, reset: Reset, p: &Palette) -> impl IntoElement {
	318	+ fn reset_button(title: &SharedString, tooltip: &'static str, reset: Reset, p: &Palette) -> impl IntoElement {
262	319	div()
263	320	.id(SharedString::from(format!("reset-{title}")))
264	321	.flex()
@@ -270,7 +327,7 @@ fn reset_button(title: &SharedString, reset: Reset, p: &Palette) -> impl IntoEle
270	327	.cursor_pointer()
271	328	.text_color(p.ink3)
272	329	.hover(\|style\| style.bg(p.row_hover).text_color(p.ink))
273		- .tooltip(\|window, cx\| Tooltip::new("Reset to default").build(window, cx))
	330	+ .tooltip(move \|window, cx\| Tooltip::new(tooltip).build(window, cx))
274	331	.on_click(move \|_, window, cx\| reset(window, cx))
275	332	.child(Icon::new(Lucide::Undo2).size(px(12.)))
276	333	}
@@ -279,10 +336,11 @@ fn reset_button(title: &SharedString, reset: Reset, p: &Palette) -> impl IntoEle
279	336	/// default, and putting the default back with `set`.
280	337	pub(crate) fn reset<T: PartialEq + 'static>(
281	338	view: &WeakEntity<SettingsView>,
	339	+ cx: &App,
282	340	get: fn(&Settings) -> T,
283	341	set: fn(&mut Settings, T),
284	342	) -> Option<Reset> {
285		- let differs = settings::get(\|settings\| get(settings) != get(&Settings::default()));
	343	+ let differs = get(&super::scope::shown_settings(cx)) != get(&Settings::default());
286	344	let view = view.clone();
287	345	differs.then(\|\| -> Reset {
288	346	Rc::new(move \|window, cx\| edit(&view, window, cx, \|settings\| set(settings, get(&Settings::default()))))
@@ -495,10 +553,10 @@ pub(crate) fn note(text: impl Into<SharedString>, p: &Palette) -> Div {
495	553
496	554	// ---- controls ------------------------------------------------------------------
497	555
498		- /// Saves an edit, then repaints the view and tells the conversations.
499		- pub(crate) fn edit(view: &WeakEntity<SettingsView>, window: &mut Window, cx: &mut App, change: impl FnOnce(&mut Settings)) {
500		- settings::update(change);
501		- let _ = view.update(cx, \|view, cx\| view.changed(window, cx));
	556	+ /// Saves an edit (to the selected environments, when it changes their
	557	+ /// settings), then repaints the view and tells the conversations.
	558	+ pub(crate) fn edit(view: &WeakEntity<SettingsView>, window: &mut Window, cx: &mut App, change: impl Fn(&mut Settings)) {
	559	+ let _ = view.update(cx, \|view, cx\| view.apply(change, window, cx));
502	560	}
503	561
504	562	pub(crate) fn switch(

+33−25src/ui/workspace.rsView File

@@ -7,7 +7,7 @@
7	7	use std::{
8	8	collections::{HashMap, HashSet},
9	9	hash::{Hash as _, Hasher as _},
10		- path::PathBuf,
	10	+ path::{Path, PathBuf},
11	11	process::{Command, Stdio},
12	12	rc::Rc,
13	13	time::{Duration, Instant, SystemTime},
@@ -56,6 +56,7 @@ mod terminal_drawer;
56	56	use actions::UndoEntry;
57	57	use palette::CommandPalette;
58	58	use remote::RemoteState;
	59	+ pub use remote::SettingsEnvironment;
59	60	use terminal_drawer::TerminalDrawer;
60	61
61	62	pub(crate) const SIDEBAR_WIDTH: f32 = 280.;
@@ -434,7 +435,7 @@ impl Workspace {
434	435	workspace.ensure_project(cwd.canonicalize().unwrap_or(cwd), None)
435	436	}
436	437	};
437		- let settings = workspace.new_thread_settings(cx);
	438	+ let settings = workspace.new_thread_settings(ix, cx);
438	439	workspace.replace_thread(ix, settings, window, cx);
439	440	}
440	441	}
@@ -666,9 +667,6 @@ impl Workspace {
666	667	/// idle ones, and checks worktree threads' pull requests.
667	668	fn housekeeping(&mut self, allowed: bool, cx: &mut Context<Self>) {
668	669	let now = SystemTime::now();
669		- let (settle_inactive, inactive_days) =
670		- settings::get(\|settings\| (settings.auto_settle_inactive, settings.inactive_days.max(1)));
671		- let inactive = Duration::from_secs(u64::from(inactive_days) * 86_400);
672	670	// Other devices look after their own threads.
673	671	let sessions: Vec<Entity<Session>> = self
674	672	.projects
@@ -680,6 +678,9 @@ impl Workspace {
680	678	let (wake, resume, settle) = {
681	679	let state = session.read(cx);
682	680	let idle = !state.is_working() && !state.needs_attention() && !state.items.is_empty();
	681	+ let (settle_inactive, inactive_days) =
	682	+ settings::get_for(&state.project, \|settings\| (settings.auto_settle_inactive, settings.inactive_days.max(1)));
	683	+ let inactive = Duration::from_secs(u64::from(inactive_days) * 86_400);
683	684	(
684	685	state.snoozed_until.is_some_and(\|until\| until <= now),
685	686	state.resume_at.is_some_and(\|at\| at <= now) && !state.is_working(),
@@ -723,10 +724,14 @@ impl Workspace {
723	724	/// branch, and with no agent at work there; the thread and its branch
724	725	/// stay, and the worktree comes back with the thread's next message.
725	726	fn clean_up_worktrees(&mut self, cx: &mut Context<Self>) {
726		- let (inactive_days, merged, unchanged) = settings::get(\|settings\| {
727		- (settings.cleanup_inactive_worktrees, settings.cleanup_merged_worktrees, settings.cleanup_unchanged_worktrees)
728		- });
729		- if inactive_days.is_none() && !merged && !unchanged {
	727	+ let rules = \|project: &Path\| {
	728	+ settings::get_for(project, \|settings\| {
	729	+ (settings.cleanup_inactive_worktrees, settings.cleanup_merged_worktrees, settings.cleanup_unchanged_worktrees)
	730	+ })
	731	+ };
	732	+ let projects: Vec<&Path> =
	733	+ self.projects.iter().filter(\|project\| project.environment.is_none()).map(\|project\| project.path.as_path()).collect();
	734	+ if projects.iter().all(\|project\| rules(project) == (None, false, false)) {
730	735	return;
731	736	}
732	737	let Some(managed) = worktree::worktrees_dir() else { return };
@@ -739,10 +744,12 @@ impl Workspace {
739	744	.filter(\|state\| state.is_working() \|\| state.preparing)
740	745	.filter_map(\|state\| state.worktree.as_ref().map(\|worktree\| worktree.root.clone()))
741	746	.collect();
742		- let mut candidates: Vec<(Worktree, bool, bool)> = Vec::new();
	747	+ // Each worktree, whether it's due, merged, and removable unchanged.
	748	+ let mut candidates: Vec<(Worktree, bool, bool, bool)> = Vec::new();
743	749	for session in sessions {
744	750	let state = session.read(cx);
745	751	let Some(worktree) = state.worktree.clone() else { continue };
	752	+ let (inactive_days, merged, unchanged) = rules(&state.project);
746	753	if !worktree.root.starts_with(&managed) \|\| !worktree.root.exists() \|\| busy.contains(&worktree.root) {
747	754	continue;
748	755	}
@@ -751,7 +758,7 @@ impl Workspace {
751	758	});
752	759	let pr_merged = merged && state.pull_request.as_ref().is_some_and(\|pr\| pr.state == "MERGED");
753	760	if inactive \|\| pr_merged \|\| unchanged {
754		- candidates.push((worktree, inactive \|\| pr_merged, pr_merged));
	761	+ candidates.push((worktree, inactive \|\| pr_merged, pr_merged, unchanged));
755	762	}
756	763	}
757	764	if candidates.is_empty() {
@@ -759,7 +766,7 @@ impl Workspace {
759	766	}
760	767	cx.background_executor()
761	768	.spawn(async move {
762		- for (worktree, due, merged) in candidates {
	769	+ for (worktree, due, merged, unchanged) in candidates {
763	770	let status = git::status(&worktree.root);
764	771	let safe = status
765	772	.as_ref()
@@ -801,10 +808,10 @@ impl Workspace {
801	808	});
802	809	cx.spawn(async move \|_, cx\| {
803	810	let results = task.await;
804		- let merged_settles = settings::get(\|settings\| settings.auto_settle_merged);
805	811	for ((session, _, _), pull_request) in threads.into_iter().zip(results) {
806	812	let Some(pull_request) = pull_request else { continue };
807	813	let _ = session.update(cx, \|session, cx\| {
	814	+ let merged_settles = settings::get_for(&session.project, \|settings\| settings.auto_settle_merged);
808	815	let was_open = session.pull_request.as_ref().is_none_or(\|before\| before.is_open());
809	816	let settle = was_open
810	817	&& session.auto_settle
@@ -873,12 +880,11 @@ impl Workspace {
873	880	settings
874	881	}
875	882
876		- /// What a fresh thread starts with: the open thread's picks, overridden
877		- /// by the defaults chosen in the settings.
878		- fn new_thread_settings(&self, cx: &App) -> ThreadSettings {
879		- let (model, reasoning, access) = settings::get(\|settings\| {
880		- (settings.default_model.clone(), settings.default_reasoning.clone(), settings.default_access.clone())
881		- });
	883	+ /// What a fresh thread in this project starts with: the open thread's
	884	+ /// picks, overridden by the defaults its environment and project chose.
	885	+ fn new_thread_settings(&self, project_ix: usize, cx: &App) -> ThreadSettings {
	886	+ let defaults = self.project_settings(project_ix);
	887	+ let (model, reasoning, access) = (defaults.default_model, defaults.default_reasoning, defaults.default_access);
882	888	let mut settings = self.current_settings(cx);
883	889	if let Some(key) = model {
884	890	match Catalog::global(cx).find_key(&key) {
@@ -918,12 +924,13 @@ impl Workspace {
918	924	if mode != WorkspaceMode::Worktree \|\| project.environment.is_some() \|\| Some(&project.path) == scratch_dir().as_ref() {
919	925	return None;
920	926	}
921		- let (from_origin, submodules) = settings::get(\|settings\| (settings.start_from_origin, settings.submodules));
	927	+ let (from_origin, submodules) =
	928	+ settings::get_for(&project.path, \|settings\| (settings.start_from_origin, settings.submodules));
922	929	Some(WorktreePlan { project: project.path.clone(), base: git.branch.clone(), from_origin, submodules })
923	930	}
924	931
925	932	fn new_thread(&mut self, project_ix: usize, window: &mut Window, cx: &mut Context<Self>) {
926		- let settings = self.new_thread_settings(cx);
	933	+ let settings = self.new_thread_settings(project_ix, cx);
927	934	self.new_thread_with(project_ix, settings, window, cx);
928	935	}
929	936
@@ -934,8 +941,8 @@ impl Workspace {
934	941	window: &mut Window,
935	942	cx: &mut Context<Self>,
936	943	) -> Option<Entity<ChatView>> {
	944	+ let mode = self.project_settings(project_ix).workspace;
937	945	let project = self.projects.get(project_ix)?;
938		- let mode = settings::get(\|settings\| settings.workspace);
939	946	let session = match project.environment.clone() {
940	947	Some(env) => {
941	948	let worktree = mode == WorkspaceMode::Worktree && project.git.is_some();
@@ -1108,7 +1115,7 @@ impl Workspace {
1108	1115	}
1109	1116	ChatEvent::OpenProviderSettings => self.open_settings(window, cx),
1110	1117	ChatEvent::ImplementInNewThread(plan) => {
1111		- let settings = self.new_thread_settings(cx);
	1118	+ let settings = self.new_thread_settings(project_ix, cx);
1112	1119	if let Some(chat) = self.new_thread_with(project_ix, settings, window, cx) {
1113	1120	let prompt = format!("Implement this plan:\n\n{plan}");
1114	1121	chat.read(cx).session().clone().update(cx, \|session, cx\| session.send_message(prompt, Vec::new(), cx));
@@ -1674,6 +1681,7 @@ impl Workspace {
1674	1681	/// Lets every open conversation pick up changed settings.
1675	1682	pub fn settings_changed(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1676	1683	self.sync_remote(window, cx);
	1684	+ self.broadcast_settings();
1677	1685	for chat in self.chats.values() {
1678	1686	chat.update(cx, \|chat, cx\| chat.settings_changed(window, cx));
1679	1687	}
@@ -2267,7 +2275,7 @@ impl Render for Workspace {
2267	2275
2268	2276	/// Two letters for a project's badge: the first letters of its first two
2269	2277	/// words (`vectrum.git` → `VG`), or of its name (`T3-2` → `T3`).
2270		- fn initials(name: &str) -> String {
	2278	+ pub(crate) fn initials(name: &str) -> String {
2271	2279	let words: Vec<&str> = name.split(\|c: char\| !c.is_alphanumeric()).filter(\|word\| !word.is_empty()).collect();
2272	2280	let letters: String = match words.as_slice() {
2273	2281	[first, second, ..] if second.starts_with(\|c: char\| c.is_alphabetic()) => {
@@ -2279,7 +2287,7 @@ fn initials(name: &str) -> String {
2279	2287	letters.to_uppercase()
2280	2288	}
2281	2289
2282		- fn tint_for(name: &str) -> usize {
	2290	+ pub(crate) fn tint_for(name: &str) -> usize {
2283	2291	let mut hasher = std::collections::hash_map::DefaultHasher::new();
2284	2292	name.hash(&mut hasher);
2285	2293	hasher.finish() as usize

+3−2src/ui/workspace/actions.rsView File

@@ -475,7 +475,8 @@ impl Workspace {
475	475	}
476	476
477	477	pub(super) fn regenerate_titles(&mut self, sessions: Vec<Entity<Session>>, window: &mut Window, cx: &mut Context<Self>) {
478		- if settings::get(\|settings\| settings.text_model.is_empty()) {
	478	+ let off = \|session: &Entity<Session>\| settings::get_for(&session.read(cx).project, \|settings\| settings.text_model.is_empty());
	479	+ if sessions.iter().all(off) {
479	480	error_toast(
480	481	if sessions.len() == 1 { "Failed to regenerate thread title" } else { "Failed to regenerate thread titles" },
481	482	"Pick a text generation model under Settings → General first.",
@@ -498,7 +499,7 @@ impl Workspace {
498	499	let state = session.read(cx);
499	500	(state.worktree.clone(), state.cwd.clone())
500	501	};
501		- let settings = self.new_thread_settings(cx);
	502	+ let settings = self.new_thread_settings(project_ix, cx);
502	503	if self.projects[project_ix].environment.is_some() {
503	504	self.new_thread_with(project_ix, settings, window, cx);
504	505	return;

+12−10src/ui/workspace/git_actions.rsView File

@@ -155,6 +155,7 @@ struct Outcome {
155	155	/// Blocks; run it in the background.
156	156	fn run(
157	157	path: &Path,
	158	+ project: &Path,
158	159	action: GitAction,
159	160	files: Option<Vec<String>>,
160	161	message: String,
@@ -201,7 +202,7 @@ fn run(
201	202	let message = if message.trim().is_empty() {
202	203	let (summary, patch) = git::staged(path);
203	204	let branch = git::status(path).and_then(\|status\| status.branch);
204		- crate::textgen::commit_message(branch.as_deref(), &summary, &patch, &writing_instructions(path))
	205	+ crate::textgen::commit_message(project, branch.as_deref(), &summary, &patch, &writing_instructions(path, project))
205	206	.unwrap_or_else(\|\| "Update files".into())
206	207	} else {
207	208	message
@@ -231,9 +232,9 @@ fn run(
231	232	let patch = git::git(path, &["diff", &format!("{base_ref}...HEAD")]).unwrap_or_default();
232	233	let mut command = std::process::Command::new(gh);
233	234	command.current_dir(path).args(["pr", "create", "--base", &base, "--head", &branch]);
234		- let template = pr_template(path);
235		- let instructions = writing_instructions(path);
236		- match crate::textgen::pull_request_content(&base, &branch, &commits, &stat, &patch, template.as_deref(), &instructions) {
	235	+ let template = pr_template(path, project);
	236	+ let instructions = writing_instructions(path, project);
	237	+ match crate::textgen::pull_request_content(project, &base, &branch, &commits, &stat, &patch, template.as_deref(), &instructions) {
237	238	Some((pr_title, body)) => command.args(["--title", &pr_title, "--body", &body]),
238	239	None => command.arg("--fill"),
239	240	};
@@ -250,9 +251,9 @@ fn run(
250	251	}
251	252
252	253	/// The instructions Settings → Source Control → writing style adds to
253		- /// commit message and pull request prompts.
254		- fn writing_instructions(path: &Path) -> String {
255		- let (style, custom) = crate::settings::get(\|settings\| (settings.writing_style, settings.writing_instructions.clone()));
	254	+ /// commit message and pull request prompts, as `project` has it.
	255	+ fn writing_instructions(path: &Path, project: &Path) -> String {
	256	+ let (style, custom) = crate::settings::get_for(project, \|settings\| (settings.writing_style, settings.writing_instructions.clone()));
256	257	match style {
257	258	crate::settings::WritingStyle::RepoConventions => {
258	259	let recent = git::git(path, &["log", "-15", "--format=%s"]).unwrap_or_default();
@@ -271,8 +272,8 @@ fn writing_instructions(path: &Path) -> String {
271	272
272	273	/// The repository's pull request template, when it has one and the
273	274	/// settings say to follow it.
274		- fn pr_template(path: &Path) -> Option<String> {
275		- if !crate::settings::get(\|settings\| settings.follow_pr_templates) {
	275	+ fn pr_template(path: &Path, project: &Path) -> Option<String> {
	276	+ if !crate::settings::get_for(project, \|settings\| settings.follow_pr_templates) {
276	277	return None;
277	278	}
278	279	let root = PathBuf::from(git::git(path, &["rev-parse", "--show-toplevel"]).ok()?.trim());
@@ -324,6 +325,7 @@ impl Workspace {
324	325	cx: &mut Context<Self>,
325	326	) {
326	327	let Some(path) = self.git_path(cx) else { return };
	328	+ let Some(project) = self.active_project().map(\|project\| project.path.clone()) else { return };
327	329	let status = match action {
328	330	GitAction::Pull => "Pulling latest changes...",
329	331	_ if action.commits() && message.trim().is_empty() => "Generating commit message...",
@@ -335,7 +337,7 @@ impl Workspace {
335	337	cx.notify();
336	338	let task = cx.background_executor().spawn({
337	339	let path = path.clone();
338		- async move { run(&path, action, files, message, feature_branch) }
	340	+ async move { run(&path, &project, action, files, message, feature_branch) }
339	341	});
340	342	cx.spawn_in(window, async move \|this, cx\| {
341	343	let result = task.await;

+184−2src/ui/workspace/remote.rsView File

@@ -25,7 +25,8 @@ use crate::remote::{
25	25	use crate::session::{
26	26	NewSession, PermissionDecision, Reasoning, RemoteLink, Session, from_millis, store_uploads,
27	27	};
28		- use crate::settings::{self, RemoteHost, WorkspaceMode};
	28	+ use crate::settings::{self, RemoteHost, Settings, SettingsPatch, WorkspaceMode};
	29	+ use crate::ui::metal::MetalButton;
29	30
30	31	/// How often changed threads are sent to subscribed clients.
31	32	pub(super) const FLUSH: Duration = Duration::from_millis(150);
@@ -35,6 +36,8 @@ pub(super) struct Environment {
35	36	pub(super) host: RemoteHost,
36	37	pub(super) status: ConnectionStatus,
37	38	pub(super) client: Rc<RemoteClient>,
	39	+ /// Its environment settings, once it shared them.
	40	+ pub(super) settings: Option<Settings>,
38	41	_events: Task<()>,
39	42	}
40	43
@@ -53,6 +56,8 @@ pub(super) struct RemoteState {
53	56	dirty_threads: HashSet<String>,
54	57	state_dirty: bool,
55	58	last_state: String,
	59	+ /// The environment settings clients were last sent.
	60	+ last_settings: String,
56	61	pub(super) environments: Vec<Environment>,
57	62	_server_events: Option<Task<()>>,
58	63	}
@@ -67,6 +72,18 @@ pub struct RemoteOverview {
67	72	pub environments: Vec<(String, ConnectionStatus)>,
68	73	}
69	74
	75	+ /// An environment the settings view edits: this device or a connected one.
	76	+ pub struct SettingsEnvironment {
	77	+ /// The connection's id in the settings; `None` for this device.
	78	+ pub id: Option<String>,
	79	+ pub name: String,
	80	+ pub connected: bool,
	81	+ /// `None` until the device shared them; older versions never do.
	82	+ pub settings: Option<Settings>,
	83	+ /// Its projects, by name and path there.
	84	+ pub projects: Vec<(String, PathBuf)>,
	85	+ }
	86	+
70	87	impl Workspace {
71	88	/// Starts, stops or restarts the server and the connections to match the
72	89	/// settings.
@@ -137,7 +154,13 @@ impl Workspace {
137	154	}
138	155	}
139	156	});
140		- self.remote.environments.push(Environment { host, status: ConnectionStatus::Connecting, client, _events: task });
	157	+ self.remote.environments.push(Environment {
	158	+ host,
	159	+ status: ConnectionStatus::Connecting,
	160	+ client,
	161	+ settings: None,
	162	+ _events: task,
	163	+ });
141	164	}
142	165
143	166	/// Disconnects from a device and takes its projects and threads away.
@@ -177,6 +200,150 @@ impl Workspace {
177	200	}
178	201	}
179	202
	203	+ /// This device, then every connection, with the settings each one keeps.
	204	+ pub fn settings_environments(&self) -> Vec<SettingsEnvironment> {
	205	+ let projects = \|env: Option<&str>\| -> Vec<(String, PathBuf)> {
	206	+ let scratch = super::scratch_dir();
	207	+ self.projects
	208	+ .iter()
	209	+ .filter(\|project\| project.environment.as_deref() == env && Some(&project.path) != scratch.as_ref())
	210	+ .map(\|project\| (project.name.to_string(), project.path.clone()))
	211	+ .collect()
	212	+ };
	213	+ let this_device = SettingsEnvironment {
	214	+ id: None,
	215	+ name: hostname(),
	216	+ connected: true,
	217	+ settings: Some(settings::load()),
	218	+ projects: projects(None),
	219	+ };
	220	+ std::iter::once(this_device)
	221	+ .chain(self.remote.environments.iter().map(\|env\| SettingsEnvironment {
	222	+ id: Some(env.host.id.clone()),
	223	+ name: env.host.label(),
	224	+ connected: matches!(env.status, ConnectionStatus::Connected(_)),
	225	+ settings: env.settings.clone(),
	226	+ projects: projects(Some(&env.host.id)),
	227	+ }))
	228	+ .collect()
	229	+ }
	230	+
	231	+ /// Changes an environment's settings: this device's (`None`) at once,
	232	+ /// another's by asking it. The caller tells the open conversations.
	233	+ pub fn write_settings(&mut self, env: Option<&str>, patch: SettingsPatch, cx: &mut Context<Self>) {
	234	+ if patch.is_empty() {
	235	+ return;
	236	+ }
	237	+ match env {
	238	+ None => settings::apply(&patch),
	239	+ Some(env) => {
	240	+ let Some(environment) = self.remote.environments.iter_mut().find(\|candidate\| candidate.host.id == env) else {
	241	+ return;
	242	+ };
	243	+ environment.client.send(&ClientMessage::UpdateSettings { patch: patch.clone() });
	244	+ // Show the change now; the device confirms it with its settings.
	245	+ if let Some(settings) = environment.settings.as_mut() {
	246	+ settings.apply_patch(&patch);
	247	+ }
	248	+ }
	249	+ }
	250	+ cx.notify();
	251	+ }
	252	+
	253	+ /// The first time a device shares its settings and they differ from
	254	+ /// this device's, asks whether to give it this device's settings or
	255	+ /// leave its own as they are.
	256	+ fn offer_settings(&mut self, env: &str, window: &mut Window, cx: &mut Context<Self>) {
	257	+ let Some(environment) = self.remote.environments.iter_mut().find(\|candidate\| candidate.host.id == env) else { return };
	258	+ let Some(theirs) = environment.settings.as_ref().map(Settings::environment_values) else { return };
	259	+ // Asked once, whatever the answer.
	260	+ environment.host.settings_offered = true;
	261	+ let name = environment.host.label();
	262	+ settings::update(\|settings\| {
	263	+ if let Some(host) = settings.remotes.iter_mut().find(\|host\| host.id == env) {
	264	+ host.settings_offered = true;
	265	+ }
	266	+ });
	267	+ let mut ours = settings::get(Settings::environment_values);
	268	+ ours.remove("project_overrides");
	269	+ let differing: Vec<String> =
	270	+ ours.iter().filter(\|(key, value)\| theirs.get(*key) != Some(value)).map(\|(key, _)\| key.clone()).collect();
	271	+ if differing.is_empty() {
	272	+ return;
	273	+ }
	274	+ let list = crate::ui::settings::row_titles(&differing).join(", ");
	275	+ let workspace = cx.weak_entity();
	276	+ let env = env.to_string();
	277	+ window.open_dialog(cx, move \|dialog, _, cx\| {
	278	+ let p = crate::ui::metal::palette(cx);
	279	+ let (workspace, env, ours) = (workspace.clone(), env.clone(), ours.clone());
	280	+ let text = \|text: String\| div().text_size(px(13.)).line_height(px(19.)).text_color(p.ink2).child(text);
	281	+ dialog
	282	+ .title(format!("Use your settings on {name}?"))
	283	+ .w(px(480.))
	284	+ .child(
	285	+ gpui_kit::component::v_flex()
	286	+ .gap(px(10.))
	287	+ .child(text(format!(
	288	+ "{name} is connected. Its settings for new threads, worktrees and source control differ from this device's: {list}."
	289	+ )))
	290	+ .child(text(format!(
	291	+ "Use my settings gives {name} this device's. Leave as is keeps {name}'s own. Either way, you can change them later in Settings with {name} picked."
	292	+ ))),
	293	+ )
	294	+ .footer(
	295	+ gpui_kit::component::h_flex()
	296	+ .w_full()
	297	+ .justify_end()
	298	+ .gap(px(8.))
	299	+ .child(
	300	+ MetalButton::new("offer-settings-leave")
	301	+ .ghost()
	302	+ .compact()
	303	+ .label("Leave as is")
	304	+ .on_click(\|_, window, cx\| window.close_dialog(cx)),
	305	+ )
	306	+ .child(MetalButton::new("offer-settings-use").primary().compact().label("Use my settings").on_click(
	307	+ move \|_, window, cx\| {
	308	+ window.close_dialog(cx);
	309	+ let patch = SettingsPatch { values: ours.clone(), ..Default::default() };
	310	+ let _ = workspace.update(cx, \|workspace, cx\| workspace.write_settings(Some(&env), patch, cx));
	311	+ },
	312	+ )),
	313	+ )
	314	+ });
	315	+ }
	316	+
	317	+ /// Sends connected devices this device's environment settings, if they
	318	+ /// changed since they were last sent.
	319	+ pub(super) fn broadcast_settings(&mut self) {
	320	+ let Some(server) = &self.remote.server else { return };
	321	+ let values = settings::get(Settings::environment_values);
	322	+ let text = serde_json::to_string(&values).unwrap_or_default();
	323	+ if text != self.remote.last_settings {
	324	+ self.remote.last_settings = text;
	325	+ server.broadcast(&ServerMessage::Settings { values });
	326	+ }
	327	+ }
	328	+
	329	+ /// The settings a thread in this project starts with: its environment's,
	330	+ /// with the project's overrides.
	331	+ pub(super) fn project_settings(&self, project_ix: usize) -> Settings {
	332	+ let Some(project) = self.projects.get(project_ix) else { return settings::load() };
	333	+ match &project.environment {
	334	+ None => settings::get(\|settings\| settings.for_project(&project.path)),
	335	+ Some(env) => self
	336	+ .remote
	337	+ .environments
	338	+ .iter()
	339	+ .find(\|candidate\| candidate.host.id == *env)
	340	+ .and_then(\|env\| env.settings.as_ref())
	341	+ .map(\|settings\| settings.for_project(&project.path))
	342	+ // Until the device says, its threads start as this one's would.
	343	+ .unwrap_or_else(settings::load),
	344	+ }
	345	+ }
	346	+
180	347	pub fn disconnect_peer(&mut self, conn: u64, cx: &mut Context<Self>) {
181	348	if let Some(server) = &self.remote.server {
182	349	server.disconnect(conn);
@@ -238,6 +405,7 @@ impl Workspace {
238	405	match event {
239	406	ServerEvent::Connected { conn, name, address } => {
240	407	server.send(conn, &self.host_state(cx));
	408	+ server.send(conn, &ServerMessage::Settings { values: settings::get(Settings::environment_values) });
241	409	self.remote.peers.push(Peer { conn, name: name.clone(), address });
242	410	self.remote.subscriptions.insert(conn, HashMap::new());
243	411	if settings::get(\|settings\| settings.in_app_notifications) {
@@ -317,6 +485,11 @@ impl Workspace {
317	485	self.remote.state_dirty = true;
318	486	self.reply(conn, ServerMessage::Created { reference, thread: id });
319	487	}
	488	+ ClientMessage::UpdateSettings { patch } => {
	489	+ settings::apply(&patch);
	490	+ // Tells the open conversations, and every client, this one too.
	491	+ self.settings_changed(window, cx);
	492	+ }
320	493	}
321	494	}
322	495
@@ -473,6 +646,15 @@ impl Workspace {
473	646	let name = self.environment_name(env);
474	647	window.push_notification(Notification::error(message).title(name), cx);
475	648	}
	649	+ ClientEvent::Message(ServerMessage::Settings { values }) => {
	650	+ if let Some(environment) = self.remote.environments.iter_mut().find(\|candidate\| candidate.host.id == env) {
	651	+ environment.settings = Some(settings::with_values(&Settings::default(), &values));
	652	+ if !environment.host.settings_offered {
	653	+ self.offer_settings(env, window, cx);
	654	+ }
	655	+ }
	656	+ cx.notify();
	657	+ }
476	658	ClientEvent::Message(ServerMessage::Welcome { .. } \| ServerMessage::Denied { .. }) => {}
477	659	}
478	660	}