feat: Add --dry-run flag to sync command (#214)

Add --dry-run option to sync --read-remotes and sync --write-remotes.
When set, shows what would change without making any modifications.

Sync output is now TSV with direction header, column headers, and
per-remote status lines (added/removed/modified/unchanged). Repos with
no changes are silently skipped; repos with any change show all their
remotes. Read and write output is a symmetric mirror of each other.

write-remotes now also updates URLs for existing remotes (set-url),
not just adding missing ones. It will not remove any remotes.

Direction headers clarify what is being updated:
  Updating .gitopolis.toml with values from git repo remotes...
  Updating git repo remotes with values from .gitopolis.toml...

Rewrote sync e2e tests: 4 core tests (read/write x real/dry-run) each
cover added, removed, modified, unchanged, and no-remotes edge cases
with full TOML assertions. Added test helpers for git repo setup.

Fixes #214

Prompts:
- do this Add dry-run arg for sync commands · Issue #214 · timabell/gitopolis
- (approved plan)
- commit (x4, rejected cat/heredoc/tempfile approaches)
- commit - bbc60c3
- dry run should output what it is changing to, and needs a clearer message in both directions for all repos. output all the before/after urls
- newlines between repos
- direction isn't clear, output needs to somehow indicate config->repo
- skip repos with no change but show all remotes for repos with any change
- new output format (provided example: reponame status remote url [url])
- include headers for tsv
- i didn't get any output for read but did for write, what gives
- Updating git repo remotes with values from .gitopolis.toml ...
- ideally we'd have 4 tests for read/write dry/real covering added/removed/unchanged plus edge cases
- these should be an exact mirror no? (showed asymmetric output)
- don't output no changes that's not unixy
- always assert full toml. write prompt list so far to a temp file in repo before compaction
- fork URL not changed (write-remotes doesn't modify) - it should
- okay to not remove remotes though (add to command doc that it won't remove any remotes)
- yes, and remember prompts from tmp file and since then
- amend last commit, expanding description, keep subject line intact

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

Author: timabell

src/git.rs

@@ -9,6 +9,7 @@ pub trait Git {
 	fn read_url(&self, path: String, remote_name: String) -> Result<String, GitopolisError>;
 	fn read_all_remotes(&self, path: String) -> Result<BTreeMap<String, String>, GitopolisError>;
 	fn add_remote(&self, path: &str, remote_name: &str, url: &str);
+	fn set_remote_url(&self, path: &str, remote_name: &str, url: &str);
 	/// Clone a repo. Returns Ok(true) if cloned, Ok(false) if already exists (skipped).
 	fn clone(
 		&self,
@@ -75,6 +76,19 @@ impl Git for GitImpl {
 		}
 	}
 
+	fn set_remote_url(&self, path: &str, remote_name: &str, url: &str) {
+		let output = Command::new("git")
+			.current_dir(path)
+			.args(["remote", "set-url", remote_name, url])
+			.output()
+			.expect("Error running git remote set-url");
+		if !output.status.success() {
+			let stderr =
+				String::from_utf8(output.stderr).expect("Error converting stderr to string");
+			eprintln!("Warning: Failed to set URL for remote {remote_name}: {stderr}");
+		}
+	}
+
 	fn clone(
 		&self,
 		path: &str,

src/gitopolis.rs

@@ -1,6 +1,6 @@
 use crate::git::Git;
 use crate::gitopolis::GitopolisError::*;
-use crate::repos::{Repo, RepoInfo, Repos};
+use crate::repos::{Remote, Repo, RepoInfo, Repos};
 use crate::storage::Storage;
 use crate::tag_filter::TagFilter;
 use log::info;
@@ -145,21 +145,53 @@ impl Gitopolis {
 		Ok(flat)
 	}
 
-	pub fn sync_read_remotes(&mut self, filter: &TagFilter) -> Result<(), GitopolisError> {
+	pub fn sync_read_remotes(
+		&mut self,
+		filter: &TagFilter,
+		dry_run: bool,
+	) -> Result<(), GitopolisError> {
 		let mut repos = self.load()?;
 		let repo_list = self.list(filter)?;
 		let mut error_count = 0;
 
-		for repo in repo_list {
+		info!("Updating .gitopolis.toml with values from git repo remotes...");
+		info!("repo\tstatus\tremote\told_url\tnew_url");
+		for repo in &repo_list {
 			match self.git.read_all_remotes(repo.path.clone()) {
-				Ok(remotes) => {
-					// Find the repo in the mutable repos structure and update its remotes
-					if let Some(repo_mut) = repos.find_repo(repo.path.clone()) {
-						repo_mut.remotes.clear();
-						for (name, url) in remotes {
-							repo_mut.add_remote(name, url);
+				Ok(git_remotes) => {
+					if !Self::remotes_differ(&repo.remotes, &git_remotes) {
+						continue;
+					}
+
+					for (name, url) in &git_remotes {
+						match repo.remotes.get(name) {
+							Some(existing) if existing.url == *url => {
+								info!("{}\tunchanged\t{}\t{}", repo.path, name, url);
+							}
+							Some(existing) => {
+								info!(
+									"{}\tmodified\t{}\t{}\t{}",
+									repo.path, name, existing.url, url
+								);
+							}
+							None => {
+								info!("{}\tadded\t{}\t\t{}", repo.path, name, url);
+							}
+						}
+					}
+					for (name, remote) in &repo.remotes {
+						if !git_remotes.contains_key(name) {
+							info!("{}\tremoved\t{}\t{}", repo.path, name, remote.url);
+						}
+					}
+
+					if !dry_run {
+						if let Some(repo_mut) = repos.find_repo(repo.path.clone()) {
+							repo_mut.remotes.clear();
+							for (name, url) in git_remotes {
+								repo_mut.add_remote(name, url);
+							}
 						}
-						info!("Updated {} with remotes from git", repo.path);
 					}
 				}
 				Err(_) => {
@@ -169,7 +201,9 @@ impl Gitopolis {
 			}
 		}
 
-		self.save(repos)?;
+		if !dry_run {
+			self.save(repos)?;
+		}
 
 		if error_count > 0 {
 			eprintln!("{error_count} repos failed to sync");
@@ -179,12 +213,33 @@ impl Gitopolis {
 		Ok(())
 	}
 
-	pub fn sync_write_remotes(&self, filter: &TagFilter) -> Result<(), GitopolisError> {
+	fn remotes_differ(
+		config_remotes: &BTreeMap<String, Remote>,
+		git_remotes: &BTreeMap<String, String>,
+	) -> bool {
+		if config_remotes.len() != git_remotes.len() {
+			return true;
+		}
+		for (name, url) in git_remotes {
+			match config_remotes.get(name) {
+				Some(existing) if existing.url == *url => {}
+				_ => return true,
+			}
+		}
+		false
+	}
+
+	pub fn sync_write_remotes(
+		&self,
+		filter: &TagFilter,
+		dry_run: bool,
+	) -> Result<(), GitopolisError> {
 		let repo_list = self.list(filter)?;
 		let mut error_count = 0;
 
-		for repo in repo_list {
-			// Get current remotes from git
+		info!("Updating git repo remotes with values from .gitopolis.toml...");
+		info!("repo\tstatus\tremote\told_url\tnew_url");
+		for repo in &repo_list {
 			let current_remotes = match self.git.read_all_remotes(repo.path.clone()) {
 				Ok(remotes) => remotes,
 				Err(_) => {
@@ -194,11 +249,33 @@ impl Gitopolis {
 				}
 			};
 
-			// Add any missing remotes from config
+			if !Self::remotes_differ(&repo.remotes, &current_remotes) {
+				continue;
+			}
+			// Show config remotes (these are the source of truth for write)
 			for (name, remote) in &repo.remotes {
-				if !current_remotes.contains_key(name) {
-					self.git.add_remote(&repo.path, name, &remote.url);
-					info!("Added remote {} to {}", name, repo.path);
+				match current_remotes.get(name) {
+					Some(url) if *url == remote.url => {
+						info!("{}\tunchanged\t{}\t{}", repo.path, name, remote.url);
+					}
+					Some(url) => {
+						info!("{}\tmodified\t{}\t{}\t{}", repo.path, name, url, remote.url);
+						if !dry_run {
+							self.git.set_remote_url(&repo.path, name, &remote.url);
+						}
+					}
+					None => {
+						info!("{}\tadded\t{}\t\t{}", repo.path, name, remote.url);
+						if !dry_run {
+							self.git.add_remote(&repo.path, name, &remote.url);
+						}
+					}
+				}
+			}
+			// Show git remotes not in config (mirror of read's "added")
+			for (name, url) in &current_remotes {
+				if !repo.remotes.contains_key(name) {
+					info!("{}\tremoved\t{}\t{}", repo.path, name, url);
 				}
 			}
 		}

src/main.rs

@@ -89,9 +89,12 @@ enum Commands {
 		/// Update .gitopolis.toml from remotes in git repositories
 		#[arg(long, conflicts_with = "write_remotes")]
 		read_remotes: bool,
-		/// Update git repositories with remotes from .gitopolis.toml
+		/// Update git repositories with remotes from .gitopolis.toml (adds missing remotes and updates URLs, but will not remove any remotes)
 		#[arg(long, conflicts_with = "read_remotes")]
 		write_remotes: bool,
+		/// Show what would be changed without making any modifications
+		#[arg(long)]
+		dry_run: bool,
 		/// Filter by tags. Comma-separated tags use AND logic (e.g., "foo,bar" = foo AND bar).
 		/// Multiple --tag flags use OR logic (e.g., "--tag foo,bar --tag baz" = (foo AND bar) OR baz).
 		#[arg(short, long)]
@@ -188,16 +191,17 @@ fn main() {
 		Some(Commands::Sync {
 			read_remotes,
 			write_remotes,
+			dry_run,
 			tag: tag_args,
 		}) => {
 			let filter = TagFilter::from_cli_args(tag_args);
 			if *read_remotes {
 				init_gitopolis()
-					.sync_read_remotes(&filter)
+					.sync_read_remotes(&filter, *dry_run)
 					.expect("Sync read failed");
 			} else if *write_remotes {
 				init_gitopolis()
-					.sync_write_remotes(&filter)
+					.sync_write_remotes(&filter, *dry_run)
 					.expect("Sync write failed");
 			} else {
 				eprintln!("Error: Must specify either --read-remotes or --write-remotes");