Implements but base check

Author: krlvi

crates/but/src/args.rs

@@ -48,6 +48,8 @@ For examples see `but rub --help`."
         #[clap(long, short = 'r')]
         repo: bool,
     },
+    /// Commands for managing the base.
+    Base(crate::base::Platform),
     /// Starts up the MCP server.
     Mcp {
         /// Starts the internal MCP server which has more granular tools.
@@ -81,6 +83,8 @@ pub enum CommandName {
     Status,
     #[clap(alias = "rub")]
     Rub,
+    BaseCheck,
+    BaseUpdate,
     #[clap(
         alias = "claude-pre-tool",
         alias = "claudepretool",

crates/but/src/base/mod.rs

@@ -0,0 +1,108 @@
+use std::path::Path;
+
+use colored::Colorize;
+use gitbutler_branch_actions::upstream_integration::{
+    BranchStatus::{Conflicted, Empty, Integrated, SaflyUpdatable},
+    StackStatuses::{UpToDate, UpdatesRequired},
+};
+use gitbutler_project::Project;
+
+#[derive(Debug, clap::Parser)]
+pub struct Platform {
+    #[clap(subcommand)]
+    pub cmd: Subcommands,
+}
+#[derive(Debug, clap::Subcommand)]
+pub enum Subcommands {
+    /// Fetches remotes from the remote and checks the mergeability of the branches in the workspace.
+    Check,
+    /// Updates the worspace (with all applied branches) to include the latest changes from the base branch.
+    Update,
+}
+
+pub fn handle(cmd: &Subcommands, repo_path: &Path, json: bool) -> anyhow::Result<()> {
+    match cmd {
+        Subcommands::Check => {
+            let project = Project::find_by_path(repo_path)?;
+            if !json {
+                println!("🔍 Checking base branch status...");
+            }
+            let base_branch = but_api::virtual_branches::fetch_from_remotes(
+                project.id,
+                Some("auto".to_string()),
+            )?;
+            println!("\n📍 Base branch:\t\t{}", base_branch.branch_name);
+            println!(
+                "⏫ Upstream commits:\t{} new commits on {}\n",
+                base_branch.behind, base_branch.branch_name
+            );
+            let commits = base_branch.recent_commits.iter().take(3);
+            for commit in commits {
+                println!(
+                    "\t{} {}",
+                    &commit.id[..7],
+                    &commit.description.to_string().replace('\n', " ")[..72]
+                );
+            }
+            let hidden_commits = base_branch.behind.saturating_sub(3);
+            if hidden_commits > 0 {
+                println!("\t... ({hidden_commits} more - run `but base check --all` to see all)");
+            }
+
+            let status =
+                but_api::virtual_branches::upstream_integration_statuses(project.id, None)?;
+
+            match status {
+                UpToDate => println!("\n✅ Everything is up to date"),
+                UpdatesRequired {
+                    worktree_conflicts,
+                    statuses,
+                } => {
+                    if !worktree_conflicts.is_empty() {
+                        println!(
+                            "\n❗️ There are uncommitted changes in the worktree that may conflict with the updates."
+                        );
+                    }
+                    if !statuses.is_empty() {
+                        println!("\n{}", "Active Branch Status".bold());
+                        for (_id, status) in statuses {
+                            for bs in status.branch_statuses {
+                                let status_icon = match bs.status {
+                                    SaflyUpdatable => "✅".to_string(),
+                                    Integrated => "🔄".to_string(),
+                                    Conflicted { rebasable } => {
+                                        if rebasable {
+                                            "⚠️".to_string()
+                                        } else {
+                                            "❗️".to_string()
+                                        }
+                                    }
+                                    Empty => "✅".to_string(),
+                                };
+                                let status_text = match bs.status {
+                                    SaflyUpdatable => "Updatable".green(),
+                                    Integrated => "Integrated".blue(),
+                                    Conflicted { rebasable } => {
+                                        if rebasable {
+                                            "Conflicted (Rebasable)".yellow()
+                                        } else {
+                                            "Conflicted (Not Rebasable)".red()
+                                        }
+                                    }
+                                    Empty => "Nothing to do".normal(),
+                                };
+                                println!("\n{} {} ({})", status_icon, bs.name, status_text);
+                            }
+                        }
+                    }
+                }
+            }
+            println!("\nRun `but base update` to update your branches");
+            Ok(())
+        }
+        Subcommands::Update => {
+            // metrics_if_configured(app_settings, CommandName::Log, p).ok();
+            Ok(())
+        }
+    }
+}

crates/but/src/main.rs

@@ -6,6 +6,7 @@ use but_settings::AppSettings;
 use metrics::{Event, Metrics, Props, metrics_if_configured};
 
 use but_claude::hooks::OutputAsJson;
+mod base;
 mod command;
 mod id;
 mod init;
@@ -96,6 +97,19 @@ async fn main() -> Result<()> {
                 Ok(())
             }
         },
+        Subcommands::Base(base::Platform { cmd }) => {
+            let result = base::handle(cmd, &args.current_dir, args.json);
+            metrics_if_configured(
+                app_settings,
+                match cmd {
+                    base::Subcommands::Check => CommandName::BaseCheck,
+                    base::Subcommands::Update => CommandName::BaseUpdate,
+                },
+                props(start, &result),
+            )
+            .ok();
+            Ok(())
+        }
         Subcommands::Log => {
             let result = log::commit_graph(&args.current_dir, args.json);
             metrics_if_configured(app_settings, CommandName::Log, props(start, &result)).ok();
@@ -120,7 +134,7 @@ async fn main() -> Result<()> {
     }
 }
 
-fn props<E, T, R>(start: std::time::Instant, result: R) -> Props
+pub(crate) fn props<E, T, R>(start: std::time::Instant, result: R) -> Props
 where
     R: std::ops::Deref<Target = Result<T, E>>,
     E: std::fmt::Display,

crates/gitbutler-branch-actions/src/upstream_integration.rs

@@ -24,15 +24,15 @@ use serde::{Deserialize, Serialize};
 #[derive(Serialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct NameAndStatus {
-    name: String,
-    status: BranchStatus,
+    pub name: String,
+    pub status: BranchStatus,
 }
 
 #[derive(Serialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct StackStatus {
-    tree_status: TreeStatus,
-    branch_statuses: Vec<NameAndStatus>,
+    pub tree_status: TreeStatus,
+    pub branch_statuses: Vec<NameAndStatus>,
 }
 
 #[derive(Serialize, PartialEq, Debug)]

crates/gitbutler-project/src/project.rs

@@ -118,6 +118,15 @@ impl Project {
             ..Default::default()
         })
     }
+    /// Finds an existing project by its path. Errors out if not found.
+    pub fn find_by_path(path: &Path) -> anyhow::Result<Project> {
+        let projects = crate::list()?;
+        let project = projects
+            .into_iter()
+            .find(|p| p.path == path)
+            .context("No project found with the given path")?;
+        Ok(project)
+    }
 }
 
 impl Project {