wip

Author: wbbradley

Cargo.lock

@@ -14,6 +14,7 @@ repository = "https://github.com/wbbradley/git-stack"
 anyhow = { version = "1.0.98", features = ["backtrace"] }
 chrono = "0.4.41"
 clap = { version = "4.5.37", features = ["derive"] }
+clap_complete = "4.5.65"
 colored = "3.0.0"
 crossterm = "0.29.0"
 git2 = "0.20"

Cargo.toml

@@ -142,16 +142,6 @@ enum Command {
         #[command(subcommand)]
         action: CacheAction,
     },
-    /// Import branch stack from existing GitHub PRs.
-    /// Reconstructs the git-stack tree by walking the PR base chain.
-    Import {
-        /// Branch to import (defaults to current branch)
-        #[arg(long, short)]
-        branch: Option<String>,
-        /// Import all open PRs for the repo, not just the current branch's chain
-        #[arg(long, short)]
-        all: bool,
-    },
     /// Sync local git-stack state with GitHub PRs.
     /// Default: weak push then weak pull (bidirectional sync).
     Sync {
@@ -396,10 +386,6 @@ fn inner_main() -> Result<()> {
         Some(Command::Cache { action }) => {
             handle_cache_command(&git_repo, &mut state, &repo, action)
         }
-        Some(Command::Import { branch, all }) => {
-            let branch = branch.unwrap_or(current_branch);
-            handle_import_command(&git_repo, &mut state, &repo, &branch, all)
-        }
         Some(Command::Sync {
             push,
             pull,
@@ -1233,293 +1219,6 @@ fn git_push(git_repo: &GitRepo, branch: &str) -> Result<()> {
     Ok(())
 }
 
-// ============== GitHub Import Command ==============
-
-fn handle_import_command(
-    git_repo: &GitRepo,
-    state: &mut State,
-    repo: &str,
-    branch: &str,
-    import_all: bool,
-) -> Result<()> {
-    use github::{
-        GitHubClient,
-        get_repo_identifier,
-        has_github_token,
-        setup_github_token_interactive,
-    };
-
-    let repo_id = get_repo_identifier(git_repo)?;
-
-    // Ensure we have auth configured
-    if !has_github_token(&repo_id.host) {
-        println!("{}", "GitHub authentication required.".yellow());
-        setup_github_token_interactive()?;
-    }
-
-    let client = GitHubClient::from_env(&repo_id)?;
-    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);
-
-    if import_all {
-        // Import all open PRs
-        import_all_prs(git_repo, &client, &repo_id, state, repo, &trunk.main_branch)?;
-    } else {
-        // Import just this branch's chain
-        import_branch_chain(
-            git_repo,
-            &client,
-            &repo_id,
-            state,
-            repo,
-            branch,
-            &trunk.main_branch,
-        )?;
-    }
-
-    state.save_state()?;
-    println!("\n{}", "Import complete!".green().bold());
-
-    // Show the tree
-    println!();
-    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();
-    let renderable = render::compute_renderable_tree(
-        git_repo,
-        tree,
-        branch,
-        false,
-        pr_cache.as_ref(),
-        &display_authors,
-    );
-    render::render_cli(&renderable, false);
-
-    Ok(())
-}
-
-/// Import a single branch's PR chain back to trunk
-fn import_branch_chain(
-    git_repo: &GitRepo,
-    client: &github::GitHubClient,
-    repo_id: &github::RepoIdentifier,
-    state: &mut State,
-    repo: &str,
-    branch: &str,
-    trunk: &str,
-) -> Result<()> {
-    // Find PR for this branch
-    let pr = client.find_pr_for_branch(repo_id, branch)?.ok_or_else(|| {
-        anyhow!(
-            "No open PR found for branch '{}'. Nothing to import.",
-            branch
-        )
-    })?;
-
-    println!(
-        "Found PR #{} for '{}' (base: '{}')",
-        pr.number.to_string().green(),
-        branch.yellow(),
-        pr.base.ref_name.cyan()
-    );
-
-    // Build the chain from this branch up to trunk
-    let mut chain: Vec<(String, Option<github::PullRequest>)> =
-        vec![(branch.to_string(), Some(pr.clone()))];
-    let mut current_base = pr.base.ref_name.clone();
-
-    while current_base != trunk {
-        // Check if we already have this branch in our chain (cycle detection)
-        if chain.iter().any(|(b, _)| b == &current_base) {
-            println!(
-                "{} Detected cycle at '{}', stopping chain walk",
-                "Warning:".yellow().bold(),
-                current_base
-            );
-            break;
-        }
-
-        // Find PR for the base branch
-        match client.find_pr_for_branch(repo_id, &current_base)? {
-            Some(base_pr) => {
-                println!(
-                    "Found PR #{} for '{}' (base: '{}')",
-                    base_pr.number.to_string().green(),
-                    current_base.yellow(),
-                    base_pr.base.ref_name.cyan()
-                );
-                let next_base = base_pr.base.ref_name.clone();
-                chain.push((current_base.clone(), Some(base_pr)));
-                current_base = next_base;
-            }
-            None => {
-                // No PR for this base - it might be an intermediate branch or already merged
-                // Check if it's the trunk
-                if current_base == trunk {
-                    break;
-                }
-                println!(
-                    "{} No PR found for '{}', assuming it's an intermediate branch",
-                    "Note:".cyan().bold(),
-                    current_base.yellow()
-                );
-                chain.push((current_base.clone(), None));
-                // We can't walk further without a PR, assume parent is trunk
-                break;
-            }
-        }
-    }
-
-    // Reverse to process from trunk-side down
-    chain.reverse();
-
-    // Mount each branch in order
-    let mut parent = trunk.to_string();
-    for (branch_name, pr_opt) in chain {
-        // Check if branch exists locally
-        if !git_repo.branch_exists(&branch_name) {
-            println!(
-                "{} Branch '{}' doesn't exist locally, skipping",
-                "Note:".cyan().bold(),
-                branch_name.yellow()
-            );
-            continue;
-        }
-
-        // Mount this branch under the parent
-        if !state.branch_exists_in_tree(repo, &branch_name) {
-            println!(
-                "Mounting '{}' on '{}'",
-                branch_name.yellow(),
-                parent.green()
-            );
-            state.mount(git_repo, repo, &branch_name, Some(parent.clone()))?;
-        } else {
-            println!("'{}' already in tree", branch_name.yellow());
-        }
-
-        // Store PR number if we have one
-        if let Some(pr) = pr_opt
-            && let Some(tree_branch) =
-                find_branch_by_name_mut(state.get_tree_mut(repo).unwrap(), &branch_name)
-            && tree_branch.pr_number.is_none()
-        {
-            tree_branch.pr_number = Some(pr.number);
-        }
-
-        parent = branch_name;
-    }
-
-    Ok(())
-}
-
-/// Import all open PRs for the repo
-fn import_all_prs(
-    git_repo: &GitRepo,
-    client: &github::GitHubClient,
-    repo_id: &github::RepoIdentifier,
-    state: &mut State,
-    repo: &str,
-    trunk: &str,
-) -> Result<()> {
-    let all_prs = client.list_open_prs(repo_id, None)?.prs;
-
-    if all_prs.is_empty() {
-        println!("No open PRs found for this repository.");
-        return Ok(());
-    }
-
-    println!("Found {} open PR(s)", all_prs.len().to_string().green());
-
-    // Build a map of branch -> (parent, pr_number)
-    let mut branch_parents: std::collections::HashMap<String, (String, u64)> =
-        std::collections::HashMap::new();
-
-    for (branch_name, pr) in &all_prs {
-        branch_parents.insert(branch_name.clone(), (pr.base.ref_name.clone(), pr.number));
-    }
-
-    // Find branches whose parent is trunk or another PR branch (roots of stacks)
-    // Then build each stack
-    let mut imported = std::collections::HashSet::new();
-
-    // Process in order: first branches based on trunk, then their children, etc.
-    let mut to_process: Vec<String> = branch_parents
-        .iter()
-        .filter(|(_, (parent, _))| parent == trunk)
-        .map(|(branch, _)| branch.clone())
-        .collect();
-
-    while !to_process.is_empty() {
-        let branch_name = to_process.remove(0);
-
-        if imported.contains(&branch_name) {
-            continue;
-        }
-
-        // Get parent and PR number
-        let (parent, pr_number) = match branch_parents.get(&branch_name) {
-            Some((p, n)) => (p.clone(), *n),
-            None => continue,
-        };
-
-        // Determine actual parent (could be trunk or another imported branch)
-        let actual_parent = if parent == trunk || imported.contains(&parent) {
-            parent.clone()
-        } else {
-            // Parent not yet imported - skip for now, will process later
-            to_process.push(branch_name);
-            continue;
-        };
-
-        // Check if branch exists locally
-        if !git_repo.branch_exists(&branch_name) {
-            println!(
-                "{} Branch '{}' doesn't exist locally (PR #{}), skipping",
-                "Note:".cyan().bold(),
-                branch_name.yellow(),
-                pr_number
-            );
-            imported.insert(branch_name.clone());
-            continue;
-        }
-
-        // Mount this branch
-        if !state.branch_exists_in_tree(repo, &branch_name) {
-            println!(
-                "Mounting '{}' on '{}' (PR #{})",
-                branch_name.yellow(),
-                actual_parent.green(),
-                pr_number
-            );
-            state.mount(git_repo, repo, &branch_name, Some(actual_parent.clone()))?;
-        }
-
-        // Store PR number
-        if let Some(tree_branch) =
-            find_branch_by_name_mut(state.get_tree_mut(repo).unwrap(), &branch_name)
-            && tree_branch.pr_number.is_none()
-        {
-            tree_branch.pr_number = Some(pr_number);
-        }
-
-        imported.insert(branch_name.clone());
-
-        // Add children of this branch to process list
-        for (child, (child_parent, _)) in &branch_parents {
-            if child_parent == &branch_name && !imported.contains(child) {
-                to_process.push(child.clone());
-            }
-        }
-    }
-
-    Ok(())
-}
-
 // ============== GitHub PR Commands ==============
 
 fn handle_pr_command(