Decouple core Yaak logic from Tauri (#354)

crates/yaak-git/src/add.rs

@@ -0,0 +1,16 @@
+use crate::error::Result;
+use crate::repository::open_repo;
+use git2::IndexAddOption;
+use log::info;
+use std::path::Path;
+
+pub fn git_add(dir: &Path, rela_path: &Path) -> Result<()> {
+    let repo = open_repo(dir)?;
+    let mut index = repo.index()?;
+
+    info!("Staging file {rela_path:?} to {dir:?}");
+    index.add_all(&[rela_path], IndexAddOption::DEFAULT, None)?;
+    index.write()?;
+
+    Ok(())
+}

crates/yaak-git/src/binary.rs

@@ -0,0 +1,38 @@
+use crate::error::Result;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+use crate::error::Error::GitNotFound;
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+
+#[cfg(target_os = "windows")]
+const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+
+pub(crate) fn new_binary_command(dir: &Path) -> Result<Command> {
+    // 1. Probe that `git` exists and is runnable
+    let mut probe = Command::new("git");
+    probe.arg("--version").stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
+
+    #[cfg(target_os = "windows")]
+    {
+        probe.creation_flags(CREATE_NO_WINDOW);
+    }
+
+    let status = probe.status().map_err(|_| GitNotFound)?;
+
+    if !status.success() {
+        return Err(GitNotFound);
+    }
+
+    // 2. Build the reusable git command
+    let mut cmd = Command::new("git");
+    cmd.arg("-C").arg(dir);
+
+    #[cfg(target_os = "windows")]
+    {
+        cmd.creation_flags(CREATE_NO_WINDOW);
+    }
+
+    Ok(cmd)
+}

crates/yaak-git/src/branch.rs

@@ -0,0 +1,99 @@
+use crate::error::Error::GenericError;
+use crate::error::Result;
+use crate::merge::do_merge;
+use crate::repository::open_repo;
+use crate::util::{bytes_to_string, get_branch_by_name, get_current_branch};
+use git2::BranchType;
+use git2::build::CheckoutBuilder;
+use log::info;
+use std::path::Path;
+
+pub fn git_checkout_branch(dir: &Path, branch_name: &str, force: bool) -> Result<String> {
+    if branch_name.starts_with("origin/") {
+        return git_checkout_remote_branch(dir, branch_name, force);
+    }
+
+    let repo = open_repo(dir)?;
+    let branch = get_branch_by_name(&repo, branch_name)?;
+    let branch_ref = branch.into_reference();
+    let branch_tree = branch_ref.peel_to_tree()?;
+
+    let mut options = CheckoutBuilder::default();
+    if force {
+        options.force();
+    }
+
+    repo.checkout_tree(branch_tree.as_object(), Some(&mut options))?;
+    repo.set_head(branch_ref.name().unwrap())?;
+
+    Ok(branch_name.to_string())
+}
+
+pub(crate) fn git_checkout_remote_branch(
+    dir: &Path,
+    branch_name: &str,
+    force: bool,
+) -> Result<String> {
+    let branch_name = branch_name.trim_start_matches("origin/");
+    let repo = open_repo(dir)?;
+
+    let refname = format!("refs/remotes/origin/{}", branch_name);
+    let remote_ref = repo.find_reference(&refname)?;
+    let commit = remote_ref.peel_to_commit()?;
+
+    let mut new_branch = repo.branch(branch_name, &commit, false)?;
+    let upstream_name = format!("origin/{}", branch_name);
+    new_branch.set_upstream(Some(&upstream_name))?;
+
+    git_checkout_branch(dir, branch_name, force)
+}
+
+pub fn git_create_branch(dir: &Path, name: &str) -> Result<()> {
+    let repo = open_repo(dir)?;
+    let head = match repo.head() {
+        Ok(h) => h,
+        Err(e) if e.code() == git2::ErrorCode::UnbornBranch => {
+            let msg = "Cannot create branch when there are no commits";
+            return Err(GenericError(msg.into()));
+        }
+        Err(e) => return Err(e.into()),
+    };
+    let head = head.peel_to_commit()?;
+
+    repo.branch(name, &head, false)?;
+
+    Ok(())
+}
+
+pub fn git_delete_branch(dir: &Path, name: &str) -> Result<()> {
+    let repo = open_repo(dir)?;
+    let mut branch = get_branch_by_name(&repo, name)?;
+
+    if branch.is_head() {
+        info!("Deleting head branch");
+        let branches = repo.branches(Some(BranchType::Local))?;
+        let other_branch = branches.into_iter().filter_map(|b| b.ok()).find(|b| !b.0.is_head());
+        let other_branch = match other_branch {
+            None => return Err(GenericError("Cannot delete only branch".into())),
+            Some(b) => bytes_to_string(b.0.name_bytes()?)?,
+        };
+
+        git_checkout_branch(dir, &other_branch, true)?;
+    }
+
+    branch.delete()?;
+
+    Ok(())
+}
+
+pub fn git_merge_branch(dir: &Path, name: &str, _force: bool) -> Result<()> {
+    let repo = open_repo(dir)?;
+    let local_branch = get_current_branch(&repo)?.unwrap();
+
+    let commit_to_merge = get_branch_by_name(&repo, name)?.into_reference();
+    let commit_to_merge = repo.reference_to_annotated_commit(&commit_to_merge)?;
+
+    do_merge(&repo, &local_branch, &commit_to_merge)?;
+
+    Ok(())
+}

crates/yaak-git/src/commit.rs

@@ -0,0 +1,20 @@
+use crate::binary::new_binary_command;
+use crate::error::Error::GenericError;
+use log::info;
+use std::path::Path;
+
+pub fn git_commit(dir: &Path, message: &str) -> crate::error::Result<()> {
+    let out = new_binary_command(dir)?.args(["commit", "--message", message]).output()?;
+
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let combined = stdout + stderr;
+
+    if !out.status.success() {
+        return Err(GenericError(format!("Failed to commit: {}", combined)));
+    }
+
+    info!("Committed to {dir:?}");
+
+    Ok(())
+}

crates/yaak-git/src/credential.rs

@@ -0,0 +1,47 @@
+use crate::binary::new_binary_command;
+use crate::error::Error::GenericError;
+use crate::error::Result;
+use std::io::Write;
+use std::path::Path;
+use std::process::Stdio;
+use url::Url;
+
+pub async fn git_add_credential(
+    dir: &Path,
+    remote_url: &str,
+    username: &str,
+    password: &str,
+) -> Result<()> {
+    let url = Url::parse(remote_url)
+        .map_err(|e| GenericError(format!("Failed to parse remote url {remote_url}: {e:?}")))?;
+    let protocol = url.scheme();
+    let host = url.host_str().unwrap();
+    let path = Some(url.path());
+
+    let mut child = new_binary_command(dir)?
+        .args(["credential", "approve"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::null())
+        .spawn()?;
+
+    {
+        let stdin = child.stdin.as_mut().unwrap();
+        writeln!(stdin, "protocol={}", protocol)?;
+        writeln!(stdin, "host={}", host)?;
+        if let Some(path) = path {
+            if !path.is_empty() {
+                writeln!(stdin, "path={}", path.trim_start_matches('/'))?;
+            }
+        }
+        writeln!(stdin, "username={}", username)?;
+        writeln!(stdin, "password={}", password)?;
+        writeln!(stdin)?; // blank line terminator
+    }
+
+    let status = child.wait()?;
+    if !status.success() {
+        return Err(GenericError("Failed to approve git credential".to_string()));
+    }
+
+    Ok(())
+}

crates/yaak-git/src/error.rs

@@ -0,0 +1,64 @@
+use serde::{Serialize, Serializer};
+use std::io;
+use std::path::PathBuf;
+use std::string::FromUtf8Error;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Git repo not found {0}")]
+    GitRepoNotFound(PathBuf),
+
+    #[error("Git error: {0}")]
+    GitUnknown(#[from] git2::Error),
+
+    #[error("Yaml error: {0}")]
+    YamlParseError(#[from] serde_yaml::Error),
+
+    #[error(transparent)]
+    ModelError(#[from] yaak_models::error::Error),
+
+    #[error("Sync error: {0}")]
+    SyncError(#[from] yaak_sync::error::Error),
+
+    #[error("I/o error: {0}")]
+    IoError(#[from] io::Error),
+
+    #[error("JSON error: {0}")]
+    JsonParseError(#[from] serde_json::Error),
+
+    #[error("UTF8 error: {0}")]
+    Utf8ConversionError(#[from] FromUtf8Error),
+
+    #[error("Git error: {0}")]
+    GenericError(String),
+
+    #[error("'git' not found. Please ensure it's installed and available in $PATH")]
+    GitNotFound,
+
+    #[error("Credentials required: {0}")]
+    CredentialsRequiredError(String),
+
+    #[error("No default remote found")]
+    NoDefaultRemoteFound,
+
+    #[error("No remotes found for repo")]
+    NoRemotesFound,
+
+    #[error("Merge failed due to conflicts")]
+    MergeConflicts,
+
+    #[error("No active branch")]
+    NoActiveBranch,
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

crates/yaak-git/src/fetch.rs

@@ -0,0 +1,20 @@
+use crate::binary::new_binary_command;
+use crate::error::Error::GenericError;
+use crate::error::Result;
+use std::path::Path;
+
+pub fn git_fetch_all(dir: &Path) -> Result<()> {
+    let out = new_binary_command(dir)?
+        .args(["fetch", "--all", "--prune", "--tags"])
+        .output()
+        .map_err(|e| GenericError(format!("failed to run git pull: {e}")))?;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let combined = stdout + stderr;
+
+    if !out.status.success() {
+        return Err(GenericError(format!("Failed to fetch: {}", combined)));
+    }
+
+    Ok(())
+}

crates/yaak-git/src/init.rs

@@ -0,0 +1,14 @@
+use crate::error::Result;
+use crate::repository::open_repo;
+use log::info;
+use std::path::Path;
+
+pub fn git_init(dir: &Path) -> Result<()> {
+    git2::Repository::init(dir)?;
+    let repo = open_repo(dir)?;
+    // Default to main instead of master, to align with
+    // the official Git and GitHub behavior
+    repo.set_head("refs/heads/main")?;
+    info!("Initialized {dir:?}");
+    Ok(())
+}

crates/yaak-git/src/lib.rs

@@ -0,0 +1,31 @@
+mod add;
+mod binary;
+mod branch;
+mod commit;
+mod credential;
+pub mod error;
+mod fetch;
+mod init;
+mod log;
+mod merge;
+mod pull;
+mod push;
+mod remotes;
+mod repository;
+mod status;
+mod unstage;
+mod util;
+
+// Re-export all git functions for external use
+pub use add::git_add;
+pub use branch::{git_checkout_branch, git_create_branch, git_delete_branch, git_merge_branch};
+pub use commit::git_commit;
+pub use credential::git_add_credential;
+pub use fetch::git_fetch_all;
+pub use init::git_init;
+pub use log::{GitCommit, git_log};
+pub use pull::{PullResult, git_pull};
+pub use push::{PushResult, git_push};
+pub use remotes::{GitRemote, git_add_remote, git_remotes, git_rm_remote};
+pub use status::{GitStatusSummary, git_status};
+pub use unstage::git_unstage;

crates/yaak-git/src/log.rs

@@ -0,0 +1,73 @@
+use crate::repository::open_repo;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use ts_rs::TS;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_git.ts")]
+pub struct GitCommit {
+    pub author: GitAuthor,
+    pub when: DateTime<Utc>,
+    pub message: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_git.ts")]
+pub struct GitAuthor {
+    pub name: Option<String>,
+    pub email: Option<String>,
+}
+
+pub fn git_log(dir: &Path) -> crate::error::Result<Vec<GitCommit>> {
+    let repo = open_repo(dir)?;
+
+    // Return empty if empty repo or no head (new repo)
+    if repo.is_empty()? || repo.head().is_err() {
+        return Ok(vec![]);
+    }
+
+    let mut revwalk = repo.revwalk()?;
+    revwalk.push_head()?;
+    revwalk.set_sorting(git2::Sort::TIME)?;
+
+    // Run git log
+    macro_rules! filter_try {
+        ($e:expr) => {
+            match $e {
+                Ok(t) => t,
+                Err(_) => return None,
+            }
+        };
+    }
+    let log: Vec<GitCommit> = revwalk
+        .filter_map(|oid| {
+            let oid = filter_try!(oid);
+            let commit = filter_try!(repo.find_commit(oid));
+            let author = commit.author();
+            Some(GitCommit {
+                author: GitAuthor {
+                    name: author.name().map(|s| s.to_string()),
+                    email: author.email().map(|s| s.to_string()),
+                },
+                when: convert_git_time_to_date(author.when()),
+                message: commit.message().map(|m| m.to_string()),
+            })
+        })
+        .collect();
+
+    Ok(log)
+}
+
+#[cfg(test)]
+fn convert_git_time_to_date(_git_time: git2::Time) -> DateTime<Utc> {
+    DateTime::from_timestamp(0, 0).unwrap()
+}
+
+#[cfg(not(test))]
+fn convert_git_time_to_date(git_time: git2::Time) -> DateTime<Utc> {
+    let timestamp = git_time.seconds();
+    DateTime::from_timestamp(timestamp, 0).unwrap()
+}

crates/yaak-git/src/merge.rs

@@ -0,0 +1,135 @@
+use crate::error::Error::MergeConflicts;
+use crate::util::bytes_to_string;
+use git2::{AnnotatedCommit, Branch, IndexEntry, Reference, Repository};
+use log::{debug, info};
+
+pub(crate) fn do_merge(
+    repo: &Repository,
+    local_branch: &Branch,
+    commit_to_merge: &AnnotatedCommit,
+) -> crate::error::Result<()> {
+    debug!("Merging remote branches");
+    let analysis = repo.merge_analysis(&[&commit_to_merge])?;
+
+    if analysis.0.is_fast_forward() {
+        let refname = bytes_to_string(local_branch.get().name_bytes())?;
+        match repo.find_reference(&refname) {
+            Ok(mut r) => {
+                merge_fast_forward(repo, &mut r, &commit_to_merge)?;
+            }
+            Err(_) => {
+                // The branch doesn't exist, so set the reference to the commit directly. Usually
+                // this is because you are pulling into an empty repository.
+                repo.reference(
+                    &refname,
+                    commit_to_merge.id(),
+                    true,
+                    &format!("Setting {} to {}", refname, commit_to_merge.id()),
+                )?;
+                repo.set_head(&refname)?;
+                repo.checkout_head(Some(
+                    git2::build::CheckoutBuilder::default()
+                        .allow_conflicts(true)
+                        .conflict_style_merge(true)
+                        .force(),
+                ))?;
+            }
+        };
+    } else if analysis.0.is_normal() {
+        let head_commit = repo.reference_to_annotated_commit(&repo.head()?)?;
+        merge_normal(repo, &head_commit, commit_to_merge)?;
+    } else {
+        debug!("Skipping merge. Nothing to do")
+    }
+
+    Ok(())
+}
+
+pub(crate) fn merge_fast_forward(
+    repo: &Repository,
+    local_reference: &mut Reference,
+    remote_commit: &AnnotatedCommit,
+) -> crate::error::Result<()> {
+    info!("Performing fast forward");
+    let name = match local_reference.name() {
+        Some(s) => s.to_string(),
+        None => String::from_utf8_lossy(local_reference.name_bytes()).to_string(),
+    };
+    let msg = format!("Fast-Forward: Setting {} to id: {}", name, remote_commit.id());
+    local_reference.set_target(remote_commit.id(), &msg)?;
+    repo.set_head(&name)?;
+    repo.checkout_head(Some(
+        git2::build::CheckoutBuilder::default()
+            // For some reason, the force is required to make the working directory actually get
+            // updated I suspect we should be adding some logic to handle dirty working directory
+            // states, but this is just an example so maybe not.
+            .force(),
+    ))?;
+    Ok(())
+}
+
+pub(crate) fn merge_normal(
+    repo: &Repository,
+    local: &AnnotatedCommit,
+    remote: &AnnotatedCommit,
+) -> crate::error::Result<()> {
+    info!("Performing normal merge");
+    let local_tree = repo.find_commit(local.id())?.tree()?;
+    let remote_tree = repo.find_commit(remote.id())?.tree()?;
+    let ancestor = repo.find_commit(repo.merge_base(local.id(), remote.id())?)?.tree()?;
+
+    let mut idx = repo.merge_trees(&ancestor, &local_tree, &remote_tree, None)?;
+
+    if idx.has_conflicts() {
+        let conflicts = idx.conflicts()?;
+        for conflict in conflicts {
+            if let Ok(conflict) = conflict {
+                print_conflict(&conflict);
+            }
+        }
+        return Err(MergeConflicts);
+    }
+
+    let result_tree = repo.find_tree(idx.write_tree_to(repo)?)?;
+    // now create the merge commit
+    let msg = format!("Merge: {} into {}", remote.id(), local.id());
+    let sig = repo.signature()?;
+    let local_commit = repo.find_commit(local.id())?;
+    let remote_commit = repo.find_commit(remote.id())?;
+
+    // Do our merge commit and set current branch head to that commit.
+    let _merge_commit = repo.commit(
+        Some("HEAD"),
+        &sig,
+        &sig,
+        &msg,
+        &result_tree,
+        &[&local_commit, &remote_commit],
+    )?;
+
+    // Set working tree to match head.
+    repo.checkout_head(None)?;
+
+    Ok(())
+}
+
+fn print_conflict(conflict: &git2::IndexConflict) {
+    let ancestor = conflict.ancestor.as_ref().map(path_from_index_entry);
+    let ours = conflict.our.as_ref().map(path_from_index_entry);
+    let theirs = conflict.their.as_ref().map(path_from_index_entry);
+
+    println!("Conflict detected:");
+    if let Some(path) = ancestor {
+        println!("  Common ancestor: {:?}", path);
+    }
+    if let Some(path) = ours {
+        println!("  Ours: {:?}", path);
+    }
+    if let Some(path) = theirs {
+        println!("  Theirs: {:?}", path);
+    }
+}
+
+fn path_from_index_entry(entry: &IndexEntry) -> String {
+    String::from_utf8_lossy(entry.path.as_slice()).into_owned()
+}

crates/yaak-git/src/pull.rs

@@ -0,0 +1,95 @@
+use crate::binary::new_binary_command;
+use crate::error::Error::GenericError;
+use crate::error::Result;
+use crate::repository::open_repo;
+use crate::util::{get_current_branch_name, get_default_remote_in_repo};
+use log::info;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use ts_rs::TS;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "gen_git.ts")]
+pub enum PullResult {
+    Success { message: String },
+    UpToDate,
+    NeedsCredentials { url: String, error: Option<String> },
+}
+
+pub fn git_pull(dir: &Path) -> Result<PullResult> {
+    let repo = open_repo(dir)?;
+    let branch_name = get_current_branch_name(&repo)?;
+    let remote = get_default_remote_in_repo(&repo)?;
+    let remote_name = remote.name().ok_or(GenericError("Failed to get remote name".to_string()))?;
+    let remote_url = remote.url().ok_or(GenericError("Failed to get remote url".to_string()))?;
+
+    let out = new_binary_command(dir)?
+        .args(["pull", &remote_name, &branch_name])
+        .env("GIT_TERMINAL_PROMPT", "0")
+        .output()
+        .map_err(|e| GenericError(format!("failed to run git pull: {e}")))?;
+
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let combined = stdout + stderr;
+
+    info!("Pulled status={} {combined}", out.status);
+
+    if combined.to_lowercase().contains("could not read") {
+        return Ok(PullResult::NeedsCredentials { url: remote_url.to_string(), error: None });
+    }
+
+    if combined.to_lowercase().contains("unable to access") {
+        return Ok(PullResult::NeedsCredentials {
+            url: remote_url.to_string(),
+            error: Some(combined.to_string()),
+        });
+    }
+
+    if !out.status.success() {
+        return Err(GenericError(format!("Failed to pull {combined}")));
+    }
+
+    if combined.to_lowercase().contains("up to date") {
+        return Ok(PullResult::UpToDate);
+    }
+
+    Ok(PullResult::Success { message: format!("Pulled from {}/{}", remote_name, branch_name) })
+}
+
+// pub(crate) fn git_pull_old(dir: &Path) -> Result<PullResult> {
+//     let repo = open_repo(dir)?;
+//
+//     let branch = get_current_branch(&repo)?.ok_or(NoActiveBranch)?;
+//     let branch_ref = branch.get();
+//     let branch_ref = bytes_to_string(branch_ref.name_bytes())?;
+//
+//     let remote_name = repo.branch_upstream_remote(&branch_ref)?;
+//     let remote_name = bytes_to_string(&remote_name)?;
+//     debug!("Pulling from {remote_name}");
+//
+//     let mut remote = repo.find_remote(&remote_name)?;
+//
+//     let mut options = FetchOptions::new();
+//     let callbacks = default_callbacks();
+//     options.remote_callbacks(callbacks);
+//
+//     let mut proxy = ProxyOptions::new();
+//     proxy.auto();
+//     options.proxy_options(proxy);
+//
+//     remote.fetch(&[&branch_ref], Some(&mut options), None)?;
+//
+//     let stats = remote.stats();
+//
+//     let fetch_head = repo.find_reference("FETCH_HEAD")?;
+//     let fetch_commit = repo.reference_to_annotated_commit(&fetch_head)?;
+//     do_merge(&repo, &branch, &fetch_commit)?;
+//
+//     Ok(PullResult::Success {
+//         message: "Hello".to_string(),
+//         // received_bytes: stats.received_bytes(),
+//         // received_objects: stats.received_objects(),
+//     })
+// }

crates/yaak-git/src/push.rs

@@ -0,0 +1,81 @@
+use crate::binary::new_binary_command;
+use crate::error::Error::GenericError;
+use crate::error::Result;
+use crate::repository::open_repo;
+use crate::util::{get_current_branch_name, get_default_remote_for_push_in_repo};
+use log::info;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use ts_rs::TS;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "gen_git.ts")]
+pub enum PushResult {
+    Success { message: String },
+    UpToDate,
+    NeedsCredentials { url: String, error: Option<String> },
+}
+
+pub fn git_push(dir: &Path) -> Result<PushResult> {
+    let repo = open_repo(dir)?;
+    let branch_name = get_current_branch_name(&repo)?;
+    let remote = get_default_remote_for_push_in_repo(&repo)?;
+    let remote_name = remote.name().ok_or(GenericError("Failed to get remote name".to_string()))?;
+    let remote_url = remote.url().ok_or(GenericError("Failed to get remote url".to_string()))?;
+
+    let out = new_binary_command(dir)?
+        .args(["push", &remote_name, &branch_name])
+        .env("GIT_TERMINAL_PROMPT", "0")
+        .output()
+        .map_err(|e| GenericError(format!("failed to run git push: {e}")))?;
+
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let combined = stdout + stderr;
+    let combined_lower = combined.to_lowercase();
+
+    info!("Pushed to repo status={} {combined}", out.status);
+
+    // Helper to check if this is a credentials error
+    let is_credentials_error = || {
+        combined_lower.contains("could not read")
+            || combined_lower.contains("unable to access")
+            || combined_lower.contains("authentication failed")
+    };
+
+    // Check for explicit rejection indicators first (e.g., protected branch rejections)
+    // These can occur even if some git servers don't properly set exit codes
+    if combined_lower.contains("rejected") || combined_lower.contains("failed to push") {
+        if is_credentials_error() {
+            return Ok(PushResult::NeedsCredentials {
+                url: remote_url.to_string(),
+                error: Some(combined.to_string()),
+            });
+        }
+        return Err(GenericError(format!("Failed to push: {combined}")));
+    }
+
+    // Check exit status for any other failures
+    if !out.status.success() {
+        if combined_lower.contains("could not read") {
+            return Ok(PushResult::NeedsCredentials { url: remote_url.to_string(), error: None });
+        }
+        if combined_lower.contains("unable to access")
+            || combined_lower.contains("authentication failed")
+        {
+            return Ok(PushResult::NeedsCredentials {
+                url: remote_url.to_string(),
+                error: Some(combined.to_string()),
+            });
+        }
+        return Err(GenericError(format!("Failed to push: {combined}")));
+    }
+
+    // Success cases (exit code 0 and no rejection indicators)
+    if combined_lower.contains("up-to-date") {
+        return Ok(PushResult::UpToDate);
+    }
+
+    Ok(PushResult::Success { message: format!("Pushed to {}/{}", remote_name, branch_name) })
+}

crates/yaak-git/src/remotes.rs

@@ -0,0 +1,47 @@
+use crate::error::Result;
+use crate::repository::open_repo;
+use log::warn;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use ts_rs::TS;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[ts(export, export_to = "gen_git.ts")]
+pub struct GitRemote {
+    name: String,
+    url: Option<String>,
+}
+
+pub fn git_remotes(dir: &Path) -> Result<Vec<GitRemote>> {
+    let repo = open_repo(dir)?;
+    let mut remotes = Vec::new();
+
+    for remote in repo.remotes()?.into_iter() {
+        let name = match remote {
+            None => continue,
+            Some(name) => name,
+        };
+        let r = match repo.find_remote(name) {
+            Ok(r) => r,
+            Err(e) => {
+                warn!("Failed to get remote {name}: {e:?}");
+                continue;
+            }
+        };
+        remotes.push(GitRemote { name: name.to_string(), url: r.url().map(|u| u.to_string()) });
+    }
+
+    Ok(remotes)
+}
+
+pub fn git_add_remote(dir: &Path, name: &str, url: &str) -> Result<GitRemote> {
+    let repo = open_repo(dir)?;
+    repo.remote(name, url)?;
+    Ok(GitRemote { name: name.to_string(), url: Some(url.to_string()) })
+}
+
+pub fn git_rm_remote(dir: &Path, name: &str) -> Result<()> {
+    let repo = open_repo(dir)?;
+    repo.remote_delete(name)?;
+    Ok(())
+}

crates/yaak-git/src/repository.rs

@@ -0,0 +1,10 @@
+use crate::error::Error::{GitRepoNotFound, GitUnknown};
+use std::path::Path;
+
+pub(crate) fn open_repo(dir: &Path) -> crate::error::Result<git2::Repository> {
+    match git2::Repository::discover(dir) {
+        Ok(r) => Ok(r),
+        Err(e) if e.code() == git2::ErrorCode::NotFound => Err(GitRepoNotFound(dir.to_path_buf())),
+        Err(e) => Err(GitUnknown(e)),
+    }
+}

crates/yaak-git/src/status.rs

@@ -0,0 +1,172 @@
+use crate::repository::open_repo;
+use crate::util::{local_branch_names, remote_branch_names};
+use log::warn;
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+use ts_rs::TS;
+use yaak_sync::models::SyncModel;
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS, PartialEq)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_git.ts")]
+pub struct GitStatusSummary {
+    pub path: String,
+    pub head_ref: Option<String>,
+    pub head_ref_shorthand: Option<String>,
+    pub entries: Vec<GitStatusEntry>,
+    pub origins: Vec<String>,
+    pub local_branches: Vec<String>,
+    pub remote_branches: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_git.ts")]
+pub struct GitStatusEntry {
+    pub rela_path: String,
+    pub status: GitStatus,
+    pub staged: bool,
+    pub prev: Option<SyncModel>,
+    pub next: Option<SyncModel>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "gen_git.ts")]
+pub enum GitStatus {
+    Untracked,
+    Conflict,
+    Current,
+    Modified,
+    Removed,
+    Renamed,
+    TypeChange,
+}
+
+pub fn git_status(dir: &Path) -> crate::error::Result<GitStatusSummary> {
+    let repo = open_repo(dir)?;
+    let (head_tree, head_ref, head_ref_shorthand) = match repo.head() {
+        Ok(head) => {
+            let tree = head.peel_to_tree().ok();
+            let head_ref_shorthand = head.shorthand().map(|s| s.to_string());
+            let head_ref = head.name().map(|s| s.to_string());
+
+            (tree, head_ref, head_ref_shorthand)
+        }
+        Err(_) => {
+            // For "unborn" repos, reading from HEAD is the only way to get the branch name
+            // See https://github.com/starship/starship/pull/1336
+            let head_path = repo.path().join("HEAD");
+            let head_ref = fs::read_to_string(&head_path)
+                .ok()
+                .unwrap_or_default()
+                .lines()
+                .next()
+                .map(|s| s.trim_start_matches("ref:").trim().to_string());
+            let head_ref_shorthand =
+                head_ref.clone().map(|r| r.split('/').last().unwrap_or("unknown").to_string());
+            (None, head_ref, head_ref_shorthand)
+        }
+    };
+
+    let mut opts = git2::StatusOptions::new();
+    opts.include_ignored(false)
+        .include_untracked(true) // Include untracked
+        .recurse_untracked_dirs(true) // Show all untracked
+        .include_unmodified(true); // Include unchanged
+
+    // TODO: Support renames
+
+    let mut entries: Vec<GitStatusEntry> = Vec::new();
+    for entry in repo.statuses(Some(&mut opts))?.into_iter() {
+        let rela_path = entry.path().unwrap().to_string();
+        let status = entry.status();
+        let index_status = match status {
+            // Note: order matters here, since we're checking a bitmap!
+            s if s.contains(git2::Status::CONFLICTED) => GitStatus::Conflict,
+            s if s.contains(git2::Status::INDEX_NEW) => GitStatus::Untracked,
+            s if s.contains(git2::Status::INDEX_MODIFIED) => GitStatus::Modified,
+            s if s.contains(git2::Status::INDEX_DELETED) => GitStatus::Removed,
+            s if s.contains(git2::Status::INDEX_RENAMED) => GitStatus::Renamed,
+            s if s.contains(git2::Status::INDEX_TYPECHANGE) => GitStatus::TypeChange,
+            s if s.contains(git2::Status::CURRENT) => GitStatus::Current,
+            s => {
+                warn!("Unknown index status {s:?}");
+                continue;
+            }
+        };
+
+        let worktree_status = match status {
+            // Note: order matters here, since we're checking a bitmap!
+            s if s.contains(git2::Status::CONFLICTED) => GitStatus::Conflict,
+            s if s.contains(git2::Status::WT_NEW) => GitStatus::Untracked,
+            s if s.contains(git2::Status::WT_MODIFIED) => GitStatus::Modified,
+            s if s.contains(git2::Status::WT_DELETED) => GitStatus::Removed,
+            s if s.contains(git2::Status::WT_RENAMED) => GitStatus::Renamed,
+            s if s.contains(git2::Status::WT_TYPECHANGE) => GitStatus::TypeChange,
+            s if s.contains(git2::Status::CURRENT) => GitStatus::Current,
+            s => {
+                warn!("Unknown worktree status {s:?}");
+                continue;
+            }
+        };
+
+        let status = if index_status == GitStatus::Current {
+            worktree_status.clone()
+        } else {
+            index_status.clone()
+        };
+
+        let staged = if index_status == GitStatus::Current && worktree_status == GitStatus::Current
+        {
+            // No change, so can't be added
+            false
+        } else if index_status != GitStatus::Current {
+            true
+        } else {
+            false
+        };
+
+        // Get previous content from Git, if it's in there
+        let prev = match head_tree.clone() {
+            None => None,
+            Some(t) => match t.get_path(&Path::new(&rela_path)) {
+                Ok(entry) => {
+                    let obj = entry.to_object(&repo)?;
+                    let content = obj.as_blob().unwrap().content();
+                    let name = Path::new(entry.name().unwrap_or_default());
+                    SyncModel::from_bytes(content.into(), name)?.map(|m| m.0)
+                }
+                Err(_) => None,
+            },
+        };
+
+        let next = {
+            let full_path = repo.workdir().unwrap().join(rela_path.clone());
+            SyncModel::from_file(full_path.as_path())?.map(|m| m.0)
+        };
+
+        entries.push(GitStatusEntry {
+            status,
+            staged,
+            rela_path,
+            prev: prev.clone(),
+            next: next.clone(),
+        })
+    }
+
+    let origins = repo.remotes()?.into_iter().filter_map(|o| Some(o?.to_string())).collect();
+    let local_branches = local_branch_names(&repo)?;
+    let remote_branches = remote_branch_names(&repo)?;
+
+    Ok(GitStatusSummary {
+        entries,
+        origins,
+        path: dir.to_string_lossy().to_string(),
+        head_ref,
+        head_ref_shorthand,
+        local_branches,
+        remote_branches,
+    })
+}

crates/yaak-git/src/unstage.rs

@@ -0,0 +1,27 @@
+use crate::repository::open_repo;
+use log::info;
+use std::path::Path;
+
+pub fn git_unstage(dir: &Path, rela_path: &Path) -> crate::error::Result<()> {
+    let repo = open_repo(dir)?;
+
+    let head = match repo.head() {
+        Ok(h) => h,
+        Err(e) if e.code() == git2::ErrorCode::UnbornBranch => {
+            info!("Unstaging file in empty branch {rela_path:?} to {dir:?}");
+            // Repo has no commits, so "unstage" means remove from index
+            let mut index = repo.index()?;
+            index.remove_path(rela_path)?;
+            index.write()?;
+            return Ok(());
+        }
+        Err(e) => return Err(e.into()),
+    };
+
+    // If repo has commits, update the index entry back to HEAD
+    info!("Unstaging file {rela_path:?} to {dir:?}");
+    let commit = head.peel_to_commit()?;
+    repo.reset_default(Some(commit.as_object()), &[rela_path])?;
+
+    Ok(())
+}

crates/yaak-git/src/util.rs

@@ -0,0 +1,125 @@
+use crate::error::Error::{GenericError, NoDefaultRemoteFound};
+use crate::error::Result;
+use git2::{Branch, BranchType, Remote, Repository};
+
+const DEFAULT_REMOTE_NAME: &str = "origin";
+
+pub(crate) fn get_current_branch(repo: &Repository) -> Result<Option<Branch<'_>>> {
+    for b in repo.branches(None)? {
+        let branch = b?.0;
+        if branch.is_head() {
+            return Ok(Some(branch));
+        }
+    }
+    Ok(None)
+}
+
+pub(crate) fn get_current_branch_name(repo: &Repository) -> Result<String> {
+    Ok(get_current_branch(&repo)?
+        .ok_or(GenericError("Failed to get current branch".to_string()))?
+        .name()?
+        .ok_or(GenericError("Failed to get current branch name".to_string()))?
+        .to_string())
+}
+
+pub(crate) fn local_branch_names(repo: &Repository) -> Result<Vec<String>> {
+    let mut branches = Vec::new();
+    for branch in repo.branches(Some(BranchType::Local))? {
+        let (branch, _) = branch?;
+        let name = branch.name_bytes()?;
+        let name = bytes_to_string(name)?;
+        branches.push(name);
+    }
+    Ok(branches)
+}
+
+pub(crate) fn remote_branch_names(repo: &Repository) -> Result<Vec<String>> {
+    let mut branches = Vec::new();
+    for branch in repo.branches(Some(BranchType::Remote))? {
+        let (branch, _) = branch?;
+        let name = branch.name_bytes()?;
+        let name = bytes_to_string(name)?;
+        if name.ends_with("/HEAD") {
+            continue;
+        }
+        branches.push(name);
+    }
+    Ok(branches)
+}
+
+pub(crate) fn get_branch_by_name<'s>(repo: &'s Repository, name: &str) -> Result<Branch<'s>> {
+    Ok(repo.find_branch(name, BranchType::Local)?)
+}
+
+pub(crate) fn bytes_to_string(bytes: &[u8]) -> Result<String> {
+    Ok(String::from_utf8(bytes.to_vec())?)
+}
+
+pub(crate) fn get_default_remote_for_push_in_repo(repo: &'_ Repository) -> Result<Remote<'_>> {
+    let name = get_default_remote_name_for_push_in_repo(repo)?;
+    let remote = repo.find_remote(&name)?;
+    Ok(remote)
+}
+
+pub(crate) fn get_default_remote_name_for_push_in_repo(repo: &Repository) -> Result<String> {
+    let config = repo.config()?;
+
+    let branch = get_current_branch(repo)?;
+
+    if let Some(branch) = branch {
+        let remote_name = bytes_to_string(branch.name_bytes()?)?;
+
+        let entry_name = format!("branch.{}.pushRemote", &remote_name);
+
+        if let Ok(entry) = config.get_entry(&entry_name) {
+            return bytes_to_string(entry.value_bytes());
+        }
+
+        if let Ok(entry) = config.get_entry("remote.pushDefault") {
+            return bytes_to_string(entry.value_bytes());
+        }
+
+        let entry_name = format!("branch.{}.remote", &remote_name);
+
+        if let Ok(entry) = config.get_entry(&entry_name) {
+            return bytes_to_string(entry.value_bytes());
+        }
+    }
+
+    get_default_remote_name_in_repo(repo)
+}
+
+pub(crate) fn get_default_remote_in_repo(repo: &'_ Repository) -> Result<Remote<'_>> {
+    let name = get_default_remote_name_in_repo(repo)?;
+    let remote = repo.find_remote(&name)?;
+    Ok(remote)
+}
+
+pub(crate) fn get_default_remote_name_in_repo(repo: &Repository) -> Result<String> {
+    let remotes = repo.remotes()?;
+
+    if remotes.is_empty() {
+        return Err(NoDefaultRemoteFound);
+    }
+
+    // if `origin` exists return that
+    let found_origin = remotes.iter().any(|r| r.is_some_and(|r| r == DEFAULT_REMOTE_NAME));
+    if found_origin {
+        return Ok(DEFAULT_REMOTE_NAME.into());
+    }
+
+    // if only one remote exists, pick that
+    if remotes.len() == 1 {
+        let first_remote = remotes
+            .iter()
+            .next()
+            .flatten()
+            .map(String::from)
+            .ok_or_else(|| GenericError("no remote found".into()))?;
+
+        return Ok(first_remote);
+    }
+
+    // inconclusive
+    Err(NoDefaultRemoteFound)
+}