> created boilerplate

tried to create a commit trough the 'gitlib2' crate,
however this is kinda hard, because one has to customly
create a tree to commit.

might switch to a simple git add / git commit wrapper for simplicity

@@ -0,0 +8,20 @@
+/// This is the same as running:
+/// - git add .
+/// - git commit -m "sac synchronization"
+/// - git push
+/// If the remote is ahead, the push is retried with the following commands:
+/// - git pull --rebase
+/// - git push
+#[clap(verbatim_doc_comment)]
+pub struct Cmd {
+    #[arg(
+        short,
+        long,
+        value_name = "message",
+        default_value = "sac synchronization"
+    )]
+    /// custom message for the changes
+    message: String,
+
+    #[arg(short, long, default_value = "false")]
+    /// commit changes only to the local rempo

@@ -0,0 +23,20 @@
+    /// custom message for the changes
+    message: String,
+
+    #[arg(short, long, default_value = "false")]
+    /// commit changes only to the local rempo
+    local: bool,
+
+    #[arg(short, long, default_value = "false")]
+    /// do not create a new commit and only sync the remote repo with the local
+    no_save: bool,
+
+    #[arg(long, default_value = "false")]
+    /// this will ignore checks for unresolved merge conflicts
+    allow_unresolved: bool,
+}
+impl Cmd {
+    pub fn execute(&self) -> anyhow::Result<()> {
+        let repo = Repository::discover(".").context("not inside a git repository")?;
+
+        if !self.no_save {

@@ -0,0 +29,20 @@
+
+    #[arg(short, long, default_value = "false")]
+    /// do not create a new commit and only sync the remote repo with the local
+    no_save: bool,
+
+    #[arg(long, default_value = "false")]
+    /// this will ignore checks for unresolved merge conflicts
+    allow_unresolved: bool,
+}
+impl Cmd {
+    pub fn execute(&self) -> anyhow::Result<()> {
+        let repo = Repository::discover(".").context("not inside a git repository")?;
+
+        if !self.no_save {
+            commit::save_changes(&repo, &self.message, self.allow_unresolved)?;
+        }
+        if !self.local {
+            remote::synchronize()?;
+        }
+

@@ -0,0 +55,20 @@
+    use crate::command::sync::util::git_root;
+    use anyhow::Context;
+    use git2::Repository;
+    use std::process::Command;
+
+    pub fn save_changes(
+        repo: &Repository,
+        commit_message: &str,
+        allow_unresolved: bool,
+    ) -> anyhow::Result<()> {
+        let status = git_status::StatusReport::new(&repo)?;
+
+        // error out when there are merge conflicts
+        if !allow_unresolved {
+            status.assume_no_conflicts()?;
+        }
+
+        let cwd = git_root()?;
+        let add = Command::new("git")
+            .args(["add", "."])

@@ -0,0 +83,20 @@
+        // This expectes, that the user does not run `sac sync` during a 'custom' rebase
+        // but only after a `sac sync` that resulted in merge conflicts.
+        let is_merge = util::is_rebase()?;
+        if is_merge {
+            // Warning: this is a dirty hack
+            //
+            // git rebase --continue will spawn an editor to provide the commit message
+            // the `-c` flag overwrites this editor configuration for this single command
+            // to be "echo 'COMMIT_MESSAGE' > "
+            // git will invoke this command and append the file name of the commit file.
+            // that way to COMMIT_MESSAGE will be written to said file.
+            //
+            // For this hack to work 'echo' and the pipe operator '>' must be valid syntax
+            // on the users maschine, however as they are wide-spread operators this should
+            // on most maschines™
+            let merge = Command::new("git")
+                .args([
+                    "-c",
+                    &format!("core.editor=echo '{commit_message}' > "),
+                    "rebase",

@@ -0,0 +175,20 @@
+
+        pub struct StatusReport {
+            created: Vec<String>,
+            modified: Vec<String>,
+            deleted: Vec<String>,
+            merged: Vec<String>,
+            typechange: Vec<String>,
+        }
+        impl StatusReport {
+            pub fn new(repo: &Repository) -> anyhow::Result<StatusReport> {
+                let mut status = StatusOptions::new();
+                status.show(StatusShow::IndexAndWorkdir);
+                status.include_untracked(true);
+                status.include_unmodified(true);
+
+                let unstaged = repo
+                    .statuses(Some(&mut status))
+                    .context("failed to list changed files")?;
+
+                let mut report = StatusReport {

@@ -0,0 +216,20 @@
+                }
+
+                return Ok(report);
+            }
+
+            /// Check whether all merge conflicts have been resolved
+            /// Will error out if there are still merge conflicts
+            pub fn assume_no_conflicts(&self) -> anyhow::Result<()> {
+                let is_rebase = util::is_rebase()?;
+                if !is_rebase {
+                    return Ok(());
+                }
+
+                let mut msg = "Unresolved merge conflicts found in:\n".to_string();
+                let mut had_conflicts = false;
+                let root = util::git_root()?;
+                'files: for file in self
+                    .created
+                    .iter()
+                    .chain(self.modified.iter())

@@ -0,0 +282,20 @@
+                    StatusType::Typechange => &self.typechange,
+                };
+                if files.len() == 0 {
+                    return out;
+                }
+                let mut out = out + &status.header();
+                for path in files.iter() {
+                    out += &status.file(path);
+                }
+                return out;
+            }
+
+            pub fn log(&self) {
+                let out = "".to_string();
+                let out = self.list_files(out, StatusType::Created);
+                let out = self.list_files(out, StatusType::Modified);
+                let out = self.list_files(out, StatusType::Merged);
+                let out = self.list_files(out, StatusType::Deleted);
+                let out = self.list_files(out, StatusType::Typechange);
+                print!("{out}");

@@ -0,0 +310,20 @@
+    use spinners::{Spinner, Spinners};
+    use std::process::Command;
+
+    pub fn synchronize() -> anyhow::Result<()> {
+        let mut sp = Spinner::new(Spinners::Line, "sync changes with remote".into());
+        match push_changes() {
+            Err(err) => {
+                if let Err(err) = match_push_error(&err.to_string(), true) {
+                    sp.stop_and_persist("☓", "failed to sync with remote".into());
+                    anyhow::bail!(err);
+                }
+                sp.stop_and_persist(">", "remote is ahead".into());
+            }
+            Ok(_) => {
+                sp.stop_and_persist("🗸", "synced changes with remote".into());
+                return Ok(());
+            }
+        };
+
+        // failed to push -> pull and push again

@@ -0,0 +348,20 @@
+
+        return Ok(());
+    }
+
+    fn push_changes() -> anyhow::Result<()> {
+        let push = Command::new("git")
+            .args(["push"])
+            .output()
+            .context("failed to execute git")?;
+        if !push.status.success() {
+            anyhow::bail!(
+                String::from_utf8(push.stderr).unwrap_or("failed to run 'git push'".into()),
+            )
+        }
+        return Ok(());
+    }
+
+    fn pull_changes() -> anyhow::Result<()> {
+        let pull = Command::new("git")
+            .args(["pull", "--rebase"])