remove is_local bit from branches

Author: wbbradley

src/github.rs

@@ -22,10 +22,10 @@ use crate::{git2_ops::GitRepo, state::write_file_secure};
 pub struct GitHubConfig {
     pub token: String,
     pub api_base: String,
-    /// GitHub usernames whose PRs should be synced.
-    /// When non-empty, only PRs from these authors will be synced.
-    /// When empty, PRs from forks will be excluded.
-    pub sync_authors: Vec<String>,
+    /// GitHub usernames whose PRs should be displayed prominently in status.
+    /// When non-empty, PRs from other authors will be shown dimmed/collapsed.
+    /// No longer used for filtering during sync.
+    pub display_authors: Vec<String>,
 }
 
 /// Repository identification (owner/repo extracted from remote URL)
@@ -241,7 +241,7 @@ pub struct CachedPrUser {
 /// Result from list_prs operations, containing both filtered PRs and all author mappings
 #[derive(Debug)]
 pub struct PrListResult {
-    /// Filtered PRs (by sync_authors or fork filter)
+    /// PRs filtered to exclude forks
     pub prs: std::collections::HashMap<String, PullRequest>,
     /// All branch -> author mappings (before filtering)
     pub all_authors: std::collections::HashMap<String, String>,
@@ -303,7 +303,7 @@ impl GitHubClient {
 
     /// Load config from environment/git config/config file
     pub fn from_env(repo_id: &RepoIdentifier) -> Result<Self, GitHubError> {
-        let (token, sync_authors) = find_github_config(&repo_id.host)?;
+        let (token, display_authors) = find_github_config(&repo_id.host)?;
         let api_base = if repo_id.host == "github.com" {
             "https://api.github.com".to_string()
         } else {
@@ -312,7 +312,7 @@ impl GitHubClient {
         Ok(Self::new(GitHubConfig {
             token,
             api_base,
-            sync_authors,
+            display_authors,
         }))
     }
 
@@ -449,25 +449,11 @@ impl GitHubClient {
             .map(|pr| (pr.head.ref_name.clone(), pr.user.login.clone()))
             .collect();
 
-        // Build map of head branch name -> PR, filtering out irrelevant PRs
+        // Build map of head branch name -> PR, filtering out PRs from forks
         let prs: std::collections::HashMap<String, PullRequest> = all_prs
             .into_iter()
             .filter(|pr| {
-                // If sync_authors is configured, only include PRs from those authors
-                if !self.config.sync_authors.is_empty() {
-                    let included = self.config.sync_authors.contains(&pr.user.login);
-                    if !included {
-                        tracing::debug!(
-                            "Skipping PR #{} '{}' - author '{}' not in sync_authors",
-                            pr.number,
-                            pr.title,
-                            pr.user.login
-                        );
-                    }
-                    return included;
-                }
-
-                // Otherwise, filter out PRs from forks
+                // Filter out PRs from forks (we can't track remote branches for forks)
                 if pr.is_from_fork() {
                     tracing::debug!(
                         "Skipping PR #{} '{}' - from fork (head: {:?})",
@@ -477,7 +463,6 @@ impl GitHubClient {
                     );
                     return false;
                 }
-
                 true
             })
             .map(|pr| (pr.head.ref_name.clone(), pr))
@@ -568,14 +553,9 @@ impl GitHubClient {
         Ok(PrListResult { prs, all_authors })
     }
 
-    /// Check if a PR should be included based on sync_authors and fork filtering
+    /// Check if a PR should be included based on fork filtering
     fn should_include_pr(&self, pr: &PullRequest) -> bool {
-        // If sync_authors is configured, only include PRs from those authors
-        if !self.config.sync_authors.is_empty() {
-            return self.config.sync_authors.contains(&pr.user.login);
-        }
-
-        // Otherwise, filter out PRs from forks
+        // Filter out PRs from forks (we can't track remote branches for forks)
         !pr.is_from_fork()
     }
 
@@ -774,28 +754,36 @@ fn load_github_config_file() -> Option<GitHubConfigFile> {
     serde_yaml::from_str(&contents).ok()
 }
 
+/// Load display_authors from the GitHub config file.
+/// Returns an empty vec if the config file doesn't exist or has no display_authors.
+pub fn load_display_authors() -> Vec<String> {
+    load_github_config_file()
+        .map(|c| c.display_authors)
+        .unwrap_or_default()
+}
+
 /// Find GitHub token and config from various sources
 fn find_github_config(host: &str) -> Result<(String, Vec<String>), GitHubError> {
     let config_file = load_github_config_file();
-    let sync_authors = config_file
+    let display_authors = config_file
         .as_ref()
-        .map(|c| c.sync_authors.clone())
+        .map(|c| c.display_authors.clone())
         .unwrap_or_default();
 
     // 1. Check GITHUB_TOKEN env var
     if let Ok(token) = std::env::var("GITHUB_TOKEN")
         && !token.is_empty()
     {
         tracing::debug!("Using GitHub token from GITHUB_TOKEN env var");
-        return Ok((token, sync_authors));
+        return Ok((token, display_authors));
     }
 
     // 2. Check GH_TOKEN env var (used by gh CLI)
     if let Ok(token) = std::env::var("GH_TOKEN")
         && !token.is_empty()
     {
         tracing::debug!("Using GitHub token from GH_TOKEN env var");
-        return Ok((token, sync_authors));
+        return Ok((token, display_authors));
     }
 
     // 3. Check git config github.token
@@ -807,7 +795,7 @@ fn find_github_config(host: &str) -> Result<(String, Vec<String>), GitHubError>
         let token = String::from_utf8_lossy(&output.stdout).trim().to_string();
         if !token.is_empty() {
             tracing::debug!("Using GitHub token from git config");
-            return Ok((token, sync_authors));
+            return Ok((token, display_authors));
         }
     }
 
@@ -818,12 +806,12 @@ fn find_github_config(host: &str) -> Result<(String, Vec<String>), GitHubError>
             && let Some(token) = hosts.get(host)
         {
             tracing::debug!("Using GitHub token from config file (host-specific)");
-            return Ok((token.clone(), sync_authors));
+            return Ok((token.clone(), display_authors));
         }
         // Fall back to default token
         if let Some(token) = config.default_token {
             tracing::debug!("Using GitHub token from config file (default)");
-            return Ok((token, sync_authors));
+            return Ok((token, display_authors));
         }
     }
 
@@ -835,11 +823,10 @@ fn find_github_config(host: &str) -> Result<(String, Vec<String>), GitHubError>
 struct GitHubConfigFile {
     default_token: Option<String>,
     hosts: Option<std::collections::HashMap<String, String>>,
-    /// GitHub usernames whose PRs should be synced.
-    /// When set, only PRs from these authors will be synced.
-    /// When empty/unset, PRs from forks will be excluded.
+    /// GitHub usernames whose PRs should be displayed prominently in status.
+    /// When set, PRs from other authors will be shown dimmed/collapsed.
     #[serde(default)]
-    sync_authors: Vec<String>,
+    display_authors: Vec<String>,
 }
 
 /// Get path to GitHub config file
@@ -857,7 +844,7 @@ pub fn save_github_token(token: &str) -> Result<()> {
         .place_config_file("github.yaml")
         .context("Failed to create config directory")?;
 
-    // Load existing config to preserve other settings (like sync_authors)
+    // Load existing config to preserve other settings (like display_authors)
     let mut config = load_github_config_file().unwrap_or_default();
     config.default_token = Some(token.to_string());
 

src/main.rs

@@ -478,7 +478,23 @@ fn recur_tree(
     parent_branch: Option<&str>,
     verbose: bool,
     pr_cache: Option<&std::collections::HashMap<String, github::PullRequest>>,
+    display_authors: &[String],
 ) -> Result<()> {
+    // Check if this branch should be dimmed (filtered by display_authors)
+    let pr_author = pr_cache
+        .and_then(|cache| cache.get(&branch.name))
+        .map(|pr| pr.user.login.as_str());
+    let is_dimmed = if display_authors.is_empty() {
+        false
+    } else {
+        pr_author.map_or(false, |author| {
+            !display_authors.contains(&author.to_string())
+        })
+    };
+
+    // Check if branch is remote-only (not local)
+    let is_remote_only = !git_repo.branch_exists(&branch.name);
+
     let Ok(branch_status) = git_repo
         .branch_status(parent_branch, &branch.name)
         .with_context(|| {
@@ -488,6 +504,44 @@ fn recur_tree(
             )
         })
     else {
+        // For remote-only branches, the local branch may not exist
+        if is_remote_only {
+            // Show remote-only branch even without status
+            let is_current_branch = branch.name == orig_branch;
+            if is_current_branch {
+                print!("{} ", selection_marker().bright_purple().bold());
+            } else {
+                print!("  ");
+            }
+            for _ in 0..depth {
+                print!("{}", "┃ ".truecolor(55, 55, 50));
+            }
+            let branch_name_colored = if is_dimmed {
+                branch.name.truecolor(90, 90, 90)
+            } else {
+                branch.name.truecolor(128, 128, 128)
+            };
+            println!(
+                "{} {}",
+                branch_name_colored,
+                "(remote)".truecolor(90, 90, 90)
+            );
+
+            // Recurse into children
+            for child in &branch.branches {
+                recur_tree(
+                    git_repo,
+                    child,
+                    depth + 1,
+                    orig_branch,
+                    Some(branch.name.as_ref()),
+                    verbose,
+                    pr_cache,
+                    display_authors,
+                )?;
+            }
+            return Ok(());
+        }
         tracing::warn!("Branch {} does not exist", branch.name);
         return Ok(());
     };
@@ -504,11 +558,23 @@ fn recur_tree(
     }
 
     // Branch name coloring: green for synced, red for diverged, bold for current branch
-    let branch_name_colored = match (is_current_branch, branch_status.is_descendent) {
-        (true, true) => branch.name.truecolor(142, 192, 124).bold(),
-        (true, false) => branch.name.red().bold(),
-        (false, true) => branch.name.truecolor(142, 192, 124),
-        (false, false) => branch.name.red(),
+    // Dimmed branches (filtered by display_authors) are shown in gray
+    let branch_name_colored = if is_dimmed {
+        branch.name.truecolor(90, 90, 90)
+    } else {
+        match (is_current_branch, branch_status.is_descendent) {
+            (true, true) => branch.name.truecolor(142, 192, 124).bold(),
+            (true, false) => branch.name.red().bold(),
+            (false, true) => branch.name.truecolor(142, 192, 124),
+            (false, false) => branch.name.red(),
+        }
+    };
+
+    // Remote-only indicator
+    let remote_indicator = if is_remote_only {
+        " (remote)".truecolor(90, 90, 90).to_string()
+    } else {
+        String::new()
     };
 
     // Get diff stats from LKG ancestor to current branch
@@ -553,8 +619,9 @@ fn recur_tree(
 
     if verbose {
         println!(
-            "{}{}{} ({}) {}{}{}{}",
+            "{}{}{}{} ({}) {}{}{}{}",
             branch_name_colored,
+            remote_indicator,
             diff_stats,
             local_status,
             branch_status.sha[..8].truecolor(215, 153, 33),
@@ -654,8 +721,8 @@ fn recur_tree(
             String::new()
         };
         println!(
-            "{}{}{}{}",
-            branch_name_colored, diff_stats, local_status, pr_info
+            "{}{}{}{}{}",
+            branch_name_colored, remote_indicator, diff_stats, local_status, pr_info
         );
     }
 
@@ -695,6 +762,7 @@ fn recur_tree(
             Some(branch.name.as_ref()),
             verbose,
             pr_cache,
+            display_authors,
         )?;
     }
     Ok(())
@@ -740,6 +808,9 @@ fn status(
     // Try to fetch PR info from GitHub (graceful degradation on failure)
     let pr_cache = fetch_pr_cache(git_repo);
 
+    // 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");
@@ -751,6 +822,7 @@ fn status(
         None,
         verbose,
         pr_cache.as_ref(),
+        &display_authors,
     )?;
     if !state.branch_exists_in_tree(repo, orig_branch) {
         eprintln!(
@@ -1186,7 +1258,17 @@ fn handle_import_command(
     println!();
     let tree = state.get_tree(repo).expect("tree exists after import");
     let pr_cache = fetch_pr_cache(git_repo);
-    recur_tree(git_repo, tree, 0, branch, None, false, pr_cache.as_ref())?;
+    let display_authors = github::load_display_authors();
+    recur_tree(
+        git_repo,
+        tree,
+        0,
+        branch,
+        None,
+        false,
+        pr_cache.as_ref(),
+        &display_authors,
+    )?;
 
     Ok(())
 }

src/state.rs

@@ -178,6 +178,9 @@ impl State {
     /// then check whether the branch exists in the git repo. If it does, then let the user know
     /// that they need to use `git checkout` to check it out. If it doesn't, then create a new
     /// branch.
+    ///
+    /// For branches tracked in git-stack but not existing locally, this will create the local
+    /// branch from the remote ref (origin/branch_name) on-demand.
     pub fn checkout(
         &mut self,
         git_repo: &GitRepo,
@@ -195,8 +198,10 @@ impl State {
         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);
 
-        if git_branch_exists(git_repo, &branch_name) {
+        // Case 1: Branch exists locally - just check it out
+        if branch_exists_locally {
             if !branch_exists_in_tree {
                 tracing::warn!(
                     "Branch {branch_name} exists in the git repo but is not tracked by git-stack. \
@@ -208,6 +213,26 @@ impl State {
             return Ok(());
         }
 
+        // Case 2: Branch is in tree but doesn't exist locally - create from remote
+        if branch_exists_in_tree {
+            let remote_ref = format!("origin/{}", branch_name);
+            if git_repo.ref_exists(&remote_ref) {
+                // Create local branch from remote ref
+                run_git(&["checkout", "-b", &branch_name, &remote_ref])?;
+                println!(
+                    "Branch {branch_name} created from remote and checked out.",
+                    branch_name = branch_name.yellow()
+                );
+                return Ok(());
+            } else {
+                bail!(
+                    "Branch {branch_name} is tracked by git-stack but doesn't exist locally or on remote.",
+                    branch_name = branch_name.red()
+                );
+            }
+        }
+
+        // Case 3: Branch doesn't exist anywhere - create a new branch from current
         let branch = self
             .get_tree_branch_mut(repo, &current_branch)
             .ok_or_else(|| {