The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(vcs): Support several git repositories in one project (multi-root)
l0ng-ai059a5193ff27
diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rsindex 14f6f8f3f..4151a6c06 100644--- a/crates/ide-vcs/src/lib.rs+++ b/crates/ide-vcs/src/lib.rs@@ -268,6 +268,7 @@ mod patch;mod refs;mod remotes;mod repo;+mod roots;pub mod shelf;mod status;mod write;@@ -275,6 +276,7 @@ mod write;pub use cli::{detected_git_executable, git_version, set_git_executable};pub use diff::build_partial_patch;pub use remotes::Remote;+pub use roots::Repos;/// Clones `url` into `dest` (which must not exist or be empty), streaming progress.pub fn clone(url: &str, dest: &Path, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {@@ -320,6 +322,10 @@ impl Repo {pub fn branch_info(&self) -> IdeResult<BranchInfo> {refs::branch_info(self)}+ /// Merge / rebase / cherry-pick… in progress (cheap: no ref walking).+ pub fn operation(&self) -> IdeResult<Option<String>> {+ Ok(refs::operation(&self.gix()?))+ }/// Content of `path` at `rev` (default HEAD); `None` if absent there./// `rev` may be any revision git understands, or `":"` / `":0"` for the index.pub fn file_at(&self, path: &Path, rev: Option<&str>) -> IdeResult<Option<String>> {diff --git a/crates/ide-vcs/src/refs.rs b/crates/ide-vcs/src/refs.rsindex 985b353fb..5b7903054 100644--- a/crates/ide-vcs/src/refs.rs+++ b/crates/ide-vcs/src/refs.rs@@ -30,7 +30,7 @@ pub(crate) fn branch_info(r: &Repo) -> IdeResult<BranchInfo> {Ok(info)}-fn operation(repo: &gix::Repository) -> Option<String> {+pub(crate) fn operation(repo: &gix::Repository) -> Option<String> {use gix::state::InProgress::*;let op = match repo.state()? {ApplyMailbox | ApplyMailboxRebase => "am",diff --git a/crates/ide-vcs/src/roots.rs b/crates/ide-vcs/src/roots.rsnew file mode 100644index 000000000..d71abe72c--- /dev/null+++ b/crates/ide-vcs/src/roots.rs@@ -0,0 +1,203 @@+//! The repositories of a project (IDEA's VCS roots): the one containing the project+//! root plus those nested below it (separate clones side by side, submodules).++use crate::{FileStatus, Repo};+use ide_core::IdeResult;+use std::path::{Path, PathBuf};+use std::sync::Arc;++/// How deep below the project root nested repositories are looked for.+const MAX_DEPTH: usize = 4;++/// Folders never searched for nested repositories (dependencies, build output).+const SKIPPED: &[&str] = &["node_modules", "target", "build", "dist", "out", "vendor", "venv", "__pycache__"];++/// The repositories of a project, sorted by root; lookups pick the innermost one.+#[derive(Clone, Default)]+pub struct Repos {+ repos: Vec<Arc<Repo>>,+ primary: Option<usize>,+}++impl Repos {+ /// The repository containing `project_root` and every repository whose worktree+ /// root lies below it (up to [`MAX_DEPTH`] levels; hidden and dependency folders and+ /// folders `skip` rejects are not searched).+ pub fn discover(project_root: &Path, skip: &dyn Fn(&Path) -> bool) -> IdeResult<Self> {+ let mut repos: Vec<Repo> = Vec::new();+ if let Some(r) = Repo::discover(project_root)? {+ repos.push(r);+ }+ let mut stack: Vec<(PathBuf, usize)> = vec![(project_root.to_path_buf(), 0)];+ while let Some((dir, depth)) = stack.pop() {+ let Ok(entries) = std::fs::read_dir(&dir) else { continue };+ for entry in entries.flatten() {+ if !entry.file_type().is_ok_and(|t| t.is_dir()) {+ continue;+ }+ let name = entry.file_name();+ let name = name.to_string_lossy();+ let path = entry.path();+ if name.starts_with('.') || SKIPPED.contains(&name.as_ref()) || skip(&path) {+ continue;+ }+ if path.join(".git").exists()+ && let Ok(Some(r)) = Repo::discover(&path)+ && r.root() == path+ && !repos.iter().any(|x| x.root() == r.root())+ {+ repos.push(r);+ }+ if depth + 1 < MAX_DEPTH {+ stack.push((path, depth + 1));+ }+ }+ }+ Ok(Self::new(repos, project_root))+ }++ /// Only the repository containing `project_root` (the quick lookup on project open).+ pub fn enclosing(project_root: &Path) -> IdeResult<Self> {+ Ok(Self::new(Repo::discover(project_root)?.into_iter().collect(), project_root))+ }++ /// Worktree roots, sorted.+ pub fn roots(&self) -> Vec<PathBuf> {+ self.repos.iter().map(|r| r.root().to_path_buf()).collect()+ }++ fn new(mut repos: Vec<Repo>, project_root: &Path) -> Self {+ repos.sort_by(|a, b| a.root().cmp(b.root()));+ let repos: Vec<Arc<Repo>> = repos.into_iter().map(Arc::new).collect();+ let primary = Self::innermost(&repos, project_root).or((!repos.is_empty()).then_some(0));+ Self { repos, primary }+ }++ fn innermost(repos: &[Arc<Repo>], path: &Path) -> Option<usize> {+ repos+ .iter()+ .enumerate()+ .filter(|(_, r)| path.starts_with(r.root()))+ .max_by_key(|(_, r)| r.root().as_os_str().len())+ .map(|(i, _)| i)+ }++ pub fn is_empty(&self) -> bool {+ self.repos.is_empty()+ }++ pub fn all(&self) -> &[Arc<Repo>] {+ &self.repos+ }++ /// The repository of the project root, else the first one.+ pub fn primary(&self) -> Option<&Arc<Repo>> {+ self.primary.map(|i| &self.repos[i])+ }++ /// The innermost repository containing `path` (a file, folder or repository root).+ pub fn for_path(&self, path: &Path) -> Option<&Arc<Repo>> {+ Self::innermost(&self.repos, path).map(|i| &self.repos[i]).or_else(|| {+ // Another spelling of the same location (symlinks, /var vs /private/var).+ let canon = dunce::canonicalize(path).ok()?;+ self.repos+ .iter()+ .filter(|r| dunce::canonicalize(r.root()).is_ok_and(|root| canon.starts_with(root)))+ .max_by_key(|r| r.root().as_os_str().len())+ })+ }++ /// `paths` grouped by the repository each belongs to (paths outside every repository are dropped).+ pub fn group(&self, paths: &[PathBuf]) -> Vec<(Arc<Repo>, Vec<PathBuf>)> {+ let mut out: Vec<(Arc<Repo>, Vec<PathBuf>)> = Vec::new();+ for p in paths {+ let Some(repo) = self.for_path(p) else { continue };+ match out.iter_mut().find(|(r, _)| Arc::ptr_eq(r, repo)) {+ Some((_, list)) => list.push(p.clone()),+ None => out.push((repo.clone(), vec![p.clone()])),+ }+ }+ out+ }++ /// Changes of every repository. A nested repository reports its own files, so the+ /// enclosing one's "untracked folder" entry for it is dropped.+ pub fn status(&self) -> IdeResult<Vec<FileStatus>> {+ let mut out = Vec::new();+ for repo in &self.repos {+ let nested: Vec<&Path> = self+ .repos+ .iter()+ .map(|r| r.root())+ .filter(|r| *r != repo.root() && r.starts_with(repo.root()))+ .collect();+ out.extend(repo.status()?.into_iter().filter(|f| {+ let untracked_root =+ f.unstaged == Some(crate::ChangeKind::Untracked) && nested.iter().any(|n| f.path.0 == *n);+ !untracked_root+ }));+ }+ Ok(out)+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::process::Command;++ fn git_init(dir: &Path) {+ std::fs::create_dir_all(dir).unwrap();+ let ok = Command::new("git").args(["init", "-q"]).current_dir(dir).status().is_ok_and(|s| s.success());+ assert!(ok, "git init in {}", dir.display());+ }++ #[test]+ fn finds_nested_repositories_and_routes_paths() {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap();+ git_init(&root);+ git_init(&root.join("services/api"));+ git_init(&root.join("web"));+ git_init(&root.join("node_modules/dep"));+ git_init(&root.join(".cache/repo"));+ std::fs::write(root.join("services/api/main.rs"), "fn main() {}").unwrap();+ std::fs::write(root.join("README.md"), "x").unwrap();++ let repos = Repos::discover(&root, &|_| false).unwrap();+ let roots: Vec<&Path> = repos.all().iter().map(|r| r.root()).collect();+ assert_eq!(roots, [root.as_path(), &root.join("services/api"), &root.join("web")]);+ assert_eq!(repos.primary().unwrap().root(), root);+ assert_eq!(repos.for_path(&root.join("services/api/main.rs")).unwrap().root(), root.join("services/api"));+ assert_eq!(repos.for_path(&root.join("services/other.txt")).unwrap().root(), root);++ let status = repos.status().unwrap();+ let paths: Vec<String> =+ status.iter().map(|f| f.path.0.strip_prefix(&root).unwrap().to_string_lossy().into_owned()).collect();+ assert!(paths.contains(&"README.md".to_owned()), "{paths:?}");+ assert!(paths.contains(&"services/api/main.rs".to_owned()), "{paths:?}");+ assert!(+ !paths.iter().any(|p| p.trim_end_matches('/') == "web"),+ "nested root is not an untracked folder: {paths:?}"+ );++ let groups = repos.group(&[root.join("README.md"), root.join("services/api/main.rs"), root.join("web/x")]);+ assert_eq!(groups.len(), 3);+ assert_eq!(groups[1].1, [root.join("services/api/main.rs")]);++ let skipped = Repos::discover(&root, &|p| p.ends_with("services")).unwrap();+ assert_eq!(skipped.all().len(), 2);+ }++ #[test]+ fn side_by_side_repositories_without_an_enclosing_one() {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap();+ git_init(&root.join("a"));+ git_init(&root.join("b"));+ let repos = Repos::discover(&root, &|_| false).unwrap();+ assert_eq!(repos.all().len(), 2);+ assert_eq!(repos.primary().unwrap().root(), root.join("a"), "the first when none contains the project root");+ assert!(repos.for_path(&root.join("c.txt")).is_none());+ }+}diff --git a/src-tauri/src/commands/app.rs b/src-tauri/src/commands/app.rsindex 34ed04aff..df5641283 100644--- a/src-tauri/src/commands/app.rs+++ b/src-tauri/src/commands/app.rs@@ -71,7 +71,7 @@ pub async fn open_project(window: Window, path: PathBuf) -> IdeResult<ProjectInffn project_info(project: &crate::state::Project) -> ProjectInfo {ProjectInfo {name: project.root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),- is_git: project.repo.lock().is_some(),+ is_git: !project.repos.read().is_empty(),settings: project.settings.effective(),root: project.root.clone().into(),}diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex e56caeb2f..4c4f60fab 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -129,6 +129,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {lsp::apply_workspace_edit,lsp::lsp_execute_command,vcs::vcs_status,+ vcs::vcs_roots,vcs::vcs_branch_info,vcs::vcs_line_hunks,vcs::vcs_file_at,diff --git a/src-tauri/src/commands/vcs.rs b/src-tauri/src/commands/vcs.rsindex 196076c57..8fd0da6f6 100644--- a/src-tauri/src/commands/vcs.rs+++ b/src-tauri/src/commands/vcs.rs@@ -1,4 +1,4 @@-use crate::state::AppState;+use crate::state::{AppState, Project};use ide_core::{IdeResult, RequestId};use ide_vcs::*;use serde::{Deserialize, Serialize};@@ -13,18 +13,59 @@ pub(crate) fn apply_git_executable(settings: &ide_core::settings::Settings) {ide_vcs::set_git_executable((!exe.is_empty()).then(|| Path::new(exe)));}+/// Changes of every repository of the project.#[tauri::command]#[specta::specta]pub async fn vcs_status(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<FileStatus>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.status())).await+ blocking(move || {+ let settings = project.settings.effective();+ apply_git_executable(&settings);+ let repos = project.repos();+ if repos.is_empty() {+ return Err(ide_core::IdeError::unavailable("project is not a git repository"));+ }+ for r in repos.all() {+ r.set_ignored_names(settings.ignored_names());+ }+ repos.status()+ })+ .await+}++/// A repository of the project (IDEA's VCS root).+#[derive(Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct VcsRoot {+ /// Worktree root.+ pub root: ide_core::IpcPath,+ /// Merge / rebase / cherry-pick / revert in progress.+ pub operation: Option<String>,}+/// The project's repositories, the primary one first.#[tauri::command]#[specta::specta]-pub async fn vcs_branch_info(window: Window, state: State<'_, AppState>) -> IdeResult<BranchInfo> {+pub fn vcs_roots(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<VcsRoot>> {+ let repos = state.project(window.label())?.repos();+ let primary = repos.primary().map(|r| r.root().to_path_buf());+ let mut all: Vec<&std::sync::Arc<Repo>> = repos.all().iter().collect();+ all.sort_by_key(|r| Some(r.root()) != primary.as_deref());+ Ok(all+ .into_iter()+ .map(|r| VcsRoot { root: r.root().to_path_buf().into(), operation: r.operation().ok().flatten() })+ .collect())+}++#[tauri::command]+#[specta::specta]+pub async fn vcs_branch_info(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+) -> IdeResult<BranchInfo> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.branch_info())).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branch_info())).await}/// Gutter change markers for a file, computed against its current (unsaved) text.@@ -33,7 +74,7 @@ pub async fn vcs_branch_info(window: Window, state: State<'_, AppState>) -> IdeRpub fn vcs_line_hunks(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<LineHunk>> {let project = state.project(window.label())?;let text = project.text_of(&path)?;- project.with_repo(|r| r.line_hunks(&path, &text, false))+ project.with_repo_at(Some(&path), |r| r.line_hunks(&path, &text, false))}#[tauri::command]@@ -45,7 +86,7 @@ pub async fn vcs_file_at(rev: Option<String>,) -> IdeResult<Option<String>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.file_at(&path, rev.as_deref()))).await+ blocking(move || project.with_repo_at(Some(&path), |r| r.file_at(&path, rev.as_deref()))).await}#[tauri::command]@@ -53,14 +94,19 @@ pub async fn vcs_file_at(pub async fn vcs_blame(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<BlameLine>> {let project = state.project(window.label())?;let text = project.documents.text_of(&path);- blocking(move || project.with_repo(|r| r.blame(&path, text.as_deref()))).await+ blocking(move || project.with_repo_at(Some(&path), |r| r.blame(&path, text.as_deref()))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_log(window: Window, state: State<'_, AppState>, query: LogQuery) -> IdeResult<Vec<Commit>> {+pub async fn vcs_log(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ query: LogQuery,+) -> IdeResult<Vec<Commit>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.log(&query))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.log(&query))).await}#[tauri::command]@@ -68,38 +114,39 @@ pub async fn vcs_log(window: Window, state: State<'_, AppState>, query: LogQuerypub async fn vcs_commit_files(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,commit: String,) -> IdeResult<Vec<ChangedFile>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.commit_files(&commit))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commit_files(&commit))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_branches(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<Branch>> {+pub async fn vcs_branches(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Branch>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.branches())).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branches())).await}#[tauri::command]#[specta::specta]-pub async fn vcs_stashes(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<Stash>> {+pub async fn vcs_stashes(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Stash>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.stashes())).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.stashes())).await}#[tauri::command]#[specta::specta]pub async fn vcs_stage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.stage(&paths))).await+ blocking(move || per_repo(&project, &paths, None, |r, paths| r.stage(paths))).await}#[tauri::command]#[specta::specta]pub async fn vcs_unstage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.unstage(&paths))).await+ blocking(move || per_repo(&project, &paths, None, |r, paths| r.unstage(paths))).await}#[tauri::command]@@ -113,7 +160,7 @@ pub async fn vcs_stage_patch(window: Window, state: State<'_, AppState>, patch:#[specta::specta]pub async fn vcs_discard(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo_recorded(Some("Rollback"), |r| r.discard(&paths))).await+ blocking(move || per_repo(&project, &paths, Some("Rollback"), |r, paths| r.discard(paths))).await}#[tauri::command]@@ -121,19 +168,27 @@ pub async fn vcs_discard(window: Window, state: State<'_, AppState>, paths: Vec<pub async fn vcs_commit(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,message: String,options: CommitOptions,) -> IdeResult<String> {// Commit hooks may run for a long time.let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.commit_with(&message, &options))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commit_with(&message, &options))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_checkout(window: Window, state: State<'_, AppState>, branch: String, create: bool) -> IdeResult<()> {+pub async fn vcs_checkout(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ branch: String,+ create: bool,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo_recorded(Some("Git checkout"), |r| r.checkout(&branch, create))).await+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git checkout"), |r| r.checkout(&branch, create)))+ .await}/// New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out.@@ -142,22 +197,31 @@ pub async fn vcs_checkout(window: Window, state: State<'_, AppState>, branch: Stpub async fn vcs_create_branch(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,name: String,start: Option<String>,checkout: bool,) -> IdeResult<()> {let project = state.project(window.label())?;let recorded = checkout.then_some("Git checkout");- blocking(move || project.with_repo_recorded(recorded, |r| r.create_branch(&name, start.as_deref(), checkout))).await+ blocking(move || {+ project.with_repo_recorded(repo.as_deref(), recorded, |r| r.create_branch(&name, start.as_deref(), checkout))+ })+ .await}/// Undo Commit: moves HEAD back to the commit's parent, keeping its changes staged./// Returns the undone commit's message.#[tauri::command]#[specta::specta]-pub async fn vcs_undo_commit(window: Window, state: State<'_, AppState>, commit: String) -> IdeResult<String> {+pub async fn vcs_undo_commit(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ commit: String,+) -> IdeResult<String> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.undo_commit(&commit))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.undo_commit(&commit))).await}#[tauri::command]@@ -165,32 +229,49 @@ pub async fn vcs_undo_commit(window: Window, state: State<'_, AppState>, commit:pub async fn vcs_delete_branch(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,branch: String,force: bool,) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.delete_branch(&branch, force))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.delete_branch(&branch, force))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_rename_branch(window: Window, state: State<'_, AppState>, from: String, to: String) -> IdeResult<()> {+pub async fn vcs_rename_branch(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ from: String,+ to: String,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.rename_branch(&from, &to))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_merge(window: Window, state: State<'_, AppState>, branch: String) -> IdeResult<()> {+pub async fn vcs_merge(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ branch: String,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo_recorded(Some("Git merge"), |r| r.merge(&branch))).await+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git merge"), |r| r.merge(&branch))).await}#[tauri::command]#[specta::specta]-pub async fn vcs_rebase(window: Window, state: State<'_, AppState>, onto: String) -> IdeResult<()> {+pub async fn vcs_rebase(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ onto: String,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo_recorded(Some("Git rebase"), |r| r.rebase(&onto))).await+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git rebase"), |r| r.rebase(&onto))).await}#[tauri::command]@@ -198,28 +279,43 @@ pub async fn vcs_rebase(window: Window, state: State<'_, AppState>, onto: Stringpub async fn vcs_stash_push(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,message: Option<String>,include_untracked: bool,) -> IdeResult<()> {let project = state.project(window.label())?;blocking(move || {- project.with_repo_recorded(Some("Git stash"), |r| r.stash_push(message.as_deref(), include_untracked))+ project.with_repo_recorded(repo.as_deref(), Some("Git stash"), |r| {+ r.stash_push(message.as_deref(), include_untracked)+ })}).await}#[tauri::command]#[specta::specta]-pub async fn vcs_stash_apply(window: Window, state: State<'_, AppState>, index: u32, pop: bool) -> IdeResult<()> {+pub async fn vcs_stash_apply(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ index: u32,+ pop: bool,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo_recorded(Some("Git unstash"), |r| r.stash_apply(index, pop))).await+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git unstash"), |r| r.stash_apply(index, pop)))+ .await}#[tauri::command]#[specta::specta]-pub async fn vcs_stash_drop(window: Window, state: State<'_, AppState>, index: u32) -> IdeResult<()> {+pub async fn vcs_stash_drop(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ index: u32,+) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.stash_drop(index))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.stash_drop(index))).await}#[derive(Clone, Serialize, Deserialize, Type)]@@ -258,6 +354,7 @@ pub enum RemoteOp {pub async fn vcs_remote(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,request: RequestId,op: RemoteOp,on_output: Channel<String>,@@ -269,7 +366,7 @@ pub async fn vcs_remote(let _ = on_output.send(line);};let recorded = matches!(op, RemoteOp::Pull { .. }).then_some("Git pull");- project.with_repo_recorded(recorded, |r| match op {+ project.with_repo_recorded(repo.as_deref(), recorded, |r| match op {RemoteOp::Fetch => r.fetch(&cancel, &out),RemoteOp::Pull { rebase } => r.pull(rebase, &cancel, &out),RemoteOp::Push { force_with_lease, set_upstream, tags } => {@@ -304,7 +401,7 @@ pub async fn vcs_conflict_versions() -> IdeResult<ConflictVersions> {let project = state.project(window.label())?;blocking(move || {- project.with_repo(|r| {+ project.with_repo_at(Some(&path), |r| {r.conflict_versions(&path).map(|(base, ours, theirs)| ConflictVersions { base, ours, theirs })})})@@ -320,7 +417,7 @@ pub async fn vcs_diff_text(staged: bool,) -> IdeResult<String> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.diff_text(&path, staged))).await+ blocking(move || project.with_repo_at(Some(&path), |r| r.diff_text(&path, staged))).await}/// Line hunks between two arbitrary texts (diff viewer, commit dialog).@@ -337,7 +434,7 @@ pub fn vcs_diff_hunks(old_text: String, new_text: String) -> Vec<LineHunk> {pub fn vcs_stage_hunks(window: Window, state: State<'_, AppState>, path: PathBuf, hunks: Vec<u32>) -> IdeResult<()> {let project = state.project(window.label())?;let current = ide_vfs::load_text(&path)?.text;- project.with_repo(|r| {+ project.with_repo_at(Some(&path), |r| {let index_text = r.file_at(&path, Some(":0"))?.unwrap_or_default();let rel = path.strip_prefix(r.root()).unwrap_or(&path).to_string_lossy().replace('\\', "/");let selected: Vec<usize> = hunks.iter().map(|&h| h as usize).collect();@@ -408,9 +505,14 @@ pub fn vcs_detected_git() -> Option<String> {/// `git config --get <key>` in the project repository; `None` when unset.#[tauri::command]#[specta::specta]-pub async fn vcs_config_get(window: Window, state: State<'_, AppState>, key: String) -> IdeResult<Option<String>> {+pub async fn vcs_config_get(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ key: String,+) -> IdeResult<Option<String>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.config_get(&key))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.config_get(&key))).await}// ---- in-progress operations, history rewriting (Git Log actions) ----@@ -448,6 +550,7 @@ pub enum GitOperation {pub async fn vcs_operation(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,request: RequestId,op: GitOperation,on_output: Channel<String>,@@ -465,7 +568,7 @@ pub async fn vcs_operation(GitOperation::InteractiveRebase { .. } => Some("Git rebase"),_ => None,};- project.with_repo_recorded(recorded, |r| match op {+ project.with_repo_recorded(repo.as_deref(), recorded, |r| match op {GitOperation::Continue => r.continue_operation(&cancel, &out),GitOperation::Abort => r.abort_operation(&cancel, &out),GitOperation::Skip => r.skip_operation(&cancel, &out),@@ -488,20 +591,22 @@ pub async fn vcs_operation(pub async fn vcs_create_tag(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,name: String,commit: String,message: Option<String>,force: bool,) -> IdeResult<()> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.create_tag(&name, &commit, message.as_deref(), force))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.create_tag(&name, &commit, message.as_deref(), force)))+ .await}#[tauri::command]#[specta::specta]-pub async fn vcs_tags(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<String>> {+pub async fn vcs_tags(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<String>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.tags())).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.tags())).await}/// Compare with Local: tracked files that differ between `rev` and the working tree.@@ -510,10 +615,28 @@ pub async fn vcs_tags(window: Window, state: State<'_, AppState>) -> IdeResult<Vpub async fn vcs_diff_with_worktree(window: Window,state: State<'_, AppState>,+ repo: Option<PathBuf>,rev: String,) -> IdeResult<Vec<ChangedFile>> {let project = state.project(window.label())?;- blocking(move || project.with_repo(|r| r.diff_with_worktree(&rev))).await+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.diff_with_worktree(&rev))).await+}++/// Runs `f` once per repository with the `paths` that belong to it.+fn per_repo(+ project: &Project,+ paths: &[PathBuf],+ recorded: Option<&str>,+ f: impl Fn(&Repo, &[PathBuf]) -> IdeResult<()>,+) -> IdeResult<()> {+ let groups = project.repos().group(paths);+ if groups.is_empty() {+ return project.with_repo_recorded(None, recorded, |r| f(r, paths));+ }+ for (repo, paths) in groups {+ project.with_repo_recorded(Some(repo.root()), recorded, |r| f(r, &paths))?;+ }+ Ok(())}async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {@@ -587,7 +710,7 @@ pub async fn vcs_shelve(let project = state.project(window.label())?;blocking(move || {keep_private(&project.root);- project.with_repo_recorded(Some("Shelve"), |r| r.shelve(&shelf_dir(&project.root), &name, &paths))+ project.with_repo_recorded(None, Some("Shelve"), |r| r.shelve(&shelf_dir(&project.root), &name, &paths))}).await}@@ -611,7 +734,7 @@ pub async fn vcs_unshelve() -> IdeResult<ApplyOutcome> {let project = state.project(window.label())?;blocking(move || {- project.with_repo_recorded(Some("Unshelve"), |r| r.unshelve(&shelf_dir(&project.root), &id, remove))+ project.with_repo_recorded(None, Some("Unshelve"), |r| r.unshelve(&shelf_dir(&project.root), &id, remove))}).await}diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rsindex 02fd62738..5fe94c1d1 100644--- a/src-tauri/src/state.rs+++ b/src-tauri/src/state.rs@@ -8,7 +8,7 @@ use ide_run::ProcessManager;use ide_syntax::StructureService;use ide_terminal::TerminalManager;use ide_text::{AppliedChange, ByteEdit};-use ide_vcs::Repo;+use ide_vcs::{Repo, Repos};use ide_vfs::Watcher;use ide_workspace::documents::DocumentObserver;use ide_workspace::{@@ -56,7 +56,8 @@ pub struct Project {pub moves: FileMoves,pub index: Arc<ProjectIndex>,pub lsp: Arc<LspManager>,- pub repo: Mutex<Option<Repo>>,+ /// Git repositories: the one containing the project root and those nested below it.+ pub repos: Arc<RwLock<Repos>>,/// Incrementally maintained syntax trees of the open documents.pub syntax: Arc<SyntaxCache>,/// Tree-sitter structure queries (LSP fallback) over `syntax`.@@ -279,7 +280,10 @@ impl AppState {documents.add_observer(Arc::new(LspObserver(lsp.clone())));documents.add_observer(Arc::new(HistoryObserver(history.clone())));+ let repos = Arc::new(RwLock::new(Repos::enclosing(&root)?));let watcher = {+ let repos = repos.clone();+ let settings = settings.clone();let index = index.clone();let documents = documents.clone();let sink = sink.clone();@@ -305,6 +309,12 @@ impl AppState {sink.emit(IdeEvent::ProjectRootsChanged { root: root.clone().into() });}}+ // A repository was cloned / initialised / removed below the project.+ let git_dirs =+ changed.iter().chain(&batch.removed).any(|p| p.file_name().is_some_and(|n| n == ".git"));+ if git_dirs {+ scan_repositories(&root, &repos, &settings, &sink);+ }sink.emit(IdeEvent::VcsChanged { root: root.clone().into() });}),)?@@ -331,8 +341,13 @@ impl AppState {};mark("watcher");- let repo = Repo::discover(&root)?;- let branch = repo.as_ref().and_then(|r| r.branch_info().ok()).and_then(|b| b.head);+ let branch = repos.read().primary().and_then(|r| r.branch_info().ok()).and_then(|b| b.head);+ {+ let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());+ std::thread::Builder::new()+ .name("openidea-vcs-roots".into())+ .spawn(move || scan_repositories(&root, &repos, &settings, &sink))?;+ }mark("git");self.recent.touch(&root, branch)?;mark("recent");@@ -349,7 +364,7 @@ impl AppState {moves: FileMoves::new(),index,lsp,- repo: Mutex::new(repo),+ repos,structure: Arc::new(StructureService::new(syntax.clone())),syntax,detected_roots,@@ -391,12 +406,39 @@ impl AppState {}}+/// Looks for repositories nested below the project (and the one containing it);+/// emits `VcsChanged` when the set of roots changed.+fn scan_repositories(root: &Path, repos: &RwLock<Repos>, settings: &SettingsStore, sink: &SharedSink) {+ let ignored = settings.effective().ignored_names();+ let skip = |p: &Path| p.file_name().is_some_and(|n| ignored.is_ignored_name(&n.to_string_lossy()));+ match Repos::discover(root, &skip) {+ Ok(found) => {+ if found.roots() != repos.read().roots() {+ *repos.write() = found;+ sink.emit(IdeEvent::VcsChanged { root: root.to_path_buf().into() });+ }+ }+ Err(e) => tracing::warn!("looking for git repositories: {e}"),+ }+}+impl Project {- /// Runs `f` with the git repository, or fails when the project is not under git.- pub fn with_repo<T>(&self, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {+ /// The project's git repositories.+ pub fn repos(&self) -> Repos {+ self.repos.read().clone()+ }++ /// Runs `f` with the repository containing `at` (a path in it or its root), the+ /// project's primary repository when `None`; fails when there is none.+ pub fn with_repo_at<T>(&self, at: Option<&Path>, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {let settings = self.settings.effective();crate::commands::vcs::apply_git_executable(&settings);- match self.repo.lock().as_ref() {+ let repos = self.repos();+ let repo = match at {+ Some(path) => repos.for_path(path),+ None => repos.primary(),+ };+ match repo {Some(repo) => {repo.set_ignored_names(settings.ignored_names());f(repo)@@ -405,25 +447,31 @@ impl Project {}}+ /// Runs `f` with the project's primary git repository, or fails when the project is not under git.+ pub fn with_repo<T>(&self, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {+ self.with_repo_at(None, f)+ }+/// Runs a VCS operation that rewrites the working tree (checkout, merge,/// rebase, pull, reset, stash, rollback): Local History gets a label and a/// snapshot of every locally changed file before, and a label after./// `None` runs `f` like [`with_repo`](Self::with_repo) (operations that keep the working tree).pub fn with_repo_recorded<T>(&self,+ at: Option<&Path>,operation: Option<&str>,f: impl FnOnce(&Repo) -> IdeResult<T>,) -> IdeResult<T> {- let Some(name) = operation else { return self.with_repo(f) };+ let Some(name) = operation else { return self.with_repo_at(at, f) };self.history_label(&format!("Before {name}"));- if let Ok(changed) = self.with_repo(|r| r.status()) {+ if let Ok(changed) = self.with_repo_at(at, |r| r.status()) {for file in changed.iter().take(HISTORY_BATCH_LIMIT) {if let Err(e) = self.history.record_file(&file.path, &format!("Before {name}"), false) {tracing::debug!("local history: {e}");}}}- let result = self.with_repo(f);+ let result = self.with_repo_at(at, f);self.history_label(&format!("After {name}"));result}diff --git a/src/bindings.ts b/src/bindings.tsindex c5ce3d46e..2afc23058 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -251,37 +251,39 @@ export const commands = {lspExecuteCommand: (doc: DocId, command: Command) => typedError<null, IdeError>(__TAURI_INVOKE("lsp_execute_command", { doc, command })),/** Changes of every repository of the project. */vcsStatus: () => typedError<FileStatus[], IdeError>(__TAURI_INVOKE("vcs_status")),- vcsBranchInfo: () => typedError<BranchInfo, IdeError>(__TAURI_INVOKE("vcs_branch_info")),+ /** The project's repositories, the primary one first. */+ vcsRoots: () => typedError<VcsRoot[], IdeError>(__TAURI_INVOKE("vcs_roots")),+ vcsBranchInfo: (repo: string | null) => typedError<BranchInfo, IdeError>(__TAURI_INVOKE("vcs_branch_info", { repo })),/** Gutter change markers for a file, computed against its current (unsaved) text. */vcsLineHunks: (path: string) => typedError<LineHunk[], IdeError>(__TAURI_INVOKE("vcs_line_hunks", { path })),vcsFileAt: (path: string, rev: string | null) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_file_at", { path, rev })),vcsBlame: (path: string) => typedError<BlameLine[], IdeError>(__TAURI_INVOKE("vcs_blame", { path })),- vcsLog: (query: LogQuery) => typedError<Commit[], IdeError>(__TAURI_INVOKE("vcs_log", { query })),- vcsCommitFiles: (commit: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_commit_files", { commit })),- vcsBranches: () => typedError<Branch[], IdeError>(__TAURI_INVOKE("vcs_branches")),- vcsStashes: () => typedError<Stash[], IdeError>(__TAURI_INVOKE("vcs_stashes")),+ vcsLog: (repo: string | null, query: LogQuery) => typedError<Commit[], IdeError>(__TAURI_INVOKE("vcs_log", { repo, query })),+ vcsCommitFiles: (repo: string | null, commit: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_commit_files", { repo, commit })),+ vcsBranches: (repo: string | null) => typedError<Branch[], IdeError>(__TAURI_INVOKE("vcs_branches", { repo })),+ vcsStashes: (repo: string | null) => typedError<Stash[], IdeError>(__TAURI_INVOKE("vcs_stashes", { repo })),vcsStage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage", { paths })),vcsUnstage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_unstage", { paths })),vcsStagePatch: (patch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage_patch", { patch })),vcsDiscard: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_discard", { paths })),- vcsCommit: (message: string, options: CommitOptions) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_commit", { message, options })),- vcsCheckout: (branch: string, create: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_checkout", { branch, create })),- vcsDeleteBranch: (branch: string, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_delete_branch", { branch, force })),+ vcsCommit: (repo: string | null, message: string, options: CommitOptions) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_commit", { repo, message, options })),+ vcsCheckout: (repo: string | null, branch: string, create: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_checkout", { repo, branch, create })),+ vcsDeleteBranch: (repo: string | null, branch: string, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_delete_branch", { repo, branch, force })),/** New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out. */- vcsCreateBranch: (name: string, start: string | null, checkout: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_branch", { name, start, checkout })),+ vcsCreateBranch: (repo: string | null, name: string, start: string | null, checkout: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_branch", { repo, name, start, checkout })),/*** Undo Commit: moves HEAD back to the commit's parent, keeping its changes staged.* Returns the undone commit's message.*/- vcsUndoCommit: (commit: string) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_undo_commit", { commit })),- vcsRenameBranch: (from: string, to: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rename_branch", { from, to })),- vcsMerge: (branch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_merge", { branch })),- vcsRebase: (onto: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rebase", { onto })),- vcsStashPush: (message: string | null, includeUntracked: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_push", { message, includeUntracked })),- vcsStashApply: (index: number, pop: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_apply", { index, pop })),- vcsStashDrop: (index: number) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_drop", { index })),+ vcsUndoCommit: (repo: string | null, commit: string) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_undo_commit", { repo, commit })),+ vcsRenameBranch: (repo: string | null, from: string, to: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rename_branch", { repo, from, to })),+ vcsMerge: (repo: string | null, branch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_merge", { repo, branch })),+ vcsRebase: (repo: string | null, onto: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rebase", { repo, onto })),+ vcsStashPush: (repo: string | null, message: string | null, includeUntracked: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_push", { repo, message, includeUntracked })),+ vcsStashApply: (repo: string | null, index: number, pop: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_apply", { repo, index, pop })),+ vcsStashDrop: (repo: string | null, index: number) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_drop", { repo, index })),/** Network operation; progress lines stream through `on_output`. Cancellable. */- vcsRemote: (request: RequestId, op: RemoteOp, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_remote", { request, op, onOutput })),+ vcsRemote: (repo: string | null, request: RequestId, op: RemoteOp, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_remote", { repo, request, op, onOutput })),vcsConflictVersions: (path: string) => typedError<ConflictVersions, IdeError>(__TAURI_INVOKE("vcs_conflict_versions", { path })),vcsDiffText: (path: string, staged: boolean) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_diff_text", { path, staged })),/** Line hunks between two arbitrary texts (diff viewer, commit dialog). */@@ -301,16 +303,16 @@ export const commands = {/** The auto-detected git executable (shown as the field's placeholder). */vcsDetectedGit: () => __TAURI_INVOKE<string | null>("vcs_detected_git"),/** `git config --get <key>` in the project repository; `None` when unset. */- vcsConfigGet: (key: string) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_config_get", { key })),+ vcsConfigGet: (repo: string | null, key: string) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_config_get", { repo, key })),/*** Local history operation that may take a while (hooks, large checkouts); git's* output streams through `on_output`. Cancellable.*/- vcsOperation: (request: RequestId, op: GitOperation, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_operation", { request, op, onOutput })),- vcsCreateTag: (name: string, commit: string, message: string | null, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_tag", { name, commit, message, force })),- vcsTags: () => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_tags")),+ vcsOperation: (repo: string | null, request: RequestId, op: GitOperation, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_operation", { repo, request, op, onOutput })),+ vcsCreateTag: (repo: string | null, name: string, commit: string, message: string | null, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_tag", { repo, name, commit, message, force })),+ vcsTags: (repo: string | null) => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_tags", { repo })),/** Compare with Local: tracked files that differ between `rev` and the working tree. */- vcsDiffWithWorktree: (rev: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_with_worktree", { rev })),+ vcsDiffWithWorktree: (repo: string | null, rev: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_with_worktree", { repo, rev })),vcsCreatePatch: (source: PatchSource) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_create_patch", { source })),vcsPatchPreview: (patch: string) => typedError<PatchFile[], IdeError>(__TAURI_INVOKE("vcs_patch_preview", { patch })),vcsApplyPatch: (patch: string) => typedError<ApplyOutcome, IdeError>(__TAURI_INVOKE("vcs_apply_patch", { patch })),@@ -3898,6 +3900,14 @@ export type VcsConfirmationSettings = {onDelete?: string,};+/** A repository of the project (IDEA's VCS root). */+export type VcsRoot = {+ /** Worktree root. */+ root: IpcPath,+ /** Merge / rebase / cherry-pick / revert in progress. */+ operation: string | null,+};+/** Version Control (main page) and its sub-pages. */export type VcsSettings = {/** Colour folders that contain changed files (project tree, tabs). */diff --git a/src/features/github/dialogs.tsx b/src/features/github/dialogs.tsxindex 1505d1524..7f6a49a1c 100644--- a/src/features/github/dialogs.tsx+++ b/src/features/github/dialogs.tsx@@ -71,7 +71,7 @@ function CreateDialog(props: {useEffect(() => {let alive = true;// Base candidates: branches of the remotes (without `origin/`), the default first.- call(commands.vcsBranches())+ call(commands.vcsBranches(null)).then((branches) => {const names = new Set<string>();if (props.defaultBase) names.add(props.defaultBase);diff --git a/src/features/github/ops.ts b/src/features/github/ops.tsindex c90d47d69..27805772d 100644--- a/src/features/github/ops.ts+++ b/src/features/github/ops.ts@@ -89,7 +89,7 @@ export async function createPullRequest() {let needsPush = true;let title = "";try {- const info = await call(commands.vcsBranchInfo());+ const info = await call(commands.vcsBranchInfo(null));head = info.head;needsPush = !info.upstream || info.ahead > 0;if (head) title = head.replace(/^[^/]+\//, "").replace(/[-_]+/g, " ").replace(/^\w/, (c) => c.toUpperCase());diff --git a/src/features/vcs/BranchWidget.module.css b/src/features/vcs/BranchWidget.module.cssindex 4ac83eec5..ba171ece7 100644--- a/src/features/vcs/BranchWidget.module.css+++ b/src/features/vcs/BranchWidget.module.css@@ -18,6 +18,48 @@overflow: hidden;text-overflow: ellipsis;}+.repo {+ flex: none;+ max-width: 120px;+ overflow: hidden;+ text-overflow: ellipsis;+ color: var(--fg-muted);+}+.repo::after {+ content: " /";+ color: var(--fg-subtle);+}+.repos {+ flex: none;+ display: flex;+ flex-wrap: wrap;+ gap: 4px;+ padding: 6px 8px;+ border-bottom: 1px solid var(--border-popup);+}+.repoButton {+ max-width: 160px;+ height: 22px;+ padding: 0 8px;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+ border: none;+ border-radius: var(--radius-small);+ background: transparent;+ color: var(--fg-secondary);+ font: inherit;+ font-size: var(--fs-small);+ cursor: pointer;+}+.repoButton:hover {+ background: var(--bg-hover);+}+.repoSelected,+.repoSelected:hover {+ background: var(--bg-selected);+ color: var(--fg);+}.operation {color: var(--warning);font-size: var(--fs-tiny);diff --git a/src/features/vcs/BranchWidget.tsx b/src/features/vcs/BranchWidget.tsxindex c91c575f3..64574a255 100644--- a/src/features/vcs/BranchWidget.tsx+++ b/src/features/vcs/BranchWidget.tsx@@ -19,7 +19,7 @@ import { buildBranchRows, type BranchRow, type PopupAction } from "./branches";import { branchMenu } from "./branchMenu";import { recentBranches } from "./branchOps";import { inProgress, operationTitle, type InProgress } from "./operations";-import { loadBranches, useVcs } from "./store";+import { loadBranches, repoName, selectRepo, useVcs } from "./store";import styles from "./BranchWidget.module.css";export const useBranchesPopup = create<{ open: boolean }>(() => ({ open: false }));@@ -34,6 +34,8 @@ export function headLabel(branch: { head: string | null; headCommit: string | nuexport function BranchWidget() {const available = useVcs((s) => s.available);const branch = useVcs((s) => s.branch);+ // With several repositories the widget names the selected one, like IDEA's.+ const repo = useVcs((s) => (s.roots.length > 1 && s.repo ? repoName(s.repo) : null));const open = useBranchesPopup((s) => s.open);const ref = useRef<HTMLButtonElement>(null);if (!available || !branch) return null;@@ -43,6 +45,7 @@ export function BranchWidget() {branch.ahead > 0 ? `${branch.ahead} outgoing` : "",].filter(Boolean);const tooltip =+ (repo ? `Repository: ${repo}\n` : "") +(branch.upstream? `Git branch: ${headLabel(branch)}${op}\nTracking ${branch.upstream}`: `Git branch: ${headLabel(branch)}${op}`) + (sync.length ? `\n${sync.join(", ")} commits` : "");@@ -58,6 +61,7 @@ export function BranchWidget() {onClick={() => useBranchesPopup.setState({ open: !open })}><Icon name={branch.head ? "branch" : "commit"} size={16} className={styles.icon} />+ {repo && <span className={styles.repo}>{repo}</span>}<span className={styles.name}>{inProgress(branch.operation) ? operationTitle(inProgress(branch.operation)!, branch.head) : headLabel(branch)}</span>@@ -179,6 +183,7 @@ function BranchesPopup({ anchor, onClose }: { anchor: RefObject<HTMLElement | nuaria-label="Git Branches"className={styles.popup}>+ <RepositoryBar /><div className={styles.search}><SearchFielddata-autofocus@@ -237,6 +242,29 @@ function BranchesPopup({ anchor, onClose }: { anchor: RefObject<HTMLElement | nu);}+/** Repository switcher (several repositories): branches, log and push act on the selected one. */+function RepositoryBar() {+ const roots = useVcs((s) => s.roots);+ const repo = useVcs((s) => s.repo);+ if (roots.length < 2) return null;+ return (+ <div className={styles.repos} role="group" aria-label="Repository">+ {roots.map((r) => (+ <button+ key={r}+ type="button"+ className={clsx(styles.repoButton, r === repo && styles.repoSelected)}+ aria-pressed={r === repo}+ title={r}+ onClick={() => void selectRepo(r).then(() => loadBranches().catch(() => undefined))}+ >+ {repoName(r)}+ </button>+ ))}+ </div>+ );+}+function BranchRowView({ row }: { row: BranchRow }) {if (row.type === "action") {const keys = shortcutLabel(row.action.id);diff --git a/src/features/vcs/CommitView.tsx b/src/features/vcs/CommitView.tsxindex 40d08035f..9555c62e7 100644--- a/src/features/vcs/CommitView.tsx+++ b/src/features/vcs/CommitView.tsx@@ -43,7 +43,7 @@ import { KIND_COLOR, KIND_LABEL, formatTime, stashLabel, stripSlash } from "./moimport { call, commands } from "@/platform/ipc";import { OperationBanner } from "./operations";import { ShelfPanel, loadShelves, useShelf } from "./shelf";-import { loadStashes, refreshNow, useVcs } from "./store";+import { currentRepo, loadStashes, refreshNow, useVcs } from "./store";import styles from "./CommitView.module.css";/** MIME type of changed files dragged between change lists (absolute paths, newline-separated). */@@ -243,7 +243,11 @@ function ChangesPanel() {const treeRef = useRef<TreeHandle>(null);const viewRef = useRef<HTMLButtonElement>(null);- const roots = useMemo(() => buildChangeTree(status, root, groupByDir, lists), [status, root, groupByDir, lists]);+ const repos = useVcs((s) => s.roots);+ const roots = useMemo(+ () => buildChangeTree(status, root, groupByDir, lists, repos),+ [status, root, groupByDir, lists, repos],+ );const [byKey, parents] = useMemo(() => {const m = new Map<string, ChangeNode>();const up = new Map<string, string>();@@ -556,7 +560,15 @@ function CommitMessage({ included }: { included: number }) {if (v && !useCommit.getState().message.trim()) {try {const [last] = await call(- commands.vcsLog({ branch: "HEAD", path: null, author: null, text: null, range: null, skip: 0, limit: 1 }),+ commands.vcsLog(currentRepo(), {+ branch: "HEAD",+ path: null,+ author: null,+ text: null,+ range: null,+ skip: 0,+ limit: 1,+ }),);if (last && !useCommit.getState().message.trim()) {amendMessage.current = last.message;diff --git a/src/features/vcs/CompareBranches.tsx b/src/features/vcs/CompareBranches.tsxindex 9db91f8b3..f2aacb868 100644--- a/src/features/vcs/CompareBranches.tsx+++ b/src/features/vcs/CompareBranches.tsx@@ -6,7 +6,7 @@ import { call, commands } from "@/platform/ipc";import { Dialog, List, Spinner, Tabs, T } from "@/ui";import { openDialog } from "./dialogs";import { formatTime } from "./model";-import { useVcs } from "./store";+import { currentRepo, useVcs } from "./store";import styles from "./common.module.css";const LIMIT = 2000;@@ -14,7 +14,7 @@ const LIMIT = 2000;/** Commits reachable from `to` but not from `from` (git's `from..to`), computed by git, unbounded by any window. */const commitsBetween = (from: string, to: string) =>call(- commands.vcsLog({+ commands.vcsLog(currentRepo(), {branch: null,path: null,author: null,diff --git a/src/features/vcs/GitLog.tsx b/src/features/vcs/GitLog.tsxindex d2f1e2ad4..2c6818e58 100644--- a/src/features/vcs/GitLog.tsx+++ b/src/features/vcs/GitLog.tsx@@ -48,7 +48,7 @@ import {} from "./logStore";import { KIND_COLOR, baseName, formatTime, relTo, type EffectiveKind } from "./model";import { clearConsole, useVcsConsole } from "./ops";-import { loadBranches, useVcs } from "./store";+import { currentRepo, loadBranches, useVcs } from "./store";import { checkoutBranch, loadFavoriteBranches, newBranch, useFavoriteBranches } from "./branchOps";import { branchMenu } from "./branchMenu";import { branchFolderKeys, branchGroupKeys, buildBranchTree, filterBranchTree, type BranchTreeNode } from "./branches";@@ -711,7 +711,7 @@ function CommitDetails({ commits }: { commits: Commit[] }) {useEffect(() => {if (!selected) return;let alive = true;- call(commands.vcsCommitFiles(selected))+ call(commands.vcsCommitFiles(currentRepo(), selected)).then((f) => alive && setFiles(f)).catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));return () => {diff --git a/src/features/vcs/__tests__/changes.test.ts b/src/features/vcs/__tests__/changes.test.tsindex df1297a5f..d30500ae0 100644--- a/src/features/vcs/__tests__/changes.test.ts+++ b/src/features/vcs/__tests__/changes.test.ts@@ -1,6 +1,14 @@import { describe, expect, it } from "vitest";import type { FileStatus } from "@/bindings";-import { aggregateCheck, buildChangeTree, initialCheck, planCommit, type CheckState, type ChangeNode } from "../changes";+import {+ aggregateCheck,+ buildChangeTree,+ commitRepos,+ initialCheck,+ planCommit,+ type CheckState,+ type ChangeNode,+} from "../changes";const fs = (rel: string, staged: FileStatus["staged"], unstaged: FileStatus["unstaged"]): FileStatus => ({path: `/r/${rel}`,@@ -54,6 +62,48 @@ describe("buildChangeTree", () => {});});+describe("several repositories", () => {+ const nested = [...status, fs("libs/core/Lib.kt", null, "modified"), fs("libs/core/new.txt", null, "untracked")];+ const repos = ["/r", "/r/libs/core"];++ it("groups each change group by repository", () => {+ expect(shape(buildChangeTree(nested, "/r", false, undefined, repos))).toEqual([+ "Merge Conflicts",+ " r",+ " conf.yml",+ "Changes",+ " r",+ " App.kt",+ " AppTest.kt",+ " Partial.kt",+ " README.md",+ " libs/core",+ " Lib.kt",+ "Unversioned Files",+ " r",+ " notes.txt",+ " libs/core",+ " new.txt",+ ]);+ const changes = buildChangeTree(nested, "/r", true, undefined, repos)[1]!;+ expect(changes.children!.map((n) => [n.label, n.path])).toEqual([+ ["r", "/r"],+ ["libs/core", "/r/libs/core"],+ ]);+ expect(shape(changes.children![1]!.children!)).toEqual(["Lib.kt"]);+ // One repository: no repository level.+ const single = buildChangeTree(status, "/r", false, undefined, ["/r"]);+ expect(shape(single)).toEqual(shape(buildChangeTree(status, "/r", false)));+ });++ it("commits every repository with included changes, the selected one last", () => {+ const included = [nested[0]!, nested[7]!];+ expect(commitRepos(included, repos, "/r")).toEqual(["/r/libs/core", "/r"]);+ expect(commitRepos(included.slice(0, 1), repos, "/r/libs/core")).toEqual(["/r"]);+ expect(commitRepos([], repos, "/r/libs/core")).toEqual(["/r/libs/core"]);+ });+});+describe("commit inclusion", () => {it("defaults: tracked changes included, partial files keep their staged part, unversioned excluded", () => {expect(initialCheck(status[0]!)).toBe("all");diff --git a/src/features/vcs/__tests__/gitOps.test.ts b/src/features/vcs/__tests__/gitOps.test.tsindex b95bc62ce..b27ee3cd0 100644--- a/src/features/vcs/__tests__/gitOps.test.ts+++ b/src/features/vcs/__tests__/gitOps.test.ts@@ -11,6 +11,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {...real.commands,vcsStatus: () => vcsStatus(),vcsBranchInfo: async () => ({ status: "ok", data: info() }),+ vcsRoots: async () => ({ status: "ok", data: [{ root: "/p", operation: null }] }),},};});diff --git a/src/features/vcs/__tests__/workflow.test.ts b/src/features/vcs/__tests__/workflow.test.tsindex 3a09b468a..40d0cca89 100644--- a/src/features/vcs/__tests__/workflow.test.ts+++ b/src/features/vcs/__tests__/workflow.test.ts@@ -1,7 +1,8 @@import { describe, expect, it } from "vitest";import { messageProblems, wrapAtMargin } from "../CommitView";import { linkifyIssues } from "../issueLinks";-import { isProtectedBranch, isPushRejected } from "../remoteUi";+import { defaultPushChecked, isProtectedBranch, isPushRejected, pushCandidates, type RepoPush } from "../remoteUi";+import { attentionRepo } from "../store";import { statusDecorations } from "../model";const cfg = { blankLineAfterSubject: true, limitSubject: true, subjectLimit: 10, limitBody: true, bodyLimit: 8 };@@ -59,3 +60,34 @@ describe("git settings helpers", () => {expect(statusDecorations(status, false).get("/p/src/a.ts")?.propagate).toBeUndefined();});});++describe("several repositories", () => {+ it("selects a repository that just stopped in an operation", () => {+ expect(attentionRepo("/p", {}, { "/p/lib": "merge" })).toBe("/p/lib");+ expect(attentionRepo("/p", { "/p/lib": "merge" }, { "/p/lib": "merge" })).toBeNull();+ expect(attentionRepo("/p", {}, { "/p": "rebase", "/p/lib": "merge" })).toBeNull();+ expect(attentionRepo("/p", {}, {})).toBeNull();+ });++ it("lists repositories with something to push", () => {+ const branch = (head: string | null, upstream: string | null) => ({+ head,+ headCommit: "c1",+ upstream,+ ahead: 0,+ behind: 0,+ operation: null,+ });+ const commit = { id: "c1", shortId: "c1" } as RepoPush["commits"][number];+ const repos: RepoPush[] = [+ { root: "/p", branch: branch("main", "origin/main"), commits: [commit] },+ { root: "/p/a", branch: branch("main", "origin/main"), commits: [] },+ { root: "/p/b", branch: branch("feature", null), commits: [commit] },+ { root: "/p/c", branch: branch(null, null), commits: [] },+ ];+ const candidates = pushCandidates(repos);+ expect(candidates.map((r) => r.root)).toEqual(["/p", "/p/b"]);+ expect([...defaultPushChecked(candidates, "/p")]).toEqual(["/p"]);+ expect([...defaultPushChecked(candidates, "/p/b")]).toEqual(["/p", "/p/b"]);+ });+});diff --git a/src/features/vcs/actions.tsx b/src/features/vcs/actions.tsxindex 7139151ff..883292416 100644--- a/src/features/vcs/actions.tsx+++ b/src/features/vcs/actions.tsx@@ -16,7 +16,7 @@ import { openDialog } from "./dialogs";import { gotoChange } from "./gutter";import { openLocalHistory } from "./localHistoryKind";import { revealCommit, setLogFilters, useGitLog, emptyFilters } from "./logStore";-import { runRemote } from "./ops";+import { allRepos, runRemote } from "./ops";import { showPushDialog, showUpdateDialog, type PushTarget } from "./remoteUi";import { chooseRevision } from "./RevisionChooser";import { showCloneDialog } from "./clone";@@ -150,7 +150,7 @@ export function registerVcsActions(): () => void {category: "Git",icon: "git-fetch",when: VCS,- run: () => void runRemote({ op: "fetch" }),+ run: () => void runRemote({ op: "fetch" }, undefined, allRepos()),},{id: "vcs.refresh",diff --git a/src/features/vcs/branchOps.ts b/src/features/vcs/branchOps.tsindex eb664fcbb..039c924c2 100644--- a/src/features/vcs/branchOps.ts+++ b/src/features/vcs/branchOps.ts@@ -7,7 +7,7 @@ import { notifications } from "@/workbench/contributions";import { isFavoriteBranch, pushRecent, shortRemoteName } from "./branches";import { confirmDialog, promptText } from "./dialogs";import { runOp, runRemote, saveAll } from "./ops";-import { conflictedFiles, refreshNow, useVcs } from "./store";+import { conflictedFiles, currentRepo, refreshNow, useVcs } from "./store";const recentKey = () => `openidea.vcs.recentBranches:${useVcs.getState().root ?? ""}`;@@ -46,7 +46,7 @@ export function validateBranchName(name: string): string | null {export async function checkoutBranch(name: string) {const previous = useVcs.getState().branch?.head;await saveAll();- const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(name, false)), {+ const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(currentRepo(), name, false)), {success: () => `Checked out ${useVcs.getState().branch?.head ?? name}`,});if (ok !== undefined) {@@ -72,7 +72,8 @@ export async function newBranch(from?: string) {const checkout = r.checked;const previous = useVcs.getState().branch?.head;if (checkout) await saveAll();- const ok = await runOp(`Create branch ${r.value}`, () => call(commands.vcsCreateBranch(r.value, from ?? null, checkout)), {+ const create = () => call(commands.vcsCreateBranch(currentRepo(), r.value, from ?? null, checkout));+ const ok = await runOp(`Create branch ${r.value}`, create, {success: checkout ? `Created and checked out ${r.value}` : `Created branch ${r.value}`,});if (ok !== undefined && checkout) {@@ -91,7 +92,7 @@ export async function checkoutRevision() {});if (!r) return;await saveAll();- await runOp(`Checkout ${r.value}`, () => call(commands.vcsCheckout(r.value, false)), {+ await runOp(`Checkout ${r.value}`, () => call(commands.vcsCheckout(currentRepo(), r.value, false)), {success: `Checked out ${r.value}`,});}@@ -116,7 +117,7 @@ async function openConflictsInstead(): Promise<boolean> {export async function mergeIntoCurrent(branch: string) {const current = useVcs.getState().branch?.head ?? "HEAD";await saveAll();- await runOp(`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(branch)), {+ await runOp(`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(currentRepo(), branch)), {success: `Merged ${branch} into ${current}`,errorActions: conflictActions,onError: openConflictsInstead,@@ -126,7 +127,7 @@ export async function mergeIntoCurrent(branch: string) {export async function rebaseOnto(branch: string) {const current = useVcs.getState().branch?.head ?? "HEAD";await saveAll();- await runOp(`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(branch)), {+ await runOp(`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(currentRepo(), branch)), {success: `Rebased ${current} onto ${branch}`,errorActions: conflictActions,onError: openConflictsInstead,@@ -144,7 +145,7 @@ export async function renameBranch(name: string) {});if (!r) return;const to = r.value.trim();- const ok = await runOp(`Rename branch ${name}`, () => call(commands.vcsRenameBranch(name, to)), {+ const ok = await runOp(`Rename branch ${name}`, () => call(commands.vcsRenameBranch(currentRepo(), name, to)), {success: `Renamed branch ${name} to ${to}`,});if (ok !== undefined) {@@ -164,7 +165,7 @@ export async function deleteBranch(name: string) {danger: true,});if (!ok) return;- await runOp(`Delete branch ${name}`, () => call(commands.vcsDeleteBranch(name, false)), {+ await runOp(`Delete branch ${name}`, () => call(commands.vcsDeleteBranch(currentRepo(), name, false)), {success: `Deleted branch ${name}`,errorActions: (m) =>/not fully merged/i.test(m)@@ -172,7 +173,7 @@ export async function deleteBranch(name: string) {{label: "Force Delete",run: () =>- void runOp(`Force delete ${name}`, () => call(commands.vcsDeleteBranch(name, true)), {+ void runOp(`Force delete ${name}`, () => call(commands.vcsDeleteBranch(currentRepo(), name, true)), {success: `Deleted branch ${name}`,}),},@@ -198,7 +199,7 @@ export async function checkoutAndRebase(name: string) {const current = useVcs.getState().branch?.head;if (!current) return;await saveAll();- const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(name, false)));+ const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(currentRepo(), name, false)));if (ok === undefined) return;rememberBranch(current);rememberBranch(name);diff --git a/src/features/vcs/changeOps.tsx b/src/features/vcs/changeOps.tsxindex 2242a9710..b24bffe4d 100644--- a/src/features/vcs/changeOps.tsx+++ b/src/features/vcs/changeOps.tsx@@ -4,14 +4,14 @@ import type { FileStatus } from "@/bindings";import { call, commands } from "@/platform/ipc";import { Checkbox, Dialog, Icon, fileIconName } from "@/ui";import { notifications } from "@/workbench/contributions";-import { groupOf, planCommit, renamedFromPath } from "./changes";+import { commitRepos, groupOf, planCommit, renamedFromPath } from "./changes";import { useChangelists, withListDefaults } from "./changelists";import { runCommitChecks } from "./commitChecks";import { rememberMessage, useCommit } from "./commitStore";import { confirmDialog, openDialog, promptText } from "./dialogs";import { KIND_COLOR, baseName, dirName, effectiveKind, relTo, stripSlash } from "./model";import { logConsole, runOp, saveAll } from "./ops";-import { loadStashes, refreshNow, useVcs } from "./store";+import { currentRepo, loadStashes, refreshNow, useVcs } from "./store";import styles from "./common.module.css";export function firstLine(message: string): string {@@ -48,18 +48,24 @@ export async function commitChanges(): Promise<string | undefined> {}const candidates = plan.included.map((f) => ({ path: stripSlash(f.path), exists: effectiveKind(f) !== "deleted" }));if (!(await runCommitChecks(candidates, amend))) return undefined;+ // Like IDEA, every repository with included changes gets a commit with the same message.+ const repos = commitRepos(plan.included, useVcs.getState().roots, currentRepo());const id = await runOp(amend ? "Amend commit" : "Commit",async () => {if (plan.unstage.length) await call(commands.vcsUnstage(plan.unstage));if (plan.stage.length) await call(commands.vcsStage(plan.stage));- return call(commands.vcsCommit(message.trim(), { amend, signOff, author: author.trim() || null, runHooks }));+ const options = { amend, signOff, author: author.trim() || null, runHooks };+ let id = "";+ for (const repo of repos) id = await call(commands.vcsCommit(repo, message.trim(), options));+ return id;},{success: () => {const n = plan.included.length;const summary = firstLine(message);- return `${n} file${n === 1 ? "" : "s"} ${amend ? "amended" : "committed"}${summary ? `: ${summary}` : ""}`;+ const where = repos.length > 1 ? ` in ${repos.length} repositories` : "";+ return `${n} file${n === 1 ? "" : "s"} ${amend ? "amended" : "committed"}${where}${summary ? `: ${summary}` : ""}`;},},);@@ -221,7 +227,7 @@ export async function stashChanges() {});if (!r) return;await saveAll();- await runOp("Stash changes", () => call(commands.vcsStashPush(r.value || null, r.checked)), {+ await runOp("Stash changes", () => call(commands.vcsStashPush(currentRepo(), r.value || null, r.checked)), {success: "Changes stashed",});void loadStashes().catch(() => undefined);@@ -229,7 +235,7 @@ export async function stashChanges() {export async function applyStash(index: number, pop: boolean) {await saveAll();- await runOp(`${pop ? "Pop" : "Apply"} stash@{${index}}`, () => call(commands.vcsStashApply(index, pop)), {+ await runOp(`${pop ? "Pop" : "Apply"} stash@{${index}}`, () => call(commands.vcsStashApply(currentRepo(), index, pop)), {success: pop ? `Unstashed stash@{${index}}` : `Applied stash@{${index}}`,});void loadStashes().catch((e) => logConsole("err", String(e)));@@ -243,7 +249,7 @@ export async function dropStash(index: number, message: string) {danger: true,});if (!ok) return;- await runOp(`Drop stash@{${index}}`, () => call(commands.vcsStashDrop(index)), {+ await runOp(`Drop stash@{${index}}`, () => call(commands.vcsStashDrop(currentRepo(), index)), {success: `Dropped stash@{${index}}`,});void loadStashes().catch((e) => logConsole("err", String(e)));diff --git a/src/features/vcs/changes.ts b/src/features/vcs/changes.tsindex 49e24f9e2..f0b3c47ad 100644--- a/src/features/vcs/changes.ts+++ b/src/features/vcs/changes.ts@@ -1,6 +1,6 @@/** Commit tool window model: change groups, directory tree, inclusion (pure). */import type { ChangelistState, FileStatus } from "@/bindings";-import { baseName, dirName, effectiveKind, relTo, stripSlash, type EffectiveKind } from "./model";+import { baseName, dirName, effectiveKind, relTo, repoLabel, rootOf, stripSlash, type EffectiveKind } from "./model";export type GroupId = "conflicts" | "changes" | "unversioned";@@ -156,6 +156,37 @@ function childNodes(files: readonly FileStatus[], root: string, group: GroupId,.map((f) => fileNode(f, root, group, true, scope));}+/** With several repositories, a node per repository (IDEA's "Group by Repository") above the files. */+function repoNodes(+ files: readonly FileStatus[],+ root: string,+ group: GroupId,+ groupByDir: boolean,+ scope: string,+ repos: readonly string[],+): ChangeNode[] {+ if (repos.length < 2) return childNodes(files, root, group, groupByDir, scope);+ const byRepo = new Map<string, FileStatus[]>();+ for (const f of files) {+ const repo = rootOf(f.path, repos) ?? root;+ let list = byRepo.get(repo);+ if (!list) byRepo.set(repo, (list = []));+ list.push(f);+ }+ const order = (r: string) => (repos.includes(r) ? repos.indexOf(r) : repos.length);+ return [...byRepo]+ .sort(([a], [b]) => order(a) - order(b))+ .map(([repo, own]) => ({+ key: `${scope}:repo:${repo}`,+ type: "dir" as const,+ label: repoLabel(repo, root),+ group,+ children: childNodes(own, repo, group, groupByDir, `${scope}@${repo}`),+ files: own,+ path: repo,+ }));+}+function tagList(nodes: ChangeNode[], id: string): ChangeNode[] {for (const n of nodes) {n.changelist = id;@@ -167,13 +198,15 @@ function tagList(nodes: ChangeNode[], id: string): ChangeNode[] {/*** Group roots (Merge Conflicts / Changes / Unversioned Files) with flat or directory* children. With change lists, "Changes" is split into one group per list- * (`ChangelistState.files` keys are project-relative paths).+ * (`ChangelistState.files` keys are project-relative paths). With several+ * repositories (`repos`), each group's files are grouped by repository first.*/export function buildChangeTree(status: readonly FileStatus[],root: string,groupByDir: boolean,lists?: ChangelistState,+ repos: readonly string[] = [],): ChangeNode[] {const byGroup = new Map<GroupId, FileStatus[]>();for (const fs of status) {@@ -202,7 +235,7 @@ export function buildChangeTree(type: "group",label: l.name,group: g,- children: tagList(childNodes(own, root, g, groupByDir, scope), l.id),+ children: tagList(repoNodes(own, root, g, groupByDir, scope, repos), l.id),files: own,changelist: l.id,active: l.id === lists.active,@@ -212,7 +245,7 @@ export function buildChangeTree(continue;}if (!files.length) continue;- const children = childNodes(files, root, g, groupByDir, g);+ const children = repoNodes(files, root, g, groupByDir, g, repos);roots.push({ key: `group:${g}`, type: "group", label: GROUP_LABEL[g], group: g, children, files });}return roots;@@ -225,6 +258,20 @@ export interface CommitPlan {included: FileStatus[];}+/**+ * Repositories to commit: those holding `included` files (the selected one last, so its+ * commit id is returned), else just the selected one (amend, concluding a merge).+ */+export function commitRepos(+ included: readonly FileStatus[],+ roots: readonly string[],+ selected: string | null,+): Array<string | null> {+ const repos = [...new Set(included.map((f) => rootOf(f.path, roots)).filter((r): r is string => !!r))];+ if (!repos.length) return [selected];+ return selected && repos.includes(selected) ? [...repos.filter((r) => r !== selected), selected] : repos;+}+/** Absolute path of the source of a staged rename (`renamedFrom` is repository-relative). */export function renamedFromPath(fs: FileStatus): string | null {if (!fs.renamedFrom) return null;diff --git a/src/features/vcs/commitChecks.tsx b/src/features/vcs/commitChecks.tsxindex 0ddb8bee3..3119a30d0 100644--- a/src/features/vcs/commitChecks.tsx+++ b/src/features/vcs/commitChecks.tsx@@ -13,7 +13,7 @@ import { maybeEditorService, toolWindowService } from "@/workbench/contributionsimport { ask } from "@/workbench/messages";import { baseName, relTo } from "./model";import { logConsole } from "./ops";-import { useVcs } from "./store";+import { currentRepo, useVcs } from "./store";import styles from "./common.module.css";// ---------------------------------------------------------------------------@@ -308,7 +308,7 @@ export async function runCommitChecks(files: readonly CommitCandidate[], amend:}if (git.warnCrlf) {- const autocrlf = (await call(commands.vcsConfigGet("core.autocrlf")).catch(() => null))?.toLowerCase();+ const autocrlf = (await call(commands.vcsConfigGet(currentRepo(), "core.autocrlf")).catch(() => null))?.toLowerCase();if (autocrlf !== "true" && autocrlf !== "input") {const crlf: string[] = [];for (const p of existing) {diff --git a/src/features/vcs/historyActions.tsx b/src/features/vcs/historyActions.tsxindex 39a8871a1..4a8ad4272 100644--- a/src/features/vcs/historyActions.tsx+++ b/src/features/vcs/historyActions.tsx@@ -42,7 +42,7 @@ import {} from "./rebase";import { showApplyPatch, showCreatePatchForChanges, showCreatePatchForCommits } from "./patches";import { deleteShelf, renameShelf, shelveChanges, showShelf, unshelve, useShelf } from "./shelf";-import { useVcs } from "./store";+import { currentRepo, useVcs } from "./store";const VCS = "vcsAvailable";const IN_GIT_LOG = "vcsAvailable && activeToolWindow == git";@@ -83,7 +83,7 @@ function withCommits(fn: (cs: Commit[]) => unknown) {async function openCommitInBrowser(c: Commit) {const upstream = useVcs.getState().branch?.upstream;const remote = upstream ? upstream.slice(0, upstream.indexOf("/")) : "origin";- const url = await call(commands.vcsConfigGet(`remote.${remote}.url`)).catch(() => null);+ const url = await call(commands.vcsConfigGet(currentRepo(), `remote.${remote}.url`)).catch(() => null);const page = url ? commitWebUrl(url, c.id) : null;if (page) await openUrl(page);else notifications().notify({ group: "vcs", level: "warning", title: `No web URL for remote '${remote}'` });@@ -122,7 +122,7 @@ function shelfArg(arg: unknown) {async function checkoutCommit(c: Commit) {await saveAll();- await runOp(`Checkout ${c.shortId}`, () => call(commands.vcsCheckout(c.id, false)), {+ await runOp(`Checkout ${c.shortId}`, () => call(commands.vcsCheckout(currentRepo(), c.id, false)), {success: `Checked out ${c.shortId} (detached HEAD)`,});}diff --git a/src/features/vcs/incoming.ts b/src/features/vcs/incoming.tsindex dfe244577..ca177604d 100644--- a/src/features/vcs/incoming.ts+++ b/src/features/vcs/incoming.ts@@ -8,7 +8,7 @@ import { Channel } from "@tauri-apps/api/core";import { call, commands, isTauri, nextRequestId } from "@/platform/ipc";import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";import { logConsole } from "./ops";-import { loadBranches, refreshNow, useVcs } from "./store";+import { currentRepo, loadBranches, refreshNow, useVcs } from "./store";const FIRST_DELAY = 20_000;const INTERVAL = 15 * 60_000;@@ -32,7 +32,7 @@ export function installIncomingCheck(): () => void {const channel = new Channel<string>();channel.onmessage = () => undefined;try {- await call(commands.vcsRemote(nextRequestId(), { op: "fetch" }, channel));+ await call(commands.vcsRemote(currentRepo(), nextRequestId(), { op: "fetch" }, channel));await refreshNow();if (useVcs.getState().branchesLoaded) void loadBranches().catch(() => undefined);} catch (e) {diff --git a/src/features/vcs/logStore.ts b/src/features/vcs/logStore.tsindex eaaab18cb..beb575d61 100644--- a/src/features/vcs/logStore.ts+++ b/src/features/vcs/logStore.ts@@ -5,7 +5,7 @@ import { call, commands } from "@/platform/ipc";import { workflowSettings } from "@/platform/workflowSettings";import { computeGraph, emptyGraphState, type GraphRow, type GraphState } from "./graph";import { clearConsole, errorMessage } from "./ops";-import { useVcs } from "./store";+import { currentRepo, repoOf, selectRepo, useVcs } from "./store";export interface LogFilters {branch: string | null;@@ -71,19 +71,33 @@ export const useGitLog = create<LogState>(() => ({ ...initialLog(), generation:let loadPromise: Promise<void> | null = null;-/** Another repository (the window switched projects): forget its commits, filters, selection and console. */+/**+ * Another project (the window switched projects): forget its commits, filters, selection+ * and console. Another repository of the project selected: show its log.+ */export function installGitLog(): () => void {return useVcs.subscribe((s, prev) => {- if (s.root === prev.root) return;- loadPromise = null;- useGitLog.setState((l) => ({ ...initialLog(), tab: l.tab, generation: l.generation + 1 }));- clearConsole();+ if (s.root !== prev.root) {+ loadPromise = null;+ useGitLog.setState((l) => ({ ...initialLog(), tab: l.tab, generation: l.generation + 1 }));+ clearConsole();+ } else if (s.repo !== prev.repo && prev.repo !== null) {+ const l = useGitLog.getState();+ if (l.generation === 0 && !l.filters.path) return;+ const { path } = useGitLog.getState().filters;+ // A path filter belongs to the repository it is in.+ if (path && repoOf(path) !== s.repo) useGitLog.setState((l) => ({ filters: { ...l.filters, path: null } }));+ void reloadLog();+ }});}export function setLogFilters(patch: Partial<LogFilters>) {useGitLog.setState((s) => ({ filters: { ...s.filters, ...patch } }));- void reloadLog();+ // History of a file in another repository: that repository's log.+ const repo = patch.path ? repoOf(patch.path) : null;+ if (repo && repo !== currentRepo()) void selectRepo(repo);+ else void reloadLog();}/** Drops loaded commits and loads the first page. */@@ -106,7 +120,15 @@ async function loadOutgoing() {if (!upstream) return useGitLog.setState({ outgoing: null });try {const commits = await call(- commands.vcsLog({ branch: "HEAD", path: null, author: null, text: null, range: "@{u}..HEAD", skip: 0, limit: 0 }),+ commands.vcsLog(currentRepo(), {+ branch: "HEAD",+ path: null,+ author: null,+ text: null,+ range: "@{u}..HEAD",+ skip: 0,+ limit: 0,+ }),);useGitLog.setState({ outgoing: new Set(commits.map((c) => c.id)) });} catch {@@ -137,7 +159,7 @@ export function loadMore(): Promise<void> {const p = (async () => {try {const page = await call(- commands.vcsLog({+ commands.vcsLog(currentRepo(), {branch: f.branch,path: f.path,author: f.author.trim() || null,diff --git a/src/features/vcs/model.ts b/src/features/vcs/model.tsindex 197b3ec99..8b9cbad13 100644--- a/src/features/vcs/model.ts+++ b/src/features/vcs/model.ts@@ -92,6 +92,20 @@ export function relTo(root: string, path: string): string {return path.startsWith(root + "/") ? path.slice(root.length + 1) : path;}+/** The innermost of `roots` (repository roots) containing `path`. */+export function rootOf(path: string, roots: readonly string[]): string | null {+ const p = stripSlash(path);+ let best: string | null = null;+ for (const r of roots) if ((p === r || p.startsWith(`${r}/`)) && (!best || r.length > best.length)) best = r;+ return best;+}++/** Repository name for display: its folder relative to the project, else its folder name. */+export function repoLabel(root: string, projectRoot: string | null): string {+ if (projectRoot && root.startsWith(`${projectRoot}/`)) return root.slice(projectRoot.length + 1);+ return baseName(root) || root;+}+export function baseName(path: string): string {const p = stripSlash(path);const i = p.lastIndexOf("/");diff --git a/src/features/vcs/operations.tsx b/src/features/vcs/operations.tsxindex db340c71f..1ca9bcf3b 100644--- a/src/features/vcs/operations.tsx+++ b/src/features/vcs/operations.tsx@@ -14,7 +14,7 @@ import { openDialog, promptText } from "./dialogs";import { KIND_COLOR, baseName, dirName } from "./model";import { runGitOperation, runOp } from "./ops";import { reloadLog, useGitLog } from "./logStore";-import { conflictedFiles, refreshNow, useVcs } from "./store";+import { conflictedFiles, currentRepo, refreshNow, repoOf, useVcs } from "./store";import styles from "./common.module.css";// ---------------------------------------------------------------------------@@ -84,7 +84,10 @@ export async function controlOperation(control: "continue" | "skip" | "abort", eawait refreshNow();const op = inProgress();if (!op || (expected && op !== expected)) return notInProgress(expected);- if (control === "continue" && conflictedFiles().length) {+ // Only the selected repository's conflicts block it (others may be in their own merge).+ const repo = currentRepo();+ const conflicts = conflictedFiles().filter((f) => !repo || repoOf(f.path) === repo);+ if (control === "continue" && conflicts.length) {notifications().notify({ group: "vcs", level: "warning", title: "Resolve all conflicts before continuing" });void executeAction("vcs.resolveConflicts");return;@@ -301,7 +304,7 @@ export function validateTagName(name: string, existing: readonly string[] = []):/** Log › New Tag…: a lightweight tag on the selected commit. */export async function newTagOn(commit: Commit) {- const existing = await call(commands.vcsTags()).catch(() => [] as string[]);+ const existing = await call(commands.vcsTags(currentRepo())).catch(() => [] as string[]);const r = await promptText({title: `Create New Tag On ${short(commit.id)}`,label: "Enter the name of new tag:",@@ -310,7 +313,8 @@ export async function newTagOn(commit: Commit) {validate: (v) => validateTagName(v, existing),});if (!r) return;- const ok = await runOp(`Create tag ${r.value}`, () => call(commands.vcsCreateTag(r.value, commit.id, null, false)), {+ const create = () => call(commands.vcsCreateTag(currentRepo(), r.value, commit.id, null, false));+ const ok = await runOp(`Create tag ${r.value}`, create, {success: `Created tag ${r.value} on ${short(commit.id)}`,});// Tags are not part of the refs signature that reloads the log.@@ -329,7 +333,7 @@ function TagDialog({ onClose }: { onClose: () => void }) {const [force, setForce] = useState(false);const [existing, setExisting] = useState<string[]>([]);useEffect(() => {- void call(commands.vcsTags()).then(setExisting, () => undefined);+ void call(commands.vcsTags(currentRepo())).then(setExisting, () => undefined);}, []);const error = validateTagName(name, force ? [] : existing);const run = async () => {@@ -338,7 +342,7 @@ function TagDialog({ onClose }: { onClose: () => void }) {const tag = name.trim();const ok = await runOp(`Create tag ${tag}`,- () => call(commands.vcsCreateTag(tag, commit.trim() || "HEAD", message || null, force)),+ () => call(commands.vcsCreateTag(currentRepo(), tag, commit.trim() || "HEAD", message || null, force)),{ success: `Created tag ${tag}` },);if (ok !== undefined && useGitLog.getState().commits.length) void reloadLog();@@ -405,7 +409,7 @@ function CompareWithLocalDialog({ rev, label, onClose }: { rev: string; label: sconst [active, setActive] = useState(0);useEffect(() => {let alive = true;- call(commands.vcsDiffWithWorktree(rev))+ call(commands.vcsDiffWithWorktree(currentRepo(), rev)).then((f) => alive && setFiles(f)).catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));return () => {diff --git a/src/features/vcs/ops.ts b/src/features/vcs/ops.tsindex b613683e4..3342b0323 100644--- a/src/features/vcs/ops.ts+++ b/src/features/vcs/ops.ts@@ -9,7 +9,7 @@ import { call, commands, emitLocalIdeEvent, isCancelled, nextRequestId } from "@import { editorsFor } from "@/editor/api";import { maybeEditorService, notifications } from "@/workbench/contributions";import { progressFraction } from "./model";-import { refreshNow, useVcs } from "./store";+import { currentRepo, refreshNow, repoName, useVcs } from "./store";// ---------------------------------------------------------------------------// Console (Git tool window → Console tab)@@ -130,8 +130,21 @@ export function cancelRemote() {if (activeRemote !== null) void commands.cancelRequest(activeRemote);}-/** Runs fetch / pull / push with progress in the status bar and output in the console. */-export async function runRemote(op: RemoteOp, detail?: string): Promise<boolean> {+/** Every repository of the project (Fetch and Update Project act on all of them, as in IDEA). */+export function allRepos(): Array<string | null> {+ const roots = useVcs.getState().roots;+ return roots.length ? roots : [null];+}++/**+ * Runs fetch / pull / push with progress in the status bar and output in the console,+ * in each of `repos` (default: the selected repository) in turn.+ */+export async function runRemote(+ op: RemoteOp,+ detail?: string,+ repos: ReadonlyArray<string | null> = [currentRepo()],+): Promise<boolean> {if (useVcs.getState().remoteBusy) {notifications().notify({ group: "vcs", level: "warning", title: "Another remote operation is in progress" });return false;@@ -163,7 +176,10 @@ export async function runRemote(op: RemoteOp, detail?: string): Promise<boolean>task(text || null, progressFraction(text), false);};try {- await call(commands.vcsRemote(request, op, channel));+ for (const repo of repos) {+ if (repos.length > 1 && repo) logConsole("info", repoName(repo));+ await call(commands.vcsRemote(repo, request, op, channel));+ }lastRemoteError = null;notifications().notify({group: "vcs",@@ -239,7 +255,7 @@ export async function runGitOperation(op: GitOperation, opts: GitOperationOptiontask(line.trim() || null, false);};try {- await call(commands.vcsOperation(request, op, channel));+ await call(commands.vcsOperation(currentRepo(), request, op, channel));let success = opts.success;if (typeof success === "function") {await refreshNow();diff --git a/src/features/vcs/rebase.tsx b/src/features/vcs/rebase.tsxindex f1a5455a1..262d041af 100644--- a/src/features/vcs/rebase.tsx+++ b/src/features/vcs/rebase.tsx@@ -26,7 +26,7 @@ import {type RebaseRange,type RebaseRow,} from "./rebasePlan";-import { refreshNow, useVcs } from "./store";+import { currentRepo, refreshNow, useVcs } from "./store";import styles from "./common.module.css";const short = (id: string) => id.slice(0, 8);@@ -56,7 +56,8 @@ export async function undoCommit(commit: Commit) {});if (!ok) return;}- const message = await runOp(`Undo commit ${short(commit.id)}`, () => call(commands.vcsUndoCommit(commit.id)), {+ const undo = () => call(commands.vcsUndoCommit(currentRepo(), commit.id));+ const message = await runOp(`Undo commit ${short(commit.id)}`, undo, {success: `Undid commit ${short(commit.id)} “${commit.summary}”; its changes are staged`,});// IDEA offers the undone message for the next commit.@@ -78,7 +79,7 @@ async function rangeFrom(target: Commit, verb: string): Promise<RebaseRange | nuconst parent = target.parents[0];try {const history = await call(- commands.vcsLog({+ commands.vcsLog(currentRepo(), {branch: "HEAD",path: null,author: null,diff --git a/src/features/vcs/remoteUi.tsx b/src/features/vcs/remoteUi.tsxindex 2efda3781..7a968df7c 100644--- a/src/features/vcs/remoteUi.tsx+++ b/src/features/vcs/remoteUi.tsx@@ -1,14 +1,14 @@/** Update Project and Push dialogs. */import { useEffect, useState } from "react";-import type { Commit, PushTags, RemoteOp } from "@/bindings";+import type { BranchInfo, Commit, PushTags, RemoteOp } from "@/bindings";import { call, commands } from "@/platform/ipc";import { workflowSettings } from "@/platform/workflowSettings";import { notifications } from "@/workbench/contributions";import { Checkbox, Dialog, List, Select, Spinner, T } from "@/ui";import { openDialog } from "./dialogs";import { formatTime } from "./model";-import { lastRemoteFailure, runRemote, saveAll } from "./ops";-import { refreshNow, useVcs } from "./store";+import { allRepos, lastRemoteFailure, runRemote, saveAll } from "./ops";+import { currentRepo, refreshNow, repoName, useVcs } from "./store";import styles from "./common.module.css";export function showUpdateDialog() {@@ -22,7 +22,14 @@ function UpdateDialog({ onClose }: { onClose: () => void }) {const run = async () => {onClose();await saveAll();- await runRemote({ op: "pull", rebase }, branch?.upstream ? `${branch.head} ← ${branch.upstream}` : undefined);+ const repos = allRepos();+ const detail =+ repos.length > 1+ ? `${repos.length} repositories`+ : branch?.upstream+ ? `${branch.head} ← ${branch.upstream}`+ : undefined;+ await runRemote({ op: "pull", rebase }, detail, repos);};return (<Dialog@@ -70,8 +77,8 @@ function UpdateDialog({ onClose }: { onClose: () => void }) {);}-const logOf = (branch: string, limit: number, range: string | null = null) =>- call(commands.vcsLog({ branch, path: null, author: null, text: null, range, skip: 0, limit }));+const logOf = (branch: string, limit: number, range: string | null = null, repo = currentRepo()) =>+ call(commands.vcsLog(repo, { branch, path: null, author: null, text: null, range, skip: 0, limit }));/** Outgoing commits of the current branch: `@{u}..HEAD`, or recent HEAD history without an upstream. */export function outgoingQuery(upstream: string | null): { branch: string; range: string | null; limit: number } {@@ -87,7 +94,169 @@ export interface PushTarget {export async function showPushDialog(target: PushTarget = {}) {await refreshNow();- openDialog((close) => <PushDialog target={target} onClose={close} />);+ // Several repositories: IDEA's dialog lists each one with outgoing commits.+ const multi = useVcs.getState().roots.length > 1 && !target.branch && !target.revision;+ openDialog((close) => (multi ? <MultiPushDialog onClose={close} /> : <PushDialog target={target} onClose={close} />));+}++/** A repository in the multi-repository Push dialog. */+export interface RepoPush {+ root: string;+ branch: BranchInfo;+ commits: Commit[];+}++/** Repositories with something to push: outgoing commits, or a branch without upstream. */+export function pushCandidates(repos: readonly RepoPush[]): RepoPush[] {+ return repos.filter((r) => r.branch.head && (r.branch.upstream ? r.commits.length > 0 : true));+}++/** Checked by default: repositories with outgoing commits (a new branch only in the selected one). */+export function defaultPushChecked(repos: readonly RepoPush[], selected: string | null): Set<string> {+ return new Set(repos.filter((r) => (r.branch.upstream ? r.commits.length > 0 : r.root === selected)).map((r) => r.root));+}++type PushRow = { type: "repo"; repo: RepoPush } | { type: "commit"; repo: RepoPush; commit: Commit };++function MultiPushDialog({ onClose }: { onClose: () => void }) {+ const roots = useVcs((s) => s.roots);+ const [repos, setRepos] = useState<RepoPush[] | null>(null);+ const [checked, setChecked] = useState<Set<string>>(() => new Set());+ const [error, setError] = useState<string | null>(null);+ const [force, setForce] = useState(false);+ const [pushTags, setPushTags] = useState(false);+ const [tagsMode, setTagsMode] = useState<PushTags>("all");++ useEffect(() => {+ let alive = true;+ Promise.all(+ roots.map(async (root) => {+ const branch = await call(commands.vcsBranchInfo(root));+ const q = outgoingQuery(branch.upstream);+ const commits = branch.head ? await logOf(q.branch, q.limit, q.range, root) : [];+ return { root, branch, commits };+ }),+ )+ .then((all) => {+ if (!alive) return;+ const list = pushCandidates(all);+ setRepos(list);+ setChecked(defaultPushChecked(list, currentRepo()));+ })+ .catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));+ return () => {+ alive = false;+ };+ }, [roots]);++ const toggle = (root: string) =>+ setChecked((prev) => {+ const next = new Set(prev);+ if (!next.delete(root)) next.add(root);+ return next;+ });+ const targetOf = (r: RepoPush) => (r.branch.upstream ? r.branch.upstream.slice(r.branch.upstream.indexOf("/") + 1) : r.branch.head!);+ const picked = (repos ?? []).filter((r) => checked.has(r.root));+ const push = async () => {+ onClose();+ for (const r of picked) {+ const upstream = r.branch.upstream;+ const ok = await pushWithAutoUpdate(+ {+ op: "push",+ force_with_lease: force && !isProtectedBranch(targetOf(r)),+ set_upstream: !upstream,+ tags: pushTags ? tagsMode : null,+ },+ `${repoName(r.root)}: ${r.branch.head} → ${upstream ?? "new remote branch"}`,+ r.root,+ );+ if (!ok) return;+ }+ };+ const rows: PushRow[] = (repos ?? []).flatMap((repo) => [+ { type: "repo" as const, repo },+ ...repo.commits.map((commit) => ({ type: "commit" as const, repo, commit })),+ ]);++ return (+ <Dialog+ open+ title="Push Commits"+ onClose={onClose}+ width={620}+ footerStart={+ <>+ <Checkbox checked={force} onChange={setForce} label="Force (with lease)" />+ <Checkbox checked={pushTags} onChange={setPushTags} label="Push tags:" />+ <Select<PushTags>+ value={tagsMode}+ disabled={!pushTags}+ aria-label="Tags to push"+ onChange={setTagsMode}+ options={[+ { value: "all", label: "All" },+ { value: "currentBranch", label: "Current Branch" },+ ]}+ />+ </>+ }+ buttons={[+ {+ label: force ? "Force Push" : "Push",+ role: "default",+ autoFocus: true,+ disabled: !picked.length,+ onClick: () => void push(),+ },+ { label: "Cancel", role: "cancel" },+ ]}+ >+ <div style={{ height: 340, display: "flex", flexDirection: "column", padding: "14px" }}>+ {error ? (+ <div className={styles.error}>{error}</div>+ ) : !repos ? (+ <div className={styles.empty}>+ <Spinner size={14} />+ </div>+ ) : (+ <List+ items={rows}+ getKey={(r) => (r.type === "repo" ? `repo:${r.repo.root}` : `${r.repo.root}:${r.commit.id}`)}+ rowHeight={22}+ aria-label="Outgoing commits"+ className={styles.boxList}+ // Clicks on the checkbox toggle it themselves.+ onActivate={(r, _i, e) => {+ if (r.type === "repo" && !(e.target as HTMLElement | null)?.closest?.("label")) toggle(r.repo.root);+ }}+ empty={<span>Everything is up to date</span>}+ renderItem={(r) =>+ r.type === "repo" ? (+ <span className={styles.commitRow} style={{ flex: 1, padding: 0 }}>+ <Checkbox+ checked={checked.has(r.repo.root)}+ onChange={() => toggle(r.repo.root)}+ label={repoName(r.repo.root)}+ />+ <span className={styles.commitMeta}>+ {r.repo.branch.head} → {r.repo.branch.upstream ?? "new remote branch"}+ </span>+ </span>+ ) : (+ <span className={styles.commitRow} style={{ flex: 1, padding: "0 0 0 24px" }}>+ <span className={styles.commitHash}>{r.commit.shortId}</span>+ <span className={styles.commitSubject}>{r.commit.summary}</span>+ <span className={styles.commitMeta}>{r.commit.author}</span>+ <span className={styles.commitMeta}>{formatTime(r.commit.timeMs)}</span>+ </span>+ )+ }+ />+ )}+ </div>+ </Dialog>+ );}function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onClose: () => void }) {@@ -262,16 +431,20 @@ export function isPushRejected(message: string): boolean {* update method) and pushes again ("Auto-update if push of the current branch* was rejected") or offers to.*/-export async function pushWithAutoUpdate(op: Extract<RemoteOp, { op: "push" }>, detail: string): Promise<boolean> {- if (await runRemote(op, detail)) return true;+export async function pushWithAutoUpdate(+ op: Extract<RemoteOp, { op: "push" }>,+ detail: string,+ repo: string | null = currentRepo(),+): Promise<boolean> {+ if (await runRemote(op, detail, [repo])) return true;const error = lastRemoteFailure();if (!error || op.force_with_lease || !isPushRejected(error)) return false;const git = workflowSettings().vcs.git;const updateAndPush = async () => {await saveAll();- if (!(await runRemote({ op: "pull", rebase: git.updateMethod === "rebase" }, "updating after rejected push")))- return false;- return runRemote(op, detail);+ const pull = { op: "pull" as const, rebase: git.updateMethod === "rebase" };+ if (!(await runRemote(pull, "updating after rejected push", [repo]))) return false;+ return runRemote(op, detail, [repo]);};if (git.autoUpdateOnPushRejected) return updateAndPush();notifications().notify({diff --git a/src/features/vcs/store.ts b/src/features/vcs/store.tsindex 49e3ad003..3e71f0e3d 100644--- a/src/features/vcs/store.ts+++ b/src/features/vcs/store.ts@@ -2,6 +2,11 @@* Repository state shared by all VCS views: working tree status, HEAD /* upstream info, branches and stashes. Refreshed (debounced) on `vcsChanged`* and `fsChanged` events and after every operation.+ *+ * A project may hold several repositories (IDEA's VCS roots: nested clones,+ * submodules). Status covers all of them; branch info, branches and stashes are+ * those of the selected repository (`repo`), which branch / log / remote+ * operations act on.*/import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";import { create } from "zustand";@@ -10,12 +15,18 @@ import { call, commands, isTauri, onIdeEvent } from "@/platform/ipc";import { setContext } from "@/platform/context";import { useProject } from "@/platform/project";import { setFileDecorations } from "@/workbench/contributions";-import { effectiveKind, statusDecorations, stripSlash } from "./model";+import { effectiveKind, repoLabel, rootOf, statusDecorations, stripSlash } from "./model";export interface VcsState {/** The open project is a git repository. */available: boolean;root: string | null;+ /** Repository roots, the project's own repository first. */+ roots: string[];+ /** Root → merge / rebase / cherry-pick / revert in progress there. */+ operations: Record<string, string>;+ /** The selected repository's root (branch widget, log, push…). */+ repo: string | null;status: FileStatus[];/** `status` reflects the repository (false until the first refresh). */statusLoaded: boolean;@@ -37,6 +48,9 @@ export interface VcsState {const initial: VcsState = {available: false,root: null,+ roots: [],+ operations: {},+ repo: null,status: [],statusLoaded: false,byPath: new Map(),@@ -53,6 +67,42 @@ const initial: VcsState = {export const useVcs = create<VcsState>(() => ({ ...initial }));+/** Root of the selected repository; `null` = the project's primary one. */+export function currentRepo(): string | null {+ return useVcs.getState().repo;+}++/** Root of the innermost repository containing `path`. */+export function repoOf(path: string, roots: readonly string[] = useVcs.getState().roots): string | null {+ return rootOf(path, roots);+}++/** Repository name for display. */+export function repoName(root: string): string {+ return repoLabel(root, useVcs.getState().root);+}++/**+ * A repository that just stopped in a merge / rebase / cherry-pick / revert (e.g. on+ * conflicts after Update Project) while `shown` has none in progress: it is selected so+ * the banner, the branch widget and Continue / Abort act on it.+ */+export function attentionRepo(+ shown: string | null,+ before: Record<string, string>,+ now: Record<string, string>,+): string | null {+ if (shown && now[shown]) return null;+ return Object.keys(now).find((root) => !before[root]) ?? null;+}++/** Selects the repository branch / log / remote operations act on. */+export function selectRepo(root: string): Promise<void> {+ if (useVcs.getState().repo === root) return Promise.resolve();+ useVcs.setState({ repo: root, branches: [], branchesLoaded: false, stashes: [], stashesLoaded: false });+ return refreshNow();+}+export function conflictedFiles(status: readonly FileStatus[] = useVcs.getState().status): FileStatus[] {return status.filter((f) => effectiveKind(f) === "conflicted");}@@ -98,14 +148,27 @@ export function refreshNow(): Promise<void> {useVcs.setState({ loading: true });try {const s = useVcs.getState();- const [status, branch, branches, stashes] = await Promise.all([+ const [vcsRoots, status, branch, branches, stashes] = await Promise.all([+ call(commands.vcsRoots()),call(commands.vcsStatus()),- call(commands.vcsBranchInfo()),- s.branchesLoaded ? call(commands.vcsBranches()) : Promise.resolve(s.branches),- s.stashesLoaded ? call(commands.vcsStashes()) : Promise.resolve(s.stashes),+ call(commands.vcsBranchInfo(s.repo)),+ s.branchesLoaded ? call(commands.vcsBranches(s.repo)) : Promise.resolve(s.branches),+ s.stashesLoaded ? call(commands.vcsStashes(s.repo)) : Promise.resolve(s.stashes),]);+ const roots = vcsRoots.map((r) => r.root);+ const operations = Object.fromEntries(vcsRoots.filter((r) => r.operation).map((r) => [r.root, r.operation!]));+ // `null` (before the first refresh) is the primary repository, listed first.+ const shown = s.repo && roots.includes(s.repo) ? s.repo : (roots[0] ?? null);+ const repo = attentionRepo(shown, s.operations, operations) ?? shown;+ useVcs.setState({ operations });+ if (repo !== s.repo || roots.join("\n") !== s.roots.join("\n")) useVcs.setState({ roots, repo });applyStatus(status, branch);useVcs.setState({ branches, stashes, error: null });+ // Branch info and branches above are of another repository: load the selected one's.+ if (repo !== shown || (s.repo && repo !== s.repo)) {+ useVcs.setState({ branchesLoaded: false, stashesLoaded: false });+ void refreshNow();+ }} catch (e) {useVcs.setState({ error: e instanceof Error ? e.message : String(e) });} finally {@@ -127,13 +190,13 @@ export function applyStatus(status: FileStatus[], branch: BranchInfo | null) {}export async function loadBranches(): Promise<Branch[]> {- const branches = await call(commands.vcsBranches());+ const branches = await call(commands.vcsBranches(currentRepo()));useVcs.setState({ branches, branchesLoaded: true });return branches;}export async function loadStashes(): Promise<Stash[]> {- const stashes = await call(commands.vcsStashes());+ const stashes = await call(commands.vcsStashes(currentRepo()));useVcs.setState({ stashes, stashesLoaded: true });return stashes;}@@ -142,6 +205,17 @@ export function statusOf(path: string): FileStatus | undefined {return useVcs.getState().byPath.get(stripSlash(path));}+/** Repositories found below a project that is not itself under git (scanned in the background). */+async function discoverRoots() {+ const root = useVcs.getState().root;+ if (!root || !isTauri()) return;+ const roots = await call(commands.vcsRoots()).catch(() => []);+ if (!roots.length || useVcs.getState().root !== root || useVcs.getState().available) return;+ useVcs.setState({ available: true });+ setContext("vcsAvailable", true);+ void refreshNow();+}+/** Tracks the open project and backend events. Returns a disposer. */export function installVcsStore(): () => void {const onProject = () => {@@ -154,12 +228,16 @@ export function installVcsStore(): () => void {setContext("vcsAvailable", available);setFileDecorations("vcs", new Map());if (available && isTauri()) void refreshNow();+ else if (project) void discoverRoots();};onProject();const unsubProject = useProject.subscribe((s, prev) => {if (s.project !== prev.project) onProject();});- const offVcs = onIdeEvent("vcsChanged", () => scheduleRefresh(200));+ const offVcs = onIdeEvent("vcsChanged", () => {+ if (useVcs.getState().available) scheduleRefresh(200);+ else void discoverRoots();+ });const offFs = onIdeEvent("fsChanged", () => scheduleRefresh(250));const offSettings = onWorkflowSettingsChange((s) => s.vcs.showDirtyDirectories,