feat: add auto-update functionality and update command

Author: gtkacz

Cargo.lock

@@ -92,6 +92,7 @@ cgen --no-verify        # Forward flags to git commit
 cgen alter <hash>       # Regenerate message from that commit's diff and rewrite it
 cgen alter <old> <new>  # Use old..new net diff, rewrite <new> message
 cgen undo               # Undo latest commit with safety prompts (soft reset)
+cgen update             # Update cgen to the latest version
 cgen config             # Interactive config editor (local .env)
 cgen config --global    # Interactive config editor (global TOML)
 ```
@@ -121,6 +122,7 @@ All settings use the `ACR_` prefix. Layered resolution: defaults → global TOML
 | `ACR_WARN_STAGED_FILES_ENABLED` | `1` | Warn when staged file count exceeds threshold (`1`/`0`) |
 | `ACR_WARN_STAGED_FILES_THRESHOLD` | `20` | Staged files warning threshold (warn when count is greater) |
 | `ACR_CONFIRM_NEW_VERSION` | `1` | Ask before creating the computed `--tag` version (`1`/`0`) |
+| `ACR_AUTO_UPDATE` | — | Enable automatic updates (`1`/`0`); prompts on first run if unset |
 
 ### Config Locations
 
@@ -157,6 +159,17 @@ ACR_API_HEADERS=Authorization: Bearer $ACR_API_KEY, X-Custom: $MY_HEADER
 - For rewritten pushed history, cgen does not auto-force-push; use manual `git push --force-with-lease` if needed.
 - `cgen undo` only undoes the latest commit (`git reset --soft HEAD~1`), never pushes, and warns before undoing pushed commits.
 
+### Updating
+
+- `cgen update` checks for a newer version on GitHub and runs the appropriate installer:
+  - If `cargo` is available: `cargo install auto-commit-rs`
+  - Otherwise on Linux/macOS: re-runs the curl install script
+  - Otherwise on Windows: re-runs the PowerShell install script
+- On every run, cgen checks the latest GitHub release tag against the current version.
+- The first time cgen runs, it asks whether to enable automatic updates and saves the preference to the global config.
+- If `ACR_AUTO_UPDATE=1`, cgen automatically updates when a newer version is found.
+- If `ACR_AUTO_UPDATE=0` (or unset after the prompt), a warning is shown at the end of the output with the available version.
+
 ## Providers
 
 Built-in providers: **Groq** (default), **OpenAI**, **Anthropic**, **Gemini**.

README.md

@@ -49,6 +49,8 @@ pub enum Command {
         #[arg(value_name = "HASH", num_args = 1..=2)]
         commits: Vec<String>,
     },
+    /// Update cgen to the latest version
+    Update,
 }
 
 pub fn parse() -> Cli {
@@ -73,7 +75,7 @@ pub fn interactive_config(global: bool) -> Result<()> {
         all_options.push("Exit without saving".red().to_string());
 
         let selection = Select::new("Edit a setting:", all_options)
-            .with_page_size(17)
+            .with_page_size(18)
             .prompt();
 
         let selection = match selection {
@@ -181,6 +183,13 @@ pub fn interactive_config(global: bool) -> Result<()> {
                     .ok()
                     .map(|v| v.chars().next().unwrap().to_string())
             }
+            "AUTO_UPDATE" => {
+                let choices = vec!["1 (yes)", "0 (no)"];
+                Select::new("Enable automatic updates:", choices)
+                    .prompt()
+                    .ok()
+                    .map(|v| v.chars().next().unwrap().to_string())
+            }
             "API_KEY" => Text::new("API Key:")
                 .with_help_message("Your LLM provider API key")
                 .prompt()

src/cli.rs

@@ -43,6 +43,8 @@ pub struct AppConfig {
     pub warn_staged_files_threshold: usize,
     #[serde(default = "default_true")]
     pub confirm_new_version: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub auto_update: Option<bool>,
 }
 
 fn default_provider() -> String {
@@ -93,6 +95,7 @@ impl Default for AppConfig {
             warn_staged_files_enabled: true,
             warn_staged_files_threshold: default_warn_staged_files_threshold(),
             confirm_new_version: true,
+            auto_update: None,
         }
     }
 }
@@ -116,6 +119,7 @@ const ENV_FIELD_MAP: &[(&str, &str)] = &[
     ("WARN_STAGED_FILES_ENABLED", "warn_staged_files_enabled"),
     ("WARN_STAGED_FILES_THRESHOLD", "warn_staged_files_threshold"),
     ("CONFIRM_NEW_VERSION", "confirm_new_version"),
+    ("AUTO_UPDATE", "auto_update"),
 ];
 
 impl AppConfig {
@@ -195,6 +199,9 @@ impl AppConfig {
         self.warn_staged_files_enabled = other.warn_staged_files_enabled;
         self.warn_staged_files_threshold = other.warn_staged_files_threshold;
         self.confirm_new_version = other.confirm_new_version;
+        if other.auto_update.is_some() {
+            self.auto_update = other.auto_update;
+        }
     }
 
     fn apply_env_map(&mut self, map: &HashMap<String, String>) {
@@ -233,6 +240,10 @@ impl AppConfig {
                     "CONFIRM_NEW_VERSION" => {
                         self.confirm_new_version = val == "1" || val.eq_ignore_ascii_case("true")
                     }
+                    "AUTO_UPDATE" => {
+                        self.auto_update =
+                            Some(val == "1" || val.eq_ignore_ascii_case("true"));
+                    }
                     _ => {}
                 }
             }
@@ -313,6 +324,12 @@ impl AppConfig {
             "ACR_CONFIRM_NEW_VERSION={}",
             if self.confirm_new_version { "1" } else { "0" }
         ));
+        if let Some(auto_update) = self.auto_update {
+            lines.push(format!(
+                "ACR_AUTO_UPDATE={}",
+                if auto_update { "1" } else { "0" }
+            ));
+        }
 
         std::fs::write(&env_path, lines.join("\n") + "\n")
             .with_context(|| format!("Failed to write {}", env_path.display()))?;
@@ -431,6 +448,15 @@ impl AppConfig {
                     "0 (no)".into()
                 },
             ),
+            (
+                "Auto Update",
+                "AUTO_UPDATE",
+                match self.auto_update {
+                    Some(true) => "1 (yes)".into(),
+                    Some(false) => "0 (no)".into(),
+                    None => "(not set)".into(),
+                },
+            ),
         ]
     }
 
@@ -469,6 +495,9 @@ impl AppConfig {
             "CONFIRM_NEW_VERSION" => {
                 self.confirm_new_version = value == "1" || value.eq_ignore_ascii_case("true");
             }
+            "AUTO_UPDATE" => {
+                self.auto_update = Some(value == "1" || value.eq_ignore_ascii_case("true"));
+            }
             _ => {}
         }
         Ok(())
@@ -491,6 +520,31 @@ pub fn global_config_path() -> Option<PathBuf> {
     dirs::config_dir().map(|d| d.join("cgen").join("config.toml"))
 }
 
+/// Save only the auto_update preference to global config without overwriting other fields
+pub fn save_auto_update_preference(value: bool) -> Result<()> {
+    let path = global_config_path().context("Could not determine global config directory")?;
+
+    let mut table: toml::Table = if path.exists() {
+        let content = std::fs::read_to_string(&path)
+            .with_context(|| format!("Failed to read {}", path.display()))?;
+        content.parse().unwrap_or_default()
+    } else {
+        toml::Table::new()
+    };
+
+    table.insert("auto_update".to_string(), toml::Value::Boolean(value));
+
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .with_context(|| format!("Failed to create {}", parent.display()))?;
+    }
+
+    let content = toml::to_string_pretty(&table).context("Failed to serialize config")?;
+    std::fs::write(&path, content)
+        .with_context(|| format!("Failed to write {}", path.display()))?;
+    Ok(())
+}
+
 fn mask_key(key: &str) -> String {
     if key.len() <= 8 {
         "*".repeat(key.len())

src/config.rs

@@ -4,3 +4,4 @@ pub mod git;
 pub mod interpolation;
 pub mod prompt;
 pub mod provider;
+pub mod update;

src/lib.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use auto_commit_rs::{cli, config, git, prompt, provider};
+use auto_commit_rs::{cli, config, git, prompt, provider, update};
 use colored::Colorize;
 use inquire::{Confirm, Select, Text};
 
@@ -13,14 +13,30 @@ fn main() {
 fn run() -> Result<()> {
     let cli = cli::parse();
     let cfg = match &cli.command {
-        Some(cli::Command::Config { .. }) => None,
+        Some(cli::Command::Config { .. }) | Some(cli::Command::Update) => None,
         _ => Some(config::AppConfig::load()?),
     };
 
+    // On first run, ask about auto-update preference
+    if let Some(ref c) = cfg {
+        if c.auto_update.is_none() {
+            prompt_auto_update();
+        }
+    }
+
+    // Check for updates (except for config/update commands)
+    let update_warning = match &cli.command {
+        Some(cli::Command::Config { .. }) | Some(cli::Command::Update) => None,
+        _ => check_for_updates(cfg.as_ref()),
+    };
+
     match &cli.command {
         Some(cli::Command::Config { global }) => {
             cli::interactive_config(*global)?;
         }
+        Some(cli::Command::Update) => {
+            run_update_command()?;
+        }
         Some(cli::Command::Undo) => {
             run_undo(cfg.as_ref().expect("config should be loaded"))?;
         }
@@ -36,6 +52,11 @@ fn run() -> Result<()> {
         }
     }
 
+    // Show update warning at the end so it doesn't get buried
+    if let Some(latest) = update_warning {
+        update::print_update_warning(&latest);
+    }
+
     Ok(())
 }
 
@@ -301,6 +322,101 @@ fn handle_post_commit_push(cfg: &config::AppConfig, ask_prompt: &str) -> Result<
     Ok(())
 }
 
+fn prompt_auto_update() {
+    let answer = Confirm::new("Would you like to enable automatic updates for cgen?")
+        .with_default(true)
+        .with_help_message("You can change this later with `cgen config --global`")
+        .prompt();
+
+    match answer {
+        Ok(yes) => {
+            if let Err(e) = config::save_auto_update_preference(yes) {
+                eprintln!(
+                    "{} Failed to save auto-update preference: {}",
+                    "warning:".yellow().bold(),
+                    e
+                );
+            } else {
+                let status = if yes { "enabled" } else { "disabled" };
+                println!(
+                    "{} Auto-updates {}.\n",
+                    "done!".green().bold(),
+                    status
+                );
+            }
+        }
+        Err(_) => {
+            // User cancelled - leave as None, will ask again next time
+        }
+    }
+}
+
+/// Check for updates and either auto-update or return the latest version for a warning.
+/// Returns Some(latest_version) if a warning should be shown, None otherwise.
+fn check_for_updates(cfg: Option<&config::AppConfig>) -> Option<String> {
+    let version_check = match update::check_version() {
+        Ok(v) => v,
+        Err(_) => return None, // silently ignore network errors
+    };
+
+    if !version_check.update_available {
+        return None;
+    }
+
+    let auto_update = cfg.and_then(|c| c.auto_update).unwrap_or(false);
+
+    if auto_update {
+        println!(
+            "{} {} → {}",
+            "Auto-updating cgen...".cyan().bold(),
+            version_check.current.dimmed(),
+            version_check.latest.green(),
+        );
+        if let Err(e) = update::run_update() {
+            eprintln!(
+                "{} Auto-update failed: {}",
+                "warning:".yellow().bold(),
+                e
+            );
+            return Some(version_check.latest);
+        }
+        println!(
+            "{} Restart cgen to use the new version.\n",
+            "note:".yellow().bold()
+        );
+        return None;
+    }
+
+    Some(version_check.latest)
+}
+
+fn run_update_command() -> Result<()> {
+    println!("{}", "Checking for updates...".cyan().bold());
+
+    match update::check_version() {
+        Ok(v) if v.update_available => {
+            println!(
+                "{} {} → {}",
+                "New version available!".green().bold(),
+                v.current.dimmed(),
+                v.latest.green(),
+            );
+            update::run_update()?;
+        }
+        Ok(v) => {
+            println!(
+                "{} You are already on the latest version ({}).",
+                "Up to date!".green().bold(),
+                v.current,
+            );
+        }
+        Err(e) => {
+            anyhow::bail!("Failed to check for updates: {}", e);
+        }
+    }
+    Ok(())
+}
+
 fn run_undo(cfg: &config::AppConfig) -> Result<()> {
     git::ensure_head_exists()?;