git-custom-cli 1.0.0

Fast, keyboard-driven terminal UI for dated Git commits
mod config;
mod git;
mod input;
mod model;
#[path = "terminal.rs"]
mod screen;

use anyhow::{anyhow, Context, Result};
use clap::Parser;
use model::{initial_values, valid_date, valid_time, Config, Values};

#[derive(Parser, Debug)]
#[command(name = "gct", version, about = "Fast Git commit TUI")]
struct Args {
    #[arg(long)]
    clear_config: bool,
}

fn run() -> Result<()> {
    let args = Args::parse();
    if args.clear_config {
        config::clear()?;
        println!("Saved configuration cleared.");
        return Ok(());
    }

    let branch = git::current_branch().map_err(|_| anyhow!("Not a git repository"))?;
    let status = git::status_lines().map_err(|_| anyhow!("Not a git repository"))?;
    let saved = config::load()?;
    let mut values = initial_values(saved, &branch);
    let _terminal = screen::Guard::enter()?;

    loop {
        let mut status_view = vec![format!(
            "{} {}",
            screen::muted("Branch"),
            screen::accent(&branch)
        )];
        if status == ["(clean working tree)"] {
            status_view.push(format!(
                "{} {}",
                screen::muted("Working tree"),
                screen::success("clean")
            ));
        } else {
            status_view.push(screen::warning("Working tree changes"));
            status_view.extend(status.iter().map(|line| format!("  {line}")));
        }
        screen::draw(&status_view, None)?;

        match input::menu(&values)?.as_str() {
            "date" => values.date = input::masked("Commit date (YYYY-MM-DD):", &values.date, true)?,
            "time" => values.time = input::masked("Commit time (HH:MM:SS):", &values.time, false)?,
            "branch" => values.branch = input::read_line("Branch to push:", &values.branch, false)?,
            "message" => {
                values.message = input::read_line("Commit message:", &values.message, true)?
            }
            "editor" => values.message = input::external_editor(&values.message)?,
            "options" => input::options(&mut values)?,
            "finalize" => {
                if finalize(&values)? {
                    return Ok(());
                }
            }
            _ => unreachable!(),
        }
    }
}

fn finalize(values: &Values) -> Result<bool> {
    if !valid_date(&values.date) {
        screen::error("Please set a valid date")?;
        return Ok(false);
    }
    if !valid_time(&values.time) {
        screen::error("Please set a valid time (HH:MM:SS)")?;
        return Ok(false);
    }
    if values.branch.trim().is_empty() {
        screen::error("Please choose a branch")?;
        return Ok(false);
    }
    if values.message.trim().is_empty() {
        screen::error("Please write a commit message")?;
        return Ok(false);
    }

    let date = format!("{} {}", values.date, values.time);
    screen::draw(
        &[
            screen::accent("Final summary"),
            format!("  Date:   {date}"),
            format!("  Branch: {}", values.branch),
            format!("  Msg:    {}", values.message),
            if values.amend {
                "  Mode:   amend last commit".into()
            } else {
                String::new()
            },
            if values.dry_run {
                "  Mode:   dry run".into()
            } else {
                String::new()
            },
        ],
        None,
    )?;
    if !input::confirm("Proceed with these actions?", true)? {
        return Ok(false);
    }

    if values.dry_run {
        screen::draw(
            &[
                "Dry run - commands that would be executed:".into(),
                "  git add .".into(),
                format!(
                    "  git {} -m {:?} (author/committer date: {date})",
                    if values.amend {
                        "commit --amend"
                    } else {
                        "commit"
                    },
                    values.message
                ),
                format!("  git push origin {}", values.branch),
            ],
            None,
        )?;
        return Ok(true);
    }

    git::run(&["add", "."]).context("Staging all files failed")?;
    git::commit(&values.message, &date, values.amend)?;
    config::save(&Config {
        last_date: date,
        last_branch: values.branch.clone(),
        last_message: values.message.clone(),
    })?;
    if input::confirm("Push to GitHub?", true)? {
        git::push(&values.branch, values.amend)?;
        screen::draw(
            &[screen::success(format!(
                "Done. commit -> push origin/{}",
                values.branch
            ))],
            None,
        )?;
    } else {
        screen::draw(
            &[screen::success("Done. commit -> local only (no push)")],
            None,
        )?;
    }
    Ok(true)
}

fn main() {
    if let Err(error) = run() {
        eprintln!("Error: {error:#}");
        std::process::exit(1);
    }
}