Replace removeMissingRepos with reactive worktree change detection via state.onDidChange

Copilot · alexr00 · Copilot · commit d567cc4ced8b · 2026-03-02T13:09:45.000Z
Instead of checking filesystem on refresh, listen to each repository's
state.onDidChange event and compare worktree paths. When a worktree is
removed from the git state, automatically remove its folder manager.

- Add checkWorktreeChanges() to RepositoriesManager that tracks worktree
  paths per repo and detects removals
- Subscribe to state.onDidChange in registerFolderListeners
- Remove removeMissingRepos() method and its call from pr.refreshList
- Update MockRepository to support worktrees and fire state changes
- Replace removeMissingRepos tests with worktree detection tests

Co-authored-by: alexr00 &lt;38270282+alexr00@users.noreply.github.com&gt;
diff --git a/src/github/repositoriesManager.ts b/src/github/repositoriesManager.ts
@@ -91,10 +91,39 @@ export class RepositoriesManager extends Disposable {
 			folderManager.onDidChangeAnyPullRequests(e => this._onDidChangeAnyPullRequests.fire(e)),
 			folderManager.onDidAddPullRequest(e => this._onDidAddPullRequest.fire(e)),
 			folderManager.onDidChangeGithubRepositories(() => this._onDidAddAnyGitHubRepository.fire(folderManager)),
+			folderManager.repository.state.onDidChange(() => this.checkWorktreeChanges(folderManager.repository)),
 		];
 		this._subs.set(folderManager, disposables);
 	}
 
+	private _previousWorktrees: Map<string, Set<string>> = new Map();
+
+	private checkWorktreeChanges(repo: Repository): void {
+		const worktrees = repo.state.worktrees;
+		if (!worktrees) {
+			return;
+		}
+
+		const repoKey = repo.rootUri.toString();
+		const currentPaths = new Set(worktrees.map(wt => vscode.Uri.file(wt.path).toString()));
+		const previousPaths = this._previousWorktrees.get(repoKey);
+		this._previousWorktrees.set(repoKey, currentPaths);
+
+		if (!previousPaths) {
+			return;
+		}
+
+		for (const previousPath of previousPaths) {
+			if (!currentPaths.has(previousPath)) {
+				const folderManager = this._folderManagers.find(m => m.repository.rootUri.toString() === previousPath);
+				if (folderManager) {
+					Logger.appendLine(`Removing folder manager for removed worktree ${previousPath}`, RepositoriesManager.ID);
+					this.removeRepo(folderManager.repository);
+				}
+			}
+		}
+	}
+
 	insertFolderManager(folderManager: FolderRepositoryManager) {
 		this.registerFolderListeners(folderManager);
 
@@ -134,24 +163,6 @@ export class RepositoriesManager extends Disposable {
 		}
 	}
 
-	async removeMissingRepos(): Promise<void> {
-		const managersToRemove: FolderRepositoryManager[] = [];
-		for (const manager of this._folderManagers) {
-			const uri = manager.repository.rootUri;
-			if (uri.scheme === 'file') {
-				try {
-					await vscode.workspace.fs.stat(uri);
-				} catch {
-					managersToRemove.push(manager);
-				}
-			}
-		}
-		for (const manager of managersToRemove) {
-			Logger.appendLine(`Removing stale repository ${manager.repository.rootUri} (path no longer exists).`, RepositoriesManager.ID);
-			this.removeRepo(manager.repository);
-		}
-	}
-
 	getManagerForIssueModel(issueModel: IssueModel | undefined): FolderRepositoryManager | undefined {
 		if (issueModel === undefined) {
 			return undefined;
diff --git a/src/test/github/repositoriesManager.test.ts b/src/test/github/repositoriesManager.test.ts
@@ -4,9 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
 import { SinonSandbox, createSandbox } from 'sinon';
 import { default as assert } from 'assert';
 
@@ -143,73 +140,78 @@ describe('RepositoriesManager', function () {
 		});
 	});
 
-	describe('removeMissingRepos', function () {
-		let tmpDir: string;
+	describe('worktree change detection', function () {
+		it('removes folder manager when its worktree is removed from the main repo', function () {
+			const mainRepo = new MockRepository();
+			mainRepo.rootUri = vscode.Uri.file('/main-repo');
+			mainRepo.addRemote('origin', 'git@github.com:aaa/bbb');
 
-		beforeEach(function () {
-			tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vscode-pr-test-'));
-		});
-
-		afterEach(function () {
-			fs.rmSync(tmpDir, { recursive: true, force: true });
-		});
-
-		it('removes folder managers whose root URIs no longer exist on disk', async function () {
-			const existingDir = path.join(tmpDir, 'existing-repo');
-			fs.mkdirSync(existingDir);
+			const worktreeRepo = new MockRepository();
+			worktreeRepo.rootUri = vscode.Uri.file('/main-repo/worktrees/feature');
+			worktreeRepo.addRemote('origin', 'git@github.com:aaa/bbb');
 
-			const removedDir = path.join(tmpDir, 'removed-worktree');
-			fs.mkdirSync(removedDir);
-
-			const repo1 = new MockRepository();
-			repo1.rootUri = vscode.Uri.file(existingDir);
-			repo1.addRemote('origin', 'git@github.com:aaa/bbb');
+			reposManager.insertFolderManager(new FolderRepositoryManager(0, context, mainRepo, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
+			reposManager.insertFolderManager(new FolderRepositoryManager(1, context, worktreeRepo, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
 
-			const repo2 = new MockRepository();
-			repo2.rootUri = vscode.Uri.file(removedDir);
-			repo2.addRemote('origin', 'git@github.com:aaa/bbb');
+			assert.strictEqual(reposManager.folderManagers.length, 2);
 
-			reposManager.insertFolderManager(new FolderRepositoryManager(0, context, repo1, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
-			reposManager.insertFolderManager(new FolderRepositoryManager(1, context, repo2, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
+			// Set initial worktrees on the main repo (includes the worktree)
+			mainRepo.setWorktrees([
+				{ name: 'main-repo', path: '/main-repo', ref: 'main', main: true, detached: false },
+				{ name: 'feature', path: '/main-repo/worktrees/feature', ref: 'feature', main: false, detached: false },
+			]);
 
 			assert.strictEqual(reposManager.folderManagers.length, 2);
 
-			// Remove the directory to simulate worktree deletion
-			fs.rmSync(removedDir, { recursive: true });
-
-			await reposManager.removeMissingRepos();
+			// Worktree is removed - main repo state changes with updated worktrees
+			mainRepo.setWorktrees([
+				{ name: 'main-repo', path: '/main-repo', ref: 'main', main: true, detached: false },
+			]);
 
 			assert.strictEqual(reposManager.folderManagers.length, 1);
-			assert.strictEqual(reposManager.folderManagers[0].repository.rootUri.toString(), repo1.rootUri.toString());
+			assert.strictEqual(reposManager.folderManagers[0].repository.rootUri.toString(), mainRepo.rootUri.toString());
 		});
 
-		it('keeps all repos when all paths exist on disk', async function () {
-			const dir1 = path.join(tmpDir, 'repo1');
-			fs.mkdirSync(dir1);
+		it('does not remove folder managers when worktrees remain unchanged', function () {
+			const mainRepo = new MockRepository();
+			mainRepo.rootUri = vscode.Uri.file('/main-repo');
+			mainRepo.addRemote('origin', 'git@github.com:aaa/bbb');
 
-			const dir2 = path.join(tmpDir, 'repo2');
-			fs.mkdirSync(dir2);
+			const worktreeRepo = new MockRepository();
+			worktreeRepo.rootUri = vscode.Uri.file('/main-repo/worktrees/feature');
+			worktreeRepo.addRemote('origin', 'git@github.com:aaa/bbb');
 
-			const repo1 = new MockRepository();
-			repo1.rootUri = vscode.Uri.file(dir1);
-			repo1.addRemote('origin', 'git@github.com:aaa/bbb');
+			reposManager.insertFolderManager(new FolderRepositoryManager(0, context, mainRepo, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
+			reposManager.insertFolderManager(new FolderRepositoryManager(1, context, worktreeRepo, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
 
-			const repo2 = new MockRepository();
-			repo2.rootUri = vscode.Uri.file(dir2);
-			repo2.addRemote('origin', 'git@github.com:ccc/ddd');
-
-			reposManager.insertFolderManager(new FolderRepositoryManager(0, context, repo1, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
-			reposManager.insertFolderManager(new FolderRepositoryManager(1, context, repo2, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
+			// Set initial worktrees
+			mainRepo.setWorktrees([
+				{ name: 'main-repo', path: '/main-repo', ref: 'main', main: true, detached: false },
+				{ name: 'feature', path: '/main-repo/worktrees/feature', ref: 'feature', main: false, detached: false },
+			]);
 
-			await reposManager.removeMissingRepos();
+			// Fire state change again with same worktrees
+			mainRepo.setWorktrees([
+				{ name: 'main-repo', path: '/main-repo', ref: 'main', main: true, detached: false },
+				{ name: 'feature', path: '/main-repo/worktrees/feature', ref: 'feature', main: false, detached: false },
+			]);
 
 			assert.strictEqual(reposManager.folderManagers.length, 2);
 		});
 
-		it('does nothing when there are no folder managers', async function () {
-			assert.strictEqual(reposManager.folderManagers.length, 0);
-			await reposManager.removeMissingRepos();
-			assert.strictEqual(reposManager.folderManagers.length, 0);
+		it('does nothing when worktrees property is not available', function () {
+			const repo = new MockRepository();
+			repo.rootUri = vscode.Uri.file('/repo');
+			repo.addRemote('origin', 'git@github.com:aaa/bbb');
+
+			reposManager.insertFolderManager(new FolderRepositoryManager(0, context, repo, telemetry, new GitApiImpl(reposManager), credentialStore, createPrHelper, mockThemeWatcher));
+
+			assert.strictEqual(reposManager.folderManagers.length, 1);
+
+			// Fire state change without setting worktrees (stays undefined)
+			(repo as any)._onDidChangeState.fire();
+
+			assert.strictEqual(reposManager.folderManagers.length, 1);
 		});
 	});
 });
diff --git a/src/test/mocks/mockRepository.ts b/src/test/mocks/mockRepository.ts
@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Uri } from 'vscode';
+import { EventEmitter, Uri } from 'vscode';
 import { RefType } from '../../api/api1';
 
 import type {
@@ -19,6 +19,7 @@ import type {
 	BranchQuery,
 	FetchOptions,
 	RefQuery,
+	Worktree,
 } from '../../api/api';
 
 type Mutable<T> = {
@@ -67,18 +68,21 @@ export class MockRepository implements Repository {
 		return Promise.reject(new Error(`Unexpected log(${options})`));
 	}
 
+	private _onDidChangeState = new EventEmitter<void>();
+
 	private _state: Mutable<RepositoryState & { refs: Ref[] }> = {
 		HEAD: {
 			type: RefType.Head
 		},
 		refs: [],
 		remotes: [],
 		submodules: [],
+		worktrees: undefined,
 		rebaseCommit: undefined,
 		mergeChanges: [],
 		indexChanges: [],
 		workingTreeChanges: [],
-		onDidChange: () => ({ dispose() { } }),
+		onDidChange: this._onDidChangeState.event,
 	};
 	private _config: Map<string, string> = new Map();
 	private _branches: Branch[] = [];
@@ -337,4 +341,9 @@ export class MockRepository implements Repository {
 	mergeAbort(): Promise<void> {
 		return Promise.reject(new Error(`Unexpected mergeAbort`));
 	}
+
+	setWorktrees(worktrees: Worktree[]) {
+		this._state.worktrees = worktrees;
+		this._onDidChangeState.fire();
+	}
 }
diff --git a/src/view/prsTreeDataProvider.ts b/src/view/prsTreeDataProvider.ts
@@ -62,8 +62,7 @@ export class PullRequestsTreeDataProvider extends Disposable implements vscode.T
 				this.refreshAllQueryResults(true);
 			}
 		}));
-		this._register(vscode.commands.registerCommand('pr.refreshList', async _ => {
-			await this._reposManager.removeMissingRepos();
+		this._register(vscode.commands.registerCommand('pr.refreshList', _ => {
 			this.prsTreeModel.forceClearCache();
 			this.refreshAllQueryResults(true);
 		}));
