make sync safer by requiring confirmation if it has remote changes

Author: wbbradley

src/git.rs

@@ -188,7 +188,7 @@ pub(crate) fn git_checkout_main(repo: &GitRepo, new_branch: Option<&str>) -> Res
     }
     git_fetch()?;
     let remote = DEFAULT_REMOTE;
-    let trunk = git_trunk(repo)?;
+    let trunk = git_trunk(repo).ok_or_else(|| anyhow!("No remote configured"))?;
 
     // Check that we don't orphan unpushed changes in the local `main` branch.
     if !repo.is_ancestor(&trunk.main_branch, &trunk.remote_main)? {
@@ -228,12 +228,10 @@ pub(crate) struct GitTrunk {
     pub(crate) main_branch: String,
 }
 
-pub(crate) fn git_trunk(git_repo: &GitRepo) -> Result<GitTrunk> {
-    let remote_main = git_repo.remote_main(DEFAULT_REMOTE)?;
-    let main_branch = after_text(&remote_main, format!("{DEFAULT_REMOTE}/"))
-        .ok_or(anyhow!("no branch?"))?
-        .to_string();
-    Ok(GitTrunk {
+pub(crate) fn git_trunk(git_repo: &GitRepo) -> Option<GitTrunk> {
+    let remote_main = git_repo.remote_main(DEFAULT_REMOTE).ok()?;
+    let main_branch = after_text(&remote_main, format!("{DEFAULT_REMOTE}/"))?.to_string();
+    Some(GitTrunk {
         remote_main,
         main_branch,
     })

src/main.rs

@@ -968,8 +968,8 @@ fn status(
     if fetch {
         git_fetch()?;
     }
-    // ensure_trunk creates the tree if it doesn't exist
-    let _trunk = state.ensure_trunk(git_repo, repo)?;
+    // ensure_trunk creates the tree if it doesn't exist (no-op if no remote)
+    let _trunk = state.ensure_trunk(git_repo, repo);
 
     // Auto-cleanup any missing branches before displaying the tree
     state.auto_cleanup_missing_branches(git_repo, repo)?;
@@ -980,9 +980,10 @@ fn status(
     // Load display_authors for filtering (show other authors dimmed)
     let display_authors = github::load_display_authors();
 
-    let tree = state
-        .get_tree_mut(repo)
-        .expect("tree exists after ensure_trunk");
+    let Some(tree) = state.get_tree_mut(repo) else {
+        println!("No stack configured for this repository.");
+        return Ok(());
+    };
     recur_tree(
         git_repo,
         tree,
@@ -1029,7 +1030,7 @@ fn restack(
     }
 
     // Check if user is trying to restack the trunk branch
-    let trunk = git_trunk(git_repo)?;
+    let trunk = git_trunk(git_repo).ok_or_else(|| anyhow!("No remote configured"))?;
     if restack_branch == trunk.main_branch {
         println!(
             "You are on the trunk branch ({}). Nothing to restack.",
@@ -1290,7 +1291,8 @@ fn sync_pr_bases_after_restack(git_repo: &GitRepo, state: &State, repo: &str) ->
         .get_tree(repo)
         .ok_or_else(|| anyhow!("No stack tree found"))?;
 
-    let trunk = crate::git::git_trunk(git_repo)?;
+    let trunk =
+        crate::git::git_trunk(git_repo).ok_or_else(|| anyhow!("No remote configured"))?;
 
     // Collect branches with depth for bottom-up processing
     let branches_with_depth = collect_branches_with_depth(tree, &tree.name, 0);
@@ -1516,10 +1518,11 @@ fn handle_import_command(
     }
 
     let client = GitHubClient::from_env(&repo_id)?;
-    let trunk = crate::git::git_trunk(git_repo)?;
+    let trunk =
+        crate::git::git_trunk(git_repo).ok_or_else(|| anyhow!("No remote configured"))?;
 
     // Ensure trunk exists in tree
-    state.ensure_trunk(git_repo, repo)?;
+    state.ensure_trunk(git_repo, repo);
 
     if import_all {
         // Import all open PRs
@@ -1542,7 +1545,9 @@ fn handle_import_command(
 
     // Show the tree
     println!();
-    let tree = state.get_tree(repo).expect("tree exists after import");
+    let Some(tree) = state.get_tree(repo) else {
+        return Ok(());
+    };
     let pr_cache = fetch_pr_cache(git_repo);
     let display_authors = github::load_display_authors();
     recur_tree(
@@ -1819,7 +1824,8 @@ fn handle_pr_command(
             state.try_auto_mount(git_repo, repo, &branch_name)?;
 
             // Check if this is the trunk branch (can't create PR for main)
-            let trunk = crate::git::git_trunk(git_repo)?;
+            let trunk = crate::git::git_trunk(git_repo)
+                .ok_or_else(|| anyhow!("No remote configured"))?;
             if branch_name == trunk.main_branch {
                 bail!(
                     "Cannot create a PR for the trunk branch '{}'.",
@@ -1991,7 +1997,8 @@ fn handle_pr_command(
         PrAction::Sync { all, dry_run } => {
             use github::UpdatePrRequest;
 
-            let trunk = crate::git::git_trunk(git_repo)?;
+            let trunk = crate::git::git_trunk(git_repo)
+                .ok_or_else(|| anyhow!("No remote configured"))?;
 
             // Get branches to sync with depth for bottom-up processing
             let branches_to_sync: Vec<(String, String, usize)> = if all {

src/state.rs

@@ -189,13 +189,14 @@ impl State {
         current_upstream: Option<String>,
         branch_name: String,
     ) -> Result<()> {
-        let trunk = git_trunk(git_repo)?;
         // Ensure the main branch is in the git-stack tree for this repo if we haven't
-        // added it yet.
-        self.repos
-            .entry(repo.to_string())
-            .or_insert_with(|| RepoState::new(Branch::new(trunk.main_branch.clone(), None)));
-        self.save_state()?;
+        // added it yet (only if we have a remote configured).
+        if let Some(trunk) = git_trunk(git_repo) {
+            self.repos
+                .entry(repo.to_string())
+                .or_insert_with(|| RepoState::new(Branch::new(trunk.main_branch.clone(), None)));
+            self.save_state()?;
+        }
 
         let branch_exists_in_tree = self.branch_exists_in_tree(repo, &branch_name);
         let branch_exists_locally = git_branch_exists(git_repo, &branch_name);
@@ -574,15 +575,15 @@ impl State {
         Ok(())
     }
 
-    pub(crate) fn ensure_trunk(&mut self, git_repo: &GitRepo, repo: &str) -> Result<GitTrunk> {
+    pub(crate) fn ensure_trunk(&mut self, git_repo: &GitRepo, repo: &str) -> Option<GitTrunk> {
         let trunk = git_trunk(git_repo)?;
         // The branch might not exist in git, let's create it, and add it to the tree.
         // Ensure the main branch is in the git-stack tree for this repo if we haven't
         // added it yet.
         self.repos
             .entry(repo.to_string())
             .or_insert_with(|| RepoState::new(Branch::new(trunk.main_branch.clone(), None)));
-        Ok(trunk)
+        Some(trunk)
     }
 
     pub(crate) fn mount(
@@ -592,16 +593,20 @@ impl State {
         branch_name: &str,
         parent_branch: Option<String>,
     ) -> Result<()> {
-        let trunk = self.ensure_trunk(git_repo, repo)?;
+        let trunk = self.ensure_trunk(git_repo, repo);
 
-        if trunk.main_branch == branch_name {
-            bail!(
-                "Branch {branch_name} cannot be stacked on anything else.",
-                branch_name = branch_name.red()
-            );
+        if let Some(ref trunk) = trunk {
+            if trunk.main_branch == branch_name {
+                bail!(
+                    "Branch {branch_name} cannot be stacked on anything else.",
+                    branch_name = branch_name.red()
+                );
+            }
         }
 
-        let parent_branch = parent_branch.unwrap_or(trunk.main_branch);
+        let parent_branch = parent_branch
+            .or_else(|| trunk.map(|t| t.main_branch))
+            .ok_or_else(|| anyhow!("No parent branch specified and no remote configured"))?;
 
         if branch_name == parent_branch {
             bail!(
@@ -678,7 +683,9 @@ impl State {
         // For each sub-branch in the tree, check if the parent
 
         tracing::debug!("Refreshing lkgs for all branches...");
-        let trunk = git_trunk(git_repo)?;
+        let Some(trunk) = git_trunk(git_repo) else {
+            return Ok(());
+        };
 
         let mut parent_lkgs: HashMap<String, Option<String>> = HashMap::default();
 
@@ -800,8 +807,8 @@ impl State {
         repo: &str,
         branch_name: &str,
     ) -> Result<bool> {
-        // Ensure the tree exists for this repo
-        self.ensure_trunk(git_repo, repo)?;
+        // Ensure the tree exists for this repo (no-op if no remote)
+        self.ensure_trunk(git_repo, repo);
 
         // Check if the branch is already in the tree
         if self.branch_exists_in_tree(repo, branch_name) {
@@ -813,8 +820,10 @@ impl State {
             bail!("Branch {branch_name} does not exist in git");
         }
 
-        // Get the tree for this repo (guaranteed to exist after ensure_trunk)
-        let tree = self.get_tree(repo).expect("tree exists after ensure_trunk");
+        // Get the tree for this repo (may not exist if no remote configured)
+        let Some(tree) = self.get_tree(repo) else {
+            return Ok(false);
+        };
 
         // Collect all mounted branches
         let mut all_branches = Vec::new();
@@ -831,7 +840,10 @@ impl State {
         // Determine the parent branch
         let parent_branch = if ancestor_branches.is_empty() {
             // No ancestors found, default to the trunk/main branch
-            let trunk = git_trunk(git_repo)?;
+            let Some(trunk) = git_trunk(git_repo) else {
+                // No remote configured and no ancestor branches - can't auto-mount
+                return Ok(false);
+            };
             tracing::info!(
                 "No mounted ancestor branches found for {}. Defaulting to trunk branch {}.",
                 branch_name,

src/sync.rs

@@ -195,6 +195,10 @@ impl SyncPlan {
     pub fn is_empty(&self) -> bool {
         self.local_changes.is_empty() && self.remote_changes.is_empty()
     }
+
+    pub fn has_remote_changes(&self) -> bool {
+        !self.remote_changes.is_empty()
+    }
 }
 
 // ============== Sync Options ==============
@@ -338,7 +342,22 @@ pub fn sync(git_repo: &GitRepo, state: &mut State, repo: &str, options: SyncOpti
             "\n{}",
             "Dry run mode: no changes applied.".bright_blue().bold()
         );
+    } else if plan.has_remote_changes() {
+        // Prompt for confirmation before applying remote changes
+        if !std::io::stdin().is_terminal() {
+            bail!(
+                "Remote changes require confirmation. Use --dry-run to preview or run interactively to confirm."
+            );
+        }
+        if confirm_remote_changes() {
+            println!("\nApplying changes...");
+            apply_plan(git_repo, state, repo, &client, &repo_id, &plan)?;
+            println!("\n{}", "Sync complete!".green().bold());
+        } else {
+            println!("\n{}", "Aborted.".yellow());
+        }
     } else {
+        // Only local changes - apply without confirmation
         println!("\nApplying changes...");
         apply_plan(git_repo, state, repo, &client, &repo_id, &plan)?;
         println!("\n{}", "Sync complete!".green().bold());
@@ -347,6 +366,21 @@ pub fn sync(git_repo: &GitRepo, state: &mut State, repo: &str, options: SyncOpti
     Ok(())
 }
 
+/// Prompt user to confirm remote changes
+fn confirm_remote_changes() -> bool {
+    use std::io::{self, Write};
+
+    print!("Apply remote changes? [y/N] ");
+    io::stdout().flush().unwrap();
+
+    let mut input = String::new();
+    if io::stdin().read_line(&mut input).is_err() {
+        return false;
+    }
+
+    matches!(input.trim().to_lowercase().as_str(), "y" | "yes")
+}
+
 // ============== Stage 1: Read Functions ==============
 
 /// Garbage collect seen SHAs that are no longer needed.
@@ -447,7 +481,7 @@ fn collect_tracked_branch_shas(git_repo: &GitRepo, branch: &Branch) -> Vec<Strin
 
 /// Read current local state from git-stack and git
 fn read_local_state(git_repo: &GitRepo, state: &State, repo: &str) -> Result<LocalState> {
-    let trunk = git_trunk(git_repo)?;
+    let trunk = git_trunk(git_repo).ok_or_else(|| anyhow!("No remote configured"))?;
     let mut branches = HashMap::new();
 
     // Get the tree for this repo
@@ -1141,7 +1175,7 @@ fn apply_plan(
 
         if unmount_set.contains(current_branch.as_str()) {
             // Find the first ancestor that's NOT being unmounted
-            let trunk = git_trunk(git_repo)?;
+            let trunk = git_trunk(git_repo).ok_or_else(|| anyhow!("No remote configured"))?;
             let mut safe_branch = trunk.main_branch.clone();
             let mut current = current_branch.clone();