From 87423a41fdfd40fe6a6de6c7bc366945812ac51e Mon Sep 17 00:00:00 2001
From: codcod <nikos@linux.com>
Date: Thu, 23 Oct 2025 21:47:43 +0200
Subject: [PATCH 1/4] feat: add plugins system phase 1

---
 docs/plugins.md       | 248 ++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs            |   1 +
 src/main.rs           |  59 +++++++++-
 src/plugins.rs        | 195 +++++++++++++++++++++++++++++++++
 tests/plugin_tests.rs | 120 ++++++++++++++++++++
 5 files changed, 620 insertions(+), 3 deletions(-)
 create mode 100644 docs/plugins.md
 create mode 100644 src/plugins.rs
 create mode 100644 tests/plugin_tests.rs

diff --git a/docs/plugins.md b/docs/plugins.md
new file mode 100644
index 0000000..2886a4b
--- /dev/null
+++ b/docs/plugins.md
@@ -0,0 +1,248 @@
+# Plugin System
+
+The `repos` tool supports an extensible plugin system that allows you to add new functionality without modifying the core codebase. This is implemented using Phase 1 of the plugin architecture: external command plugins.
+
+## How It Works
+
+The plugin system follows the same pattern as Git's external subcommands:
+
+- Any executable named `repos-<plugin>` in your `PATH` becomes a plugin
+- When you run `repos <plugin> <args>`, the tool automatically finds and executes `repos-<plugin>` with the provided arguments
+- This provides complete isolation, crash safety, and the ability to write plugins in any language
+
+## Creating a Plugin
+
+To create a plugin:
+
+1. **Create an executable** named `repos-<name>` where `<name>` is your plugin name
+2. **Make it executable** (`chmod +x repos-<name>`)
+3. **Add it to your PATH** so the `repos` tool can find it
+
+### Example: Health Plugin
+
+Here's a simple example of a health check plugin written in bash:
+
+```bash
+#!/bin/bash
+# Save as: repos-health
+
+echo "=== Repository Health Check ==="
+
+# Parse arguments
+CONFIG_FILE="config.yaml"
+VERBOSE=false
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -c|--config)
+            CONFIG_FILE="$2"
+            shift 2
+            ;;
+        -v|--verbose)
+            VERBOSE=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+echo "Using config: $CONFIG_FILE"
+echo "Verbose mode: $VERBOSE"
+
+# Add your health check logic here
+# You can parse the YAML config file and iterate over repositories
+# Example checks:
+# - Check for outdated dependencies (cargo outdated, npm outdated, etc.)
+# - Analyze cognitive complexity (radon, lizard, etc.)
+# - Security audits (cargo audit, npm audit, etc.)
+# - Code coverage statistics
+# - Git repository health (uncommitted changes, etc.)
+
+echo "Health check completed!"
+```
+
+### Example: Security Plugin in Python
+
+```python
+#!/usr/bin/env python3
+# Save as: repos-security
+
+import argparse
+import yaml
+import subprocess
+import sys
+
+def main():
+    parser = argparse.ArgumentParser(description='Security audit for repositories')
+    parser.add_argument('-c', '--config', default='config.yaml', help='Config file path')
+    parser.add_argument('--fix', action='store_true', help='Attempt to fix issues automatically')
+    args = parser.parse_args()
+
+    # Load configuration
+    try:
+        with open(args.config, 'r') as f:
+            config = yaml.safe_load(f)
+    except FileNotFoundError:
+        print(f"Error: Config file '{args.config}' not found", file=sys.stderr)
+        sys.exit(1)
+
+    repositories = config.get('repositories', [])
+
+    print("=== Security Audit ===")
+
+    for repo in repositories:
+        name = repo['name']
+        path = repo.get('path', f"./{name}")
+
+        print(f"\n🔍 Auditing {name}...")
+
+        # Example security checks
+        if check_rust_security(path):
+            print(f"  ✅ {name}: No security issues found")
+        else:
+            print(f"  ⚠️  {name}: Security issues detected")
+
+def check_rust_security(repo_path):
+    """Run cargo audit for Rust projects"""
+    try:
+        result = subprocess.run(
+            ['cargo', 'audit'],
+            cwd=repo_path,
+            capture_output=True,
+            text=True
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        # cargo not available, skip Rust checks
+        return True
+
+if __name__ == '__main__':
+    main()
+```
+
+## Using Plugins
+
+### List Available Plugins
+
+```bash
+repos --list-plugins
+```
+
+This command scans your `PATH` for any executables matching the `repos-*` pattern and displays them.
+
+### Execute a Plugin
+
+```bash
+repos <plugin-name> [arguments...]
+```
+
+Examples:
+
+```bash
+# Run health check with default config
+repos health
+
+# Run health check with custom config and verbose output
+repos health -c my-config.yaml -v
+
+# Run security audit
+repos security --config production.yaml
+
+# Run security audit with auto-fix
+repos security --fix
+```
+
+## Plugin Guidelines
+
+### Naming
+
+- Plugin executables must be named `repos-<name>`
+- Choose descriptive, lowercase names
+- Use hyphens for multi-word names (e.g., `repos-code-quality`)
+
+### Arguments
+
+- Follow Unix conventions for command-line arguments
+- Support `-h` or `--help` for usage information
+- Consider supporting `-c` or `--config` for custom config files
+- Use long options with double dashes (`--verbose`) for clarity
+
+### Output
+
+- Use clear, structured output
+- Consider using emoji or symbols for visual feedback (✅ ❌ ⚠️)
+- Write errors to stderr, normal output to stdout
+- Use appropriate exit codes (0 for success, non-zero for errors)
+
+### Integration
+
+- Plugins should work with the standard `config.yaml` format
+- Parse the YAML configuration to access repository information
+- Consider the repository structure (name, path, tags, etc.)
+
+## Plugin Development Tips
+
+### Configuration Access
+
+Most plugins will need to read the repos configuration file. Here's how to parse it in different languages:
+
+**Bash (using yq):**
+
+```bash
+# Install yq: brew install yq (macOS) or similar
+repos=$(yq eval '.repositories[].name' config.yaml)
+```
+
+**Python:**
+
+```python
+import yaml
+with open('config.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+    repositories = config.get('repositories', [])
+```
+
+**Rust:**
+
+```rust
+use serde_yaml;
+use std::fs;
+
+let content = fs::read_to_string("config.yaml")?;
+let config: serde_yaml::Value = serde_yaml::from_str(&content)?;
+```
+
+### Error Handling
+
+- Always validate input arguments
+- Check if required tools are available before using them
+- Provide helpful error messages
+- Use appropriate exit codes
+
+### Testing
+
+- Create test repositories for development
+- Test with different repository structures
+- Verify behavior with missing or invalid configurations
+
+## Limitations
+
+This Phase 1 implementation has some limitations that future phases may address:
+
+- No built-in dependency management for plugins
+- No plugin metadata or versioning system
+- No automatic plugin updates
+- Limited inter-plugin communication
+
+## Future Phases
+
+The plugin system is designed for gradual expansion:
+
+- **Phase 2**: Plugin registry and installation system
+- **Phase 3**: Plugin API for deeper integration
+- **Phase 4**: Plugin dependency management and sandboxing
+
+For now, Phase 1 provides a solid foundation for extending the repos tool with external functionality while maintaining simplicity and safety.
diff --git a/src/lib.rs b/src/lib.rs
index c1a1b25..575f7f2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,7 @@ pub mod config;
 pub mod constants;
 pub mod git;
 pub mod github;
+pub mod plugins;
 pub mod runner;
 pub mod util;
 
diff --git a/src/main.rs b/src/main.rs
index 08b80ca..3f2ea75 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,20 @@
 use anyhow::Result;
 use clap::{Parser, Subcommand};
-use repos::{commands::*, config::Config, constants};
+use repos::{commands::*, config::Config, constants, plugins};
 use std::{env, path::PathBuf};
 
 #[derive(Parser)]
 #[command(name = "repos")]
 #[command(about = "A cli tool to manage multiple GitHub repositories")]
 #[command(version)]
+#[command(allow_external_subcommands = true)]
 struct Cli {
+    /// List all available external plugins
+    #[arg(long)]
+    list_plugins: bool,
+
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
 }
 
 #[derive(Subcommand)]
@@ -159,14 +164,62 @@ enum Commands {
         #[arg(long)]
         supplement: bool,
     },
+
+    /// External plugin command
+    #[command(external_subcommand)]
+    External(Vec<String>),
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
 
-    // Execute the appropriate command
+    // Handle list-plugins option first
+    if cli.list_plugins {
+        let plugins = plugins::list_external_plugins();
+        if plugins.is_empty() {
+            println!("No external plugins found.");
+            println!(
+                "To create a plugin, make an executable named 'repos-<name>' available in your PATH."
+            );
+        } else {
+            println!("Available external plugins:");
+            for plugin in plugins {
+                println!("  {}", plugin);
+            }
+        }
+        return Ok(());
+    }
+
+    // Handle commands
     match cli.command {
+        Some(Commands::External(args)) => {
+            if args.is_empty() {
+                anyhow::bail!("External command provided but no arguments given");
+            }
+
+            let plugin_name = &args[0];
+            let plugin_args: Vec<String> = args.iter().skip(1).cloned().collect();
+
+            plugins::try_external_plugin(plugin_name, &plugin_args)?;
+        }
+        Some(command) => execute_builtin_command(command).await?,
+        None => {
+            // No command provided, print help
+            anyhow::bail!("No command provided. Use --help for usage information.");
+        }
+    }
+
+    Ok(())
+}
+
+async fn execute_builtin_command(command: Commands) -> Result<()> {
+    // Execute the appropriate command
+    match command {
+        Commands::External(_) => {
+            // These cases are handled in main(), this should not be reached
+            unreachable!("External commands should be handled in main()")
+        }
         Commands::Clone {
             repos,
             config,
diff --git a/src/plugins.rs b/src/plugins.rs
new file mode 100644
index 0000000..bc79505
--- /dev/null
+++ b/src/plugins.rs
@@ -0,0 +1,195 @@
+use anyhow::Result;
+use std::env;
+use std::path::Path;
+use std::process::Command;
+
+/// Prefix for external plugin executables
+const PLUGIN_PREFIX: &str = "repos-";
+
+/// Try to execute an external plugin
+pub fn try_external_plugin(plugin_name: &str, args: &[String]) -> Result<()> {
+    let binary_name = format!("{}{}", PLUGIN_PREFIX, plugin_name);
+
+    let mut cmd = Command::new(&binary_name);
+    cmd.args(args);
+
+    let status = cmd.status().map_err(|e| {
+        anyhow::anyhow!(
+            "Plugin '{}' not found or failed to execute: {}",
+            binary_name,
+            e
+        )
+    })?;
+
+    if !status.success() {
+        anyhow::bail!("Plugin '{}' exited with status: {}", binary_name, status);
+    }
+
+    Ok(())
+}
+
+/// List all available external plugins by scanning PATH
+pub fn list_external_plugins() -> Vec<String> {
+    let mut plugins = Vec::new();
+
+    if let Ok(path_env) = env::var("PATH") {
+        for path_dir in env::split_paths(&path_env) {
+            if let Ok(entries) = std::fs::read_dir(&path_dir) {
+                for entry in entries.flatten() {
+                    if let Some(file_name) = entry.file_name().to_str()
+                        && file_name.starts_with(PLUGIN_PREFIX)
+                        && is_executable(&entry.path())
+                        && let Some(plugin_name) = file_name.strip_prefix(PLUGIN_PREFIX)
+                        && !plugin_name.is_empty()
+                        && !plugins.contains(&plugin_name.to_string())
+                    {
+                        plugins.push(plugin_name.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    plugins.sort();
+    plugins
+}
+
+/// Check if a file is executable
+fn is_executable(path: &Path) -> bool {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        if let Ok(metadata) = std::fs::metadata(path) {
+            let permissions = metadata.permissions();
+            return permissions.mode() & 0o111 != 0;
+        }
+    }
+
+    #[cfg(windows)]
+    {
+        use std::ffi::OsStr;
+        // On Windows, check if file has executable extension
+        if let Some(extension) = path.extension().and_then(OsStr::to_str) {
+            let executable_extensions = ["exe", "bat", "cmd", "com"];
+            return executable_extensions
+                .iter()
+                .any(|&ext| ext.eq_ignore_ascii_case(extension));
+        }
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_list_external_plugins_empty() {
+        // Test with empty PATH
+        let original_path = env::var("PATH").ok();
+        unsafe {
+            env::set_var("PATH", "");
+        }
+
+        let plugins = list_external_plugins();
+        assert!(plugins.is_empty());
+
+        // Restore original PATH
+        if let Some(path) = original_path {
+            unsafe {
+                env::set_var("PATH", path);
+            }
+        }
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_list_external_plugins_with_mock_plugins() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let temp_dir = TempDir::new().unwrap();
+        let plugin_dir = temp_dir.path();
+
+        // Create mock plugin files
+        let plugin1_path = plugin_dir.join("repos-health");
+        let plugin2_path = plugin_dir.join("repos-security");
+        let non_plugin_path = plugin_dir.join("other-tool");
+        let non_executable_path = plugin_dir.join("repos-nonexec");
+
+        fs::write(&plugin1_path, "#!/bin/sh\necho 'health plugin'").unwrap();
+        fs::write(&plugin2_path, "#!/bin/sh\necho 'security plugin'").unwrap();
+        fs::write(&non_plugin_path, "#!/bin/sh\necho 'not a plugin'").unwrap();
+        fs::write(&non_executable_path, "echo 'not executable'").unwrap();
+
+        // Make plugins executable
+        let mut perms = fs::metadata(&plugin1_path).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&plugin1_path, perms).unwrap();
+
+        let mut perms = fs::metadata(&plugin2_path).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&plugin2_path, perms).unwrap();
+
+        let mut perms = fs::metadata(&non_plugin_path).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&non_plugin_path, perms).unwrap();
+
+        // Update PATH to include our temp directory
+        let original_path = env::var("PATH").unwrap_or_default();
+        let new_path = format!("{}:{}", plugin_dir.display(), original_path);
+        unsafe {
+            env::set_var("PATH", &new_path);
+        }
+
+        let plugins = list_external_plugins();
+
+        // Should find health and security plugins, but not the others
+        assert!(plugins.contains(&"health".to_string()));
+        assert!(plugins.contains(&"security".to_string()));
+        assert!(!plugins.contains(&"other-tool".to_string()));
+        assert!(!plugins.contains(&"nonexec".to_string()));
+
+        // Restore original PATH
+        unsafe {
+            env::set_var("PATH", original_path);
+        }
+    }
+
+    #[test]
+    fn test_is_executable() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test_file");
+        fs::write(&file_path, "test content").unwrap();
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+
+            // Initially not executable
+            assert!(!is_executable(&file_path));
+
+            // Make executable
+            let mut perms = fs::metadata(&file_path).unwrap().permissions();
+            perms.set_mode(0o755);
+            fs::set_permissions(&file_path, perms).unwrap();
+
+            assert!(is_executable(&file_path));
+        }
+
+        #[cfg(windows)]
+        {
+            // Test with .exe extension
+            let exe_path = temp_dir.path().join("test.exe");
+            fs::write(&exe_path, "test content").unwrap();
+            assert!(is_executable(&exe_path));
+
+            // Test with .bat extension
+            let bat_path = temp_dir.path().join("test.bat");
+            fs::write(&bat_path, "test content").unwrap();
+            assert!(is_executable(&bat_path));
+        }
+    }
+}
diff --git a/tests/plugin_tests.rs b/tests/plugin_tests.rs
new file mode 100644
index 0000000..dbbc5b2
--- /dev/null
+++ b/tests/plugin_tests.rs
@@ -0,0 +1,120 @@
+use std::fs;
+use std::os::unix::fs::PermissionsExt;
+use std::process::Command;
+use tempfile::TempDir;
+
+#[test]
+fn test_plugin_system_integration() {
+    // Create a temporary directory for our test plugin
+    let temp_dir = TempDir::new().unwrap();
+    let plugin_dir = temp_dir.path();
+
+    // Create a mock plugin
+    let plugin_content = r#"#!/bin/bash
+echo "Mock health plugin executed"
+echo "Args: $@"
+exit 0
+"#;
+
+    let plugin_path = plugin_dir.join("repos-health");
+    fs::write(&plugin_path, plugin_content).unwrap();
+
+    // Make it executable
+    let mut perms = fs::metadata(&plugin_path).unwrap().permissions();
+    perms.set_mode(0o755);
+    fs::set_permissions(&plugin_path, perms).unwrap();
+
+    // Build the project
+    let output = Command::new("cargo")
+        .args(["build", "--quiet"])
+        .output()
+        .expect("Failed to build project");
+
+    assert!(
+        output.status.success(),
+        "Failed to build: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Test list-plugins with our mock plugin
+    let output = Command::new("./target/debug/repos")
+        .arg("--list-plugins")
+        .env(
+            "PATH",
+            format!(
+                "{}:{}",
+                plugin_dir.display(),
+                std::env::var("PATH").unwrap_or_default()
+            ),
+        )
+        .output()
+        .expect("Failed to run list-plugins");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Available external plugins:"));
+    assert!(stdout.contains("health"));
+
+    // Test calling the external plugin
+    let output = Command::new("./target/debug/repos")
+        .args(["health", "--test", "argument"])
+        .env(
+            "PATH",
+            format!(
+                "{}:{}",
+                plugin_dir.display(),
+                std::env::var("PATH").unwrap_or_default()
+            ),
+        )
+        .output()
+        .expect("Failed to run health plugin");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Mock health plugin executed"));
+    assert!(stdout.contains("Args: --test argument"));
+
+    // Test non-existent plugin
+    let output = Command::new("./target/debug/repos")
+        .arg("nonexistent")
+        .output()
+        .expect("Failed to run nonexistent plugin");
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("Plugin 'repos-nonexistent' not found"));
+}
+
+#[test]
+fn test_builtin_commands_still_work() {
+    // Ensure built-in commands are not affected by plugin system
+    let output = Command::new("cargo")
+        .args(["build", "--quiet"])
+        .output()
+        .expect("Failed to build project");
+
+    assert!(output.status.success());
+
+    // Test help command
+    let output = Command::new("./target/debug/repos")
+        .arg("--help")
+        .output()
+        .expect("Failed to run help");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("A cli tool to manage multiple GitHub repositories"));
+    assert!(stdout.contains("list-plugins"));
+    assert!(stdout.contains("clone"));
+
+    // Test list-plugins when no plugins are available
+    let output = Command::new("./target/debug/repos")
+        .arg("--list-plugins")
+        .env("PATH", "/nonexistent") // Empty PATH
+        .output()
+        .expect("Failed to run list-plugins");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("No external plugins found"));
+}

From 07382d2318595a469b5f1dfa79e36222610779a3 Mon Sep 17 00:00:00 2001
From: codcod <nikos@linux.com>
Date: Thu, 23 Oct 2025 23:01:11 +0200
Subject: [PATCH 2/4] tests: improve coverage

---
 Cargo.toml                              |  11 +
 src/lib.rs                              |   5 +
 tests/github_tests.rs                   | 413 ++++++++++++++++-----
 tests/init_command_integration_tests.rs | 470 ++++++++++++++++++++++++
 tests/init_command_tests.rs             | 470 ++++++++++++++++++++++++
 tests/mod.rs                            |   2 +
 tests/run_command_tests.rs              | 206 +++++++++++
 7 files changed, 1482 insertions(+), 95 deletions(-)
 create mode 100644 tests/init_command_integration_tests.rs
 create mode 100644 tests/init_command_tests.rs

diff --git a/Cargo.toml b/Cargo.toml
index d554fc9..2cdd3a7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,6 +3,16 @@ name = "repos"
 version = "0.0.8"
 edition = "2024"
 
+[lib]
+name = "repos"
+path = "src/lib.rs"
+
+[workspace]
+members = [
+    ".",
+    "plugins/repos-health",
+]
+
 [dependencies]
 async-trait = "0.1"
 clap = { version = "4.4", features = ["derive"] }
@@ -22,3 +32,4 @@ uuid = { version = "1.6", features = ["v4"] }
 
 [dev-dependencies]
 tempfile = "3.0"
+serial_test = "3.0"
diff --git a/src/lib.rs b/src/lib.rs
index 575f7f2..4181095 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,3 +15,8 @@ pub type Result<T> = anyhow::Result<T>;
 pub use commands::{Command, CommandContext};
 pub use config::{Config, Repository};
 pub use github::PrOptions;
+
+/// Helper function for plugins to load the default config
+pub fn load_default_config() -> anyhow::Result<Config> {
+    Config::load_config(constants::config::DEFAULT_CONFIG_FILE)
+}
diff --git a/tests/github_tests.rs b/tests/github_tests.rs
index 7e87498..21cc150 100644
--- a/tests/github_tests.rs
+++ b/tests/github_tests.rs
@@ -1,9 +1,255 @@
 use repos::config::repository::Repository;
 use repos::github::api::create_pr_from_workspace;
+use repos::github::auth::GitHubAuth;
+use repos::github::client::GitHubClient;
 use repos::github::types::PrOptions;
 use std::fs;
 use tempfile::TempDir;
 
+// ===== GitHub Authentication Tests =====
+
+#[test]
+fn test_github_auth_new() {
+    let token = "ghp_test_token_123".to_string();
+    let auth = GitHubAuth::new(token.clone());
+    assert_eq!(auth.token(), &token);
+}
+
+#[test]
+fn test_github_auth_token() {
+    let token = "ghp_another_token_456".to_string();
+    let auth = GitHubAuth::new(token.clone());
+    assert_eq!(auth.token(), &token);
+}
+
+#[test]
+fn test_github_auth_get_auth_header() {
+    let token = "ghp_header_token_789".to_string();
+    let auth = GitHubAuth::new(token.clone());
+    let expected_header = format!("Bearer {}", token);
+    assert_eq!(auth.get_auth_header(), expected_header);
+}
+
+#[test]
+fn test_github_auth_validate_token_success() {
+    let token = "valid_token".to_string();
+    let auth = GitHubAuth::new(token);
+    let result = auth.validate_token();
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_github_auth_validate_token_empty() {
+    let auth = GitHubAuth::new(String::new());
+    let result = auth.validate_token();
+    assert!(result.is_err());
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("GitHub token is required")
+    );
+}
+
+#[test]
+fn test_github_auth_validate_token_whitespace() {
+    let auth = GitHubAuth::new("   ".to_string());
+    let result = auth.validate_token();
+    // Empty string after trim should still pass current validation
+    // (the validation only checks if completely empty)
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_github_auth_comprehensive() {
+    let token = "ghp_comprehensive_test_token".to_string();
+    let auth = GitHubAuth::new(token.clone());
+
+    // Test all methods work together
+    assert_eq!(auth.token(), &token);
+    assert_eq!(auth.get_auth_header(), format!("Bearer {}", token));
+    assert!(auth.validate_token().is_ok());
+}
+
+// ===== GitHub Client Tests =====
+
+#[test]
+fn test_github_client_new_with_token() {
+    let _client = GitHubClient::new(Some("test_token".to_string()));
+    // Client should be created successfully (we can't test internal state)
+    // This tests the constructor
+}
+
+#[test]
+fn test_github_client_new_without_token() {
+    let _client = GitHubClient::new(None);
+    // Client should be created successfully without token
+    // This tests the constructor
+}
+
+#[test]
+fn test_parse_github_url_ssh_github_com() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("git@github.com:owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_ssh_enterprise() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("git@github-enterprise:owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_https_github_com() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github.com/owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_https_enterprise() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github-enterprise/owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_legacy_format() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("github.com:owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_with_git_suffix() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("git@github.com:owner/repo.git");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_with_trailing_slash() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github.com/owner/repo/");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+}
+
+#[test]
+fn test_parse_github_url_invalid_format() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("invalid-url-format");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_parse_github_url_empty_string() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_parse_github_url_only_domain() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github.com");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_parse_github_url_missing_repo() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github.com/owner");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_parse_github_url_complex_repo_name() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("git@github.com:owner/repo-with-dashes");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo-with-dashes");
+}
+
+#[test]
+fn test_parse_github_url_numbers_in_names() {
+    let client = GitHubClient::new(None);
+    let result = client.parse_github_url("https://github.com/owner123/repo456");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner123");
+    assert_eq!(repo, "repo456");
+}
+
+#[test]
+fn test_github_client_comprehensive() {
+    // Test that all methods work together
+    let client = GitHubClient::new(Some("test_token".to_string()));
+
+    // Test various URL formats
+    let urls = vec![
+        "git@github.com:owner/repo",
+        "https://github.com/owner/repo.git",
+        "github.com/owner/repo",
+    ];
+
+    for url in urls {
+        let result = client.parse_github_url(url);
+        assert!(result.is_ok());
+        let (owner, repo) = result.unwrap();
+        assert_eq!(owner, "owner");
+        assert_eq!(repo, "repo");
+    }
+}
+
+// ===== GitHub API Integration Tests =====
+
+/// Helper function to create a git repository in a directory
+fn create_git_repo(path: &std::path::Path) -> std::io::Result<()> {
+    // Initialize git repo
+    std::process::Command::new("git")
+        .arg("init")
+        .current_dir(path)
+        .output()?;
+
+    // Configure git (required for commits)
+    std::process::Command::new("git")
+        .args(["config", "user.name", "Test User"])
+        .current_dir(path)
+        .output()?;
+
+    std::process::Command::new("git")
+        .args(["config", "user.email", "test@example.com"])
+        .current_dir(path)
+        .output()?;
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_create_pr_from_workspace_with_changes_success_flow() {
     // Setup temporary directory with real git repo structure
@@ -11,27 +257,9 @@ async fn test_create_pr_from_workspace_with_changes_success_flow() {
     let repo_path = temp_dir.path().to_path_buf();
 
     // Initialize git repo
-    let output = std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git init failed");
-    assert!(output.status.success());
-
-    // Set git config for testing
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config email failed");
-
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config name failed");
+    create_git_repo(&repo_path).unwrap();
 
-    // Create a file to have changes
+    // Create a file and commit
     fs::write(repo_path.join("test.txt"), "test content").unwrap();
 
     // Add and commit initial file
@@ -80,7 +308,6 @@ async fn test_create_pr_from_workspace_with_changes_success_flow() {
         .expect("git branch failed");
 
     let branches = String::from_utf8(output.stdout).unwrap();
-    println!("Branches created: {}", branches);
     assert!(branches.contains("automated-changes-") || branches.contains("* automated-changes-"));
 }
 
@@ -91,25 +318,7 @@ async fn test_create_pr_workspace_no_changes_early_return() {
     let repo_path = temp_dir.path().to_path_buf();
 
     // Initialize git repo
-    let output = std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git init failed");
-    assert!(output.status.success());
-
-    // Set git config
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config email failed");
-
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config name failed");
+    create_git_repo(&repo_path).unwrap();
 
     // Create and commit initial file to have a clean repo
     fs::write(repo_path.join("initial.txt"), "initial").unwrap();
@@ -152,24 +361,7 @@ async fn test_create_pr_workspace_commit_message_fallback() {
     let repo_path = temp_dir.path().to_path_buf();
 
     // Initialize git repo
-    std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git init failed");
-
-    // Set git config
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config email failed");
-
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config name failed");
+    create_git_repo(&repo_path).unwrap();
 
     // Create initial commit
     fs::write(repo_path.join("initial.txt"), "initial").unwrap();
@@ -227,24 +419,7 @@ async fn test_create_pr_workspace_branch_name_generation() {
     let repo_path = temp_dir.path().to_path_buf();
 
     // Initialize git repo
-    std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git init failed");
-
-    // Set git config
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config email failed");
-
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config name failed");
+    create_git_repo(&repo_path).unwrap();
 
     // Create initial commit
     fs::write(repo_path.join("initial.txt"), "initial").unwrap();
@@ -291,7 +466,6 @@ async fn test_create_pr_workspace_branch_name_generation() {
         .expect("git branch failed");
 
     let branches = String::from_utf8(output.stdout).unwrap();
-    println!("Branches in branch generation test: {}", branches);
     assert!(branches.contains("automated-changes-") || branches.contains("* automated-changes-"));
 }
 
@@ -332,24 +506,7 @@ async fn test_create_pr_workspace_custom_branch_and_commit() {
     let repo_path = temp_dir.path().to_path_buf();
 
     // Initialize git repo
-    std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git init failed");
-
-    // Set git config
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config email failed");
-
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .output()
-        .expect("git config name failed");
+    create_git_repo(&repo_path).unwrap();
 
     // Create initial commit
     fs::write(repo_path.join("initial.txt"), "initial").unwrap();
@@ -410,3 +567,69 @@ async fn test_create_pr_workspace_custom_branch_and_commit() {
     let commit_msg = String::from_utf8(output.stdout).unwrap();
     assert_eq!(commit_msg, "Custom commit message");
 }
+
+// ===== GitHub End-to-End Integration Tests =====
+
+#[tokio::test]
+async fn test_github_integration_auth_client_api() {
+    // Test complete integration flow with authentication, client, and API
+    let token = "ghp_integration_test_token".to_string();
+    let auth = GitHubAuth::new(token.clone());
+
+    // Validate auth
+    assert!(auth.validate_token().is_ok());
+    assert_eq!(auth.get_auth_header(), format!("Bearer {}", token));
+
+    // Test client with auth
+    let client = GitHubClient::new(Some(token));
+
+    // Test URL parsing
+    let result = client.parse_github_url("git@github.com:owner/repo");
+    assert!(result.is_ok());
+    let (owner, repo) = result.unwrap();
+    assert_eq!(owner, "owner");
+    assert_eq!(repo, "repo");
+
+    // Setup git repo for API testing
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path().to_path_buf();
+
+    create_git_repo(&repo_path).unwrap();
+
+    // Create initial commit
+    fs::write(repo_path.join("integration.txt"), "integration test").unwrap();
+    std::process::Command::new("git")
+        .args(["add", "."])
+        .current_dir(&repo_path)
+        .output()
+        .expect("git add failed");
+
+    std::process::Command::new("git")
+        .args(["commit", "-m", "Integration commit"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("git commit failed");
+
+    // Create changes for PR
+    fs::write(repo_path.join("changes.txt"), "integration changes").unwrap();
+
+    let repository = Repository {
+        name: "integration-repo".to_string(),
+        url: "https://github.com/owner/integration-repo.git".to_string(),
+        path: Some(repo_path.to_string_lossy().to_string()),
+        tags: Vec::new(),
+        branch: None,
+        config_dir: None,
+    };
+
+    let options = PrOptions::new(
+        "Integration Test PR".to_string(),
+        "This PR tests the integration flow".to_string(),
+        "ghp_integration_test_token".to_string(),
+    )
+    .create_only();
+
+    // Test the complete flow
+    let result = create_pr_from_workspace(&repository, &options).await;
+    assert!(result.is_ok());
+}
diff --git a/tests/init_command_integration_tests.rs b/tests/init_command_integration_tests.rs
new file mode 100644
index 0000000..907934e
--- /dev/null
+++ b/tests/init_command_integration_tests.rs
@@ -0,0 +1,470 @@
+use repos::commands::{Command, CommandContext, init::InitCommand};
+use repos::config::Config;
+use serial_test::serial;
+use std::fs;
+use tempfile::TempDir;
+
+/// Helper function to create a git repository in a directory
+fn create_git_repo(path: &std::path::Path) -> std::io::Result<()> {
+    // Initialize git repo
+    std::process::Command::new("git")
+        .arg("init")
+        .current_dir(path)
+        .output()?;
+
+    // Configure git (required for commits)
+    std::process::Command::new("git")
+        .args(["config", "user.name", "Test User"])
+        .current_dir(path)
+        .output()?;
+
+    std::process::Command::new("git")
+        .args(["config", "user.email", "test@example.com"])
+        .current_dir(path)
+        .output()?;
+
+    Ok(())
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_basic_creation() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("basic-config.yaml");
+
+    // Create a git repository so the command has something to discover
+    let repo_dir = temp_dir.path().join("test-repo");
+    fs::create_dir_all(&repo_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    assert!(result.is_ok());
+    // Config file should be created if repositories are found
+    if result.is_ok() {
+        // Command succeeded, but file may not exist if no remote URL could be found
+        // This is acceptable behavior
+    }
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_overwrite_existing_file() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("existing-config.yaml");
+
+    // Create existing file
+    fs::write(&output_path, "existing content").unwrap();
+
+    // Create a git repository so the command has something to discover
+    let repo_dir = temp_dir.path().join("test-repo");
+    fs::create_dir_all(&repo_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: true, // Should overwrite
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to temp directory
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    assert!(result.is_ok()); // Should succeed and overwrite
+
+    // The file content check is not reliable since it depends on whether
+    // a remote URL could be discovered
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_no_overwrite_existing_file() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("existing-config.yaml");
+
+    // Create existing file
+    fs::write(&output_path, "existing content").unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false, // Should not overwrite
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should fail because file exists and overwrite is false
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_with_git_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_dir = temp_dir.path().join("test-repo");
+    let git_dir = repo_dir.join(".git");
+
+    // Create a mock git repository
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    // Create a mock git config to simulate a real repo
+    fs::write(
+        git_dir.join("config"),
+        "[core]\nrepositoryformatversion = 0",
+    )
+    .unwrap();
+
+    let output_path = temp_dir.path().join("discovered-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to temp directory to discover the git repo
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let _result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // The command might fail because it can't get the remote URL, but should not panic
+    // We test that the discovery logic executes without crashing
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_supplement_with_duplicate_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("config-with-duplicate.yaml");
+
+    // Create existing config with a repository
+    let existing_config = Config {
+        repositories: vec![repos::config::Repository::new(
+            "test-repo".to_string(),
+            "git@github.com:owner/test-repo.git".to_string(),
+        )],
+    };
+    existing_config
+        .save(&output_path.to_string_lossy())
+        .unwrap();
+
+    // Create a directory structure that would discover the same repo
+    let repo_dir = temp_dir.path().join("test-repo");
+    let git_dir = repo_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: true, // Should supplement but skip duplicates
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed and maintain the existing repository
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_supplement_with_new_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("config-with-supplement.yaml");
+
+    // Create existing config with one repository
+    let existing_config = Config {
+        repositories: vec![repos::config::Repository::new(
+            "existing-repo".to_string(),
+            "git@github.com:owner/existing-repo.git".to_string(),
+        )],
+    };
+    existing_config
+        .save(&output_path.to_string_lossy())
+        .unwrap();
+
+    // Create a different directory structure that would discover a new repo
+    let repo_dir = temp_dir.path().join("new-repo");
+    let git_dir = repo_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: true, // Should supplement with new repo
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed and add the new repository
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_git_directory_edge_cases() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create various directory structures to test edge cases
+    let nested_dir = temp_dir
+        .path()
+        .join("level1")
+        .join("level2")
+        .join("level3")
+        .join("too-deep");
+    let git_dir = nested_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&nested_dir).unwrap();
+
+    // Create a .git file (not directory) to test that case
+    let repo_with_git_file = temp_dir.path().join("repo-with-git-file");
+    fs::create_dir_all(&repo_with_git_file).unwrap();
+    fs::write(repo_with_git_file.join(".git"), "gitdir: ../real-git-dir").unwrap();
+
+    let output_path = temp_dir.path().join("edge-case-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed - edge cases are handled gracefully
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_empty_directory() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("empty-config.yaml");
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to empty temp directory
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed even with no git repositories found
+    assert!(result.is_ok());
+
+    // File should NOT exist when no repositories are found (expected behavior)
+    assert!(!output_path.exists());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_multiple_git_repositories() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create multiple git repositories
+    let repo1_dir = temp_dir.path().join("repo1");
+    let repo2_dir = temp_dir.path().join("repo2");
+    let repo3_dir = temp_dir.path().join("nested").join("repo3");
+
+    for repo_dir in [&repo1_dir, &repo2_dir, &repo3_dir] {
+        fs::create_dir_all(repo_dir).unwrap();
+        fs::create_dir_all(repo_dir.join(".git")).unwrap();
+        create_git_repo(repo_dir).unwrap();
+    }
+
+    let output_path = temp_dir.path().join("multi-repo-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed
+    assert!(result.is_ok());
+
+    // Note: File may not exist if git repositories don't have remote URLs
+    // which is common in test scenarios. This is expected behavior.
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_integration_flow() {
+    // Test complete initialization flow with realistic scenarios
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create a realistic project structure
+    let backend_dir = temp_dir.path().join("my-project-backend");
+    let frontend_dir = temp_dir.path().join("my-project-frontend");
+    let docs_dir = temp_dir.path().join("docs");
+
+    // Only backend and frontend are git repos
+    for repo_dir in [&backend_dir, &frontend_dir] {
+        fs::create_dir_all(repo_dir).unwrap();
+        fs::create_dir_all(repo_dir.join(".git")).unwrap();
+        create_git_repo(repo_dir).unwrap();
+
+        // Add some realistic files
+        fs::write(repo_dir.join("README.md"), "# Project").unwrap();
+        fs::write(repo_dir.join(".gitignore"), "target/\nnode_modules/").unwrap();
+    }
+
+    // docs is not a git repo
+    fs::create_dir_all(&docs_dir).unwrap();
+    fs::write(docs_dir.join("README.md"), "# Documentation").unwrap();
+
+    let output_path = temp_dir.path().join("repos.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed
+    assert!(result.is_ok());
+
+    // Note: Config file may not be created if repositories don't have remote URLs
+    // This is expected behavior in test scenarios
+}
diff --git a/tests/init_command_tests.rs b/tests/init_command_tests.rs
new file mode 100644
index 0000000..907934e
--- /dev/null
+++ b/tests/init_command_tests.rs
@@ -0,0 +1,470 @@
+use repos::commands::{Command, CommandContext, init::InitCommand};
+use repos::config::Config;
+use serial_test::serial;
+use std::fs;
+use tempfile::TempDir;
+
+/// Helper function to create a git repository in a directory
+fn create_git_repo(path: &std::path::Path) -> std::io::Result<()> {
+    // Initialize git repo
+    std::process::Command::new("git")
+        .arg("init")
+        .current_dir(path)
+        .output()?;
+
+    // Configure git (required for commits)
+    std::process::Command::new("git")
+        .args(["config", "user.name", "Test User"])
+        .current_dir(path)
+        .output()?;
+
+    std::process::Command::new("git")
+        .args(["config", "user.email", "test@example.com"])
+        .current_dir(path)
+        .output()?;
+
+    Ok(())
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_basic_creation() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("basic-config.yaml");
+
+    // Create a git repository so the command has something to discover
+    let repo_dir = temp_dir.path().join("test-repo");
+    fs::create_dir_all(&repo_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    assert!(result.is_ok());
+    // Config file should be created if repositories are found
+    if result.is_ok() {
+        // Command succeeded, but file may not exist if no remote URL could be found
+        // This is acceptable behavior
+    }
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_overwrite_existing_file() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("existing-config.yaml");
+
+    // Create existing file
+    fs::write(&output_path, "existing content").unwrap();
+
+    // Create a git repository so the command has something to discover
+    let repo_dir = temp_dir.path().join("test-repo");
+    fs::create_dir_all(&repo_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: true, // Should overwrite
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to temp directory
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    assert!(result.is_ok()); // Should succeed and overwrite
+
+    // The file content check is not reliable since it depends on whether
+    // a remote URL could be discovered
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_no_overwrite_existing_file() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("existing-config.yaml");
+
+    // Create existing file
+    fs::write(&output_path, "existing content").unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false, // Should not overwrite
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should fail because file exists and overwrite is false
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_with_git_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_dir = temp_dir.path().join("test-repo");
+    let git_dir = repo_dir.join(".git");
+
+    // Create a mock git repository
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    // Create a mock git config to simulate a real repo
+    fs::write(
+        git_dir.join("config"),
+        "[core]\nrepositoryformatversion = 0",
+    )
+    .unwrap();
+
+    let output_path = temp_dir.path().join("discovered-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to temp directory to discover the git repo
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let _result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // The command might fail because it can't get the remote URL, but should not panic
+    // We test that the discovery logic executes without crashing
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_supplement_with_duplicate_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("config-with-duplicate.yaml");
+
+    // Create existing config with a repository
+    let existing_config = Config {
+        repositories: vec![repos::config::Repository::new(
+            "test-repo".to_string(),
+            "git@github.com:owner/test-repo.git".to_string(),
+        )],
+    };
+    existing_config
+        .save(&output_path.to_string_lossy())
+        .unwrap();
+
+    // Create a directory structure that would discover the same repo
+    let repo_dir = temp_dir.path().join("test-repo");
+    let git_dir = repo_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: true, // Should supplement but skip duplicates
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed and maintain the existing repository
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_supplement_with_new_repository() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("config-with-supplement.yaml");
+
+    // Create existing config with one repository
+    let existing_config = Config {
+        repositories: vec![repos::config::Repository::new(
+            "existing-repo".to_string(),
+            "git@github.com:owner/existing-repo.git".to_string(),
+        )],
+    };
+    existing_config
+        .save(&output_path.to_string_lossy())
+        .unwrap();
+
+    // Create a different directory structure that would discover a new repo
+    let repo_dir = temp_dir.path().join("new-repo");
+    let git_dir = repo_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&repo_dir).unwrap();
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: true, // Should supplement with new repo
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed and add the new repository
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_git_directory_edge_cases() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create various directory structures to test edge cases
+    let nested_dir = temp_dir
+        .path()
+        .join("level1")
+        .join("level2")
+        .join("level3")
+        .join("too-deep");
+    let git_dir = nested_dir.join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    create_git_repo(&nested_dir).unwrap();
+
+    // Create a .git file (not directory) to test that case
+    let repo_with_git_file = temp_dir.path().join("repo-with-git-file");
+    fs::create_dir_all(&repo_with_git_file).unwrap();
+    fs::write(repo_with_git_file.join(".git"), "gitdir: ../real-git-dir").unwrap();
+
+    let output_path = temp_dir.path().join("edge-case-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    // Restore original directory
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed - edge cases are handled gracefully
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_empty_directory() {
+    let temp_dir = TempDir::new().unwrap();
+    let output_path = temp_dir.path().join("empty-config.yaml");
+
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    // Change to empty temp directory
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed even with no git repositories found
+    assert!(result.is_ok());
+
+    // File should NOT exist when no repositories are found (expected behavior)
+    assert!(!output_path.exists());
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_multiple_git_repositories() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create multiple git repositories
+    let repo1_dir = temp_dir.path().join("repo1");
+    let repo2_dir = temp_dir.path().join("repo2");
+    let repo3_dir = temp_dir.path().join("nested").join("repo3");
+
+    for repo_dir in [&repo1_dir, &repo2_dir, &repo3_dir] {
+        fs::create_dir_all(repo_dir).unwrap();
+        fs::create_dir_all(repo_dir.join(".git")).unwrap();
+        create_git_repo(repo_dir).unwrap();
+    }
+
+    let output_path = temp_dir.path().join("multi-repo-config.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed
+    assert!(result.is_ok());
+
+    // Note: File may not exist if git repositories don't have remote URLs
+    // which is common in test scenarios. This is expected behavior.
+}
+
+#[tokio::test]
+#[serial]
+async fn test_init_command_integration_flow() {
+    // Test complete initialization flow with realistic scenarios
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create a realistic project structure
+    let backend_dir = temp_dir.path().join("my-project-backend");
+    let frontend_dir = temp_dir.path().join("my-project-frontend");
+    let docs_dir = temp_dir.path().join("docs");
+
+    // Only backend and frontend are git repos
+    for repo_dir in [&backend_dir, &frontend_dir] {
+        fs::create_dir_all(repo_dir).unwrap();
+        fs::create_dir_all(repo_dir.join(".git")).unwrap();
+        create_git_repo(repo_dir).unwrap();
+
+        // Add some realistic files
+        fs::write(repo_dir.join("README.md"), "# Project").unwrap();
+        fs::write(repo_dir.join(".gitignore"), "target/\nnode_modules/").unwrap();
+    }
+
+    // docs is not a git repo
+    fs::create_dir_all(&docs_dir).unwrap();
+    fs::write(docs_dir.join("README.md"), "# Documentation").unwrap();
+
+    let output_path = temp_dir.path().join("repos.yaml");
+    let command = InitCommand {
+        output: output_path.to_string_lossy().to_string(),
+        overwrite: false,
+        supplement: false,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        repos: None,
+        parallel: false,
+    };
+
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+
+    let result = command.execute(&context).await;
+
+    std::env::set_current_dir(original_dir).unwrap();
+
+    // Should succeed
+    assert!(result.is_ok());
+
+    // Note: Config file may not be created if repositories don't have remote URLs
+    // This is expected behavior in test scenarios
+}
diff --git a/tests/mod.rs b/tests/mod.rs
index 2151ee2..58fb681 100644
--- a/tests/mod.rs
+++ b/tests/mod.rs
@@ -1,5 +1,7 @@
 pub mod cli_tests;
 pub mod git_tests;
 pub mod github_tests;
+pub mod init_command_tests;
+pub mod plugin_tests;
 pub mod pr_command_tests;
 pub mod run_command_tests;
diff --git a/tests/run_command_tests.rs b/tests/run_command_tests.rs
index 0556a10..59f0ec5 100644
--- a/tests/run_command_tests.rs
+++ b/tests/run_command_tests.rs
@@ -3,6 +3,7 @@ use repos::{
     config::{Config, Repository},
 };
 use std::fs;
+use std::path::PathBuf;
 use std::process::Command as ProcessCommand;
 use tempfile::TempDir;
 
@@ -41,6 +42,66 @@ fn create_git_repo(path: &std::path::Path) -> std::io::Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_run_command_basic_creation() {
+    let command = RunCommand {
+        command: "echo hello".to_string(),
+        no_save: false,
+        output_dir: None,
+    };
+
+    assert_eq!(command.command, "echo hello");
+    assert!(!command.no_save);
+    assert!(command.output_dir.is_none());
+}
+
+#[tokio::test]
+async fn test_run_command_with_custom_output_dir() {
+    let output_dir = PathBuf::from("/tmp/custom");
+    let command = RunCommand {
+        command: "ls".to_string(),
+        no_save: false,
+        output_dir: Some(output_dir.clone()),
+    };
+
+    assert_eq!(command.command, "ls");
+    assert!(!command.no_save);
+    assert_eq!(command.output_dir, Some(output_dir));
+}
+
+#[tokio::test]
+async fn test_run_command_no_save_mode() {
+    let command = RunCommand {
+        command: "pwd".to_string(),
+        no_save: true,
+        output_dir: None,
+    };
+
+    assert_eq!(command.command, "pwd");
+    assert!(command.no_save);
+    assert!(command.output_dir.is_none());
+}
+
+#[tokio::test]
+async fn test_run_command_empty_repositories() {
+    let command = RunCommand {
+        command: "echo test".to_string(),
+        no_save: true,
+        output_dir: None,
+    };
+
+    let context = CommandContext {
+        config: Config::new(), // Empty config
+        tag: vec![],
+        exclude_tag: vec![],
+        parallel: false,
+        repos: None,
+    };
+
+    let result = command.execute(&context).await;
+    assert!(result.is_ok()); // Should succeed with empty repos
+}
+
 #[tokio::test]
 async fn test_run_command_basic_execution() {
     let temp_dir = TempDir::new().unwrap();
@@ -439,3 +500,148 @@ async fn test_run_command_with_multiple_tags() {
     let result = command.execute(&context).await;
     assert!(result.is_ok());
 }
+
+#[tokio::test]
+async fn test_run_command_with_special_characters() {
+    let command = RunCommand {
+        command: "echo \"test with spaces and symbols: @#$%\"".to_string(),
+        no_save: true,
+        output_dir: None,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        parallel: false,
+        repos: None,
+    };
+
+    let result = command.execute(&context).await;
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn test_run_command_parallel_mode() {
+    let command = RunCommand {
+        command: "echo parallel test".to_string(),
+        no_save: true,
+        output_dir: None,
+    };
+
+    let context = CommandContext {
+        config: Config::new(),
+        tag: vec![],
+        exclude_tag: vec![],
+        parallel: true, // Test parallel execution
+        repos: None,
+    };
+
+    let result = command.execute(&context).await;
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn test_run_command_comprehensive() {
+    // Test all options together with real git repositories
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create multiple test repos
+    let repo_dir1 = temp_dir.path().join("comprehensive-repo1");
+    fs::create_dir_all(&repo_dir1).unwrap();
+    create_git_repo(&repo_dir1).unwrap();
+
+    let repo_dir2 = temp_dir.path().join("comprehensive-repo2");
+    fs::create_dir_all(&repo_dir2).unwrap();
+    create_git_repo(&repo_dir2).unwrap();
+
+    let command = RunCommand {
+        command: "echo comprehensive test".to_string(),
+        no_save: false,
+        output_dir: Some(temp_dir.path().to_path_buf()),
+    };
+
+    let config = Config {
+        repositories: vec![
+            Repository {
+                name: "comprehensive-repo1".to_string(),
+                url: "https://github.com/test/comprehensive1.git".to_string(),
+                tags: vec!["backend".to_string()],
+                path: Some(repo_dir1.to_string_lossy().to_string()),
+                branch: None,
+                config_dir: None,
+            },
+            Repository {
+                name: "comprehensive-repo2".to_string(),
+                url: "https://github.com/test/comprehensive2.git".to_string(),
+                tags: vec!["frontend".to_string()],
+                path: Some(repo_dir2.to_string_lossy().to_string()),
+                branch: None,
+                config_dir: None,
+            },
+        ],
+    };
+
+    let context = CommandContext {
+        config,
+        tag: vec!["backend".to_string()], // Should filter to repo1 only
+        exclude_tag: vec![],
+        parallel: true,
+        repos: None,
+    };
+
+    let result = command.execute(&context).await;
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn test_run_command_exclude_tag_filter() {
+    let temp_dir = TempDir::new().unwrap();
+    let log_dir = temp_dir.path().join("logs");
+    fs::create_dir_all(&log_dir).unwrap();
+
+    let repo_dir1 = temp_dir.path().join("backend-repo");
+    fs::create_dir_all(&repo_dir1).unwrap();
+    create_git_repo(&repo_dir1).unwrap();
+
+    let repo_dir2 = temp_dir.path().join("frontend-repo");
+    fs::create_dir_all(&repo_dir2).unwrap();
+    create_git_repo(&repo_dir2).unwrap();
+
+    let backend_repo = Repository {
+        name: "backend-repo".to_string(),
+        url: "https://github.com/user/backend-repo.git".to_string(),
+        tags: vec!["backend".to_string(), "rust".to_string()],
+        path: Some(repo_dir1.to_string_lossy().to_string()),
+        branch: None,
+        config_dir: None,
+    };
+
+    let frontend_repo = Repository {
+        name: "frontend-repo".to_string(),
+        url: "https://github.com/user/frontend-repo.git".to_string(),
+        tags: vec!["frontend".to_string(), "javascript".to_string()],
+        path: Some(repo_dir2.to_string_lossy().to_string()),
+        branch: None,
+        config_dir: None,
+    };
+
+    let command = RunCommand {
+        command: "echo hello".to_string(),
+        no_save: true,
+        output_dir: None,
+    };
+
+    let context = CommandContext {
+        config: Config {
+            repositories: vec![backend_repo, frontend_repo],
+        },
+        tag: vec![],
+        exclude_tag: vec!["frontend".to_string()], // Should exclude frontend repo
+        repos: None,
+        parallel: false,
+    };
+
+    let result = command.execute(&context).await;
+    assert!(result.is_ok());
+}

From 2e268a4cb92686f082cf114805adb8976b7e49fd Mon Sep 17 00:00:00 2001
From: codcod <nikos@linux.com>
Date: Thu, 23 Oct 2025 23:02:00 +0200
Subject: [PATCH 3/4] tests: improve coverage

---
 tests/init_command_integration_tests.rs | 470 ------------------------
 1 file changed, 470 deletions(-)
 delete mode 100644 tests/init_command_integration_tests.rs

diff --git a/tests/init_command_integration_tests.rs b/tests/init_command_integration_tests.rs
deleted file mode 100644
index 907934e..0000000
--- a/tests/init_command_integration_tests.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-use repos::commands::{Command, CommandContext, init::InitCommand};
-use repos::config::Config;
-use serial_test::serial;
-use std::fs;
-use tempfile::TempDir;
-
-/// Helper function to create a git repository in a directory
-fn create_git_repo(path: &std::path::Path) -> std::io::Result<()> {
-    // Initialize git repo
-    std::process::Command::new("git")
-        .arg("init")
-        .current_dir(path)
-        .output()?;
-
-    // Configure git (required for commits)
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(path)
-        .output()?;
-
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(path)
-        .output()?;
-
-    Ok(())
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_basic_creation() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("basic-config.yaml");
-
-    // Create a git repository so the command has something to discover
-    let repo_dir = temp_dir.path().join("test-repo");
-    fs::create_dir_all(&repo_dir).unwrap();
-    create_git_repo(&repo_dir).unwrap();
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    assert!(result.is_ok());
-    // Config file should be created if repositories are found
-    if result.is_ok() {
-        // Command succeeded, but file may not exist if no remote URL could be found
-        // This is acceptable behavior
-    }
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_overwrite_existing_file() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("existing-config.yaml");
-
-    // Create existing file
-    fs::write(&output_path, "existing content").unwrap();
-
-    // Create a git repository so the command has something to discover
-    let repo_dir = temp_dir.path().join("test-repo");
-    fs::create_dir_all(&repo_dir).unwrap();
-    create_git_repo(&repo_dir).unwrap();
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: true, // Should overwrite
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    // Change to temp directory
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    // Restore original directory
-    std::env::set_current_dir(original_dir).unwrap();
-
-    assert!(result.is_ok()); // Should succeed and overwrite
-
-    // The file content check is not reliable since it depends on whether
-    // a remote URL could be discovered
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_no_overwrite_existing_file() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("existing-config.yaml");
-
-    // Create existing file
-    fs::write(&output_path, "existing content").unwrap();
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false, // Should not overwrite
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should fail because file exists and overwrite is false
-    assert!(result.is_err());
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_with_git_repository() {
-    let temp_dir = TempDir::new().unwrap();
-    let repo_dir = temp_dir.path().join("test-repo");
-    let git_dir = repo_dir.join(".git");
-
-    // Create a mock git repository
-    fs::create_dir_all(&git_dir).unwrap();
-    create_git_repo(&repo_dir).unwrap();
-
-    // Create a mock git config to simulate a real repo
-    fs::write(
-        git_dir.join("config"),
-        "[core]\nrepositoryformatversion = 0",
-    )
-    .unwrap();
-
-    let output_path = temp_dir.path().join("discovered-config.yaml");
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    // Change to temp directory to discover the git repo
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let _result = command.execute(&context).await;
-
-    // Restore original directory
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // The command might fail because it can't get the remote URL, but should not panic
-    // We test that the discovery logic executes without crashing
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_supplement_with_duplicate_repository() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("config-with-duplicate.yaml");
-
-    // Create existing config with a repository
-    let existing_config = Config {
-        repositories: vec![repos::config::Repository::new(
-            "test-repo".to_string(),
-            "git@github.com:owner/test-repo.git".to_string(),
-        )],
-    };
-    existing_config
-        .save(&output_path.to_string_lossy())
-        .unwrap();
-
-    // Create a directory structure that would discover the same repo
-    let repo_dir = temp_dir.path().join("test-repo");
-    let git_dir = repo_dir.join(".git");
-    fs::create_dir_all(&git_dir).unwrap();
-    create_git_repo(&repo_dir).unwrap();
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: true, // Should supplement but skip duplicates
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    // Restore original directory
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed and maintain the existing repository
-    assert!(result.is_ok());
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_supplement_with_new_repository() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("config-with-supplement.yaml");
-
-    // Create existing config with one repository
-    let existing_config = Config {
-        repositories: vec![repos::config::Repository::new(
-            "existing-repo".to_string(),
-            "git@github.com:owner/existing-repo.git".to_string(),
-        )],
-    };
-    existing_config
-        .save(&output_path.to_string_lossy())
-        .unwrap();
-
-    // Create a different directory structure that would discover a new repo
-    let repo_dir = temp_dir.path().join("new-repo");
-    let git_dir = repo_dir.join(".git");
-    fs::create_dir_all(&git_dir).unwrap();
-    create_git_repo(&repo_dir).unwrap();
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: true, // Should supplement with new repo
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed and add the new repository
-    assert!(result.is_ok());
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_git_directory_edge_cases() {
-    let temp_dir = TempDir::new().unwrap();
-
-    // Create various directory structures to test edge cases
-    let nested_dir = temp_dir
-        .path()
-        .join("level1")
-        .join("level2")
-        .join("level3")
-        .join("too-deep");
-    let git_dir = nested_dir.join(".git");
-    fs::create_dir_all(&git_dir).unwrap();
-    create_git_repo(&nested_dir).unwrap();
-
-    // Create a .git file (not directory) to test that case
-    let repo_with_git_file = temp_dir.path().join("repo-with-git-file");
-    fs::create_dir_all(&repo_with_git_file).unwrap();
-    fs::write(repo_with_git_file.join(".git"), "gitdir: ../real-git-dir").unwrap();
-
-    let output_path = temp_dir.path().join("edge-case-config.yaml");
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    // Restore original directory
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed - edge cases are handled gracefully
-    assert!(result.is_ok());
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_empty_directory() {
-    let temp_dir = TempDir::new().unwrap();
-    let output_path = temp_dir.path().join("empty-config.yaml");
-
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    // Change to empty temp directory
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed even with no git repositories found
-    assert!(result.is_ok());
-
-    // File should NOT exist when no repositories are found (expected behavior)
-    assert!(!output_path.exists());
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_multiple_git_repositories() {
-    let temp_dir = TempDir::new().unwrap();
-
-    // Create multiple git repositories
-    let repo1_dir = temp_dir.path().join("repo1");
-    let repo2_dir = temp_dir.path().join("repo2");
-    let repo3_dir = temp_dir.path().join("nested").join("repo3");
-
-    for repo_dir in [&repo1_dir, &repo2_dir, &repo3_dir] {
-        fs::create_dir_all(repo_dir).unwrap();
-        fs::create_dir_all(repo_dir.join(".git")).unwrap();
-        create_git_repo(repo_dir).unwrap();
-    }
-
-    let output_path = temp_dir.path().join("multi-repo-config.yaml");
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed
-    assert!(result.is_ok());
-
-    // Note: File may not exist if git repositories don't have remote URLs
-    // which is common in test scenarios. This is expected behavior.
-}
-
-#[tokio::test]
-#[serial]
-async fn test_init_command_integration_flow() {
-    // Test complete initialization flow with realistic scenarios
-    let temp_dir = TempDir::new().unwrap();
-
-    // Create a realistic project structure
-    let backend_dir = temp_dir.path().join("my-project-backend");
-    let frontend_dir = temp_dir.path().join("my-project-frontend");
-    let docs_dir = temp_dir.path().join("docs");
-
-    // Only backend and frontend are git repos
-    for repo_dir in [&backend_dir, &frontend_dir] {
-        fs::create_dir_all(repo_dir).unwrap();
-        fs::create_dir_all(repo_dir.join(".git")).unwrap();
-        create_git_repo(repo_dir).unwrap();
-
-        // Add some realistic files
-        fs::write(repo_dir.join("README.md"), "# Project").unwrap();
-        fs::write(repo_dir.join(".gitignore"), "target/\nnode_modules/").unwrap();
-    }
-
-    // docs is not a git repo
-    fs::create_dir_all(&docs_dir).unwrap();
-    fs::write(docs_dir.join("README.md"), "# Documentation").unwrap();
-
-    let output_path = temp_dir.path().join("repos.yaml");
-    let command = InitCommand {
-        output: output_path.to_string_lossy().to_string(),
-        overwrite: false,
-        supplement: false,
-    };
-
-    let context = CommandContext {
-        config: Config::new(),
-        tag: vec![],
-        exclude_tag: vec![],
-        repos: None,
-        parallel: false,
-    };
-
-    let original_dir = std::env::current_dir().unwrap();
-    std::env::set_current_dir(temp_dir.path()).unwrap();
-
-    let result = command.execute(&context).await;
-
-    std::env::set_current_dir(original_dir).unwrap();
-
-    // Should succeed
-    assert!(result.is_ok());
-
-    // Note: Config file may not be created if repositories don't have remote URLs
-    // This is expected behavior in test scenarios
-}

From a33a47e3f0c5aaaa0862cfaa5d141dd90416a929 Mon Sep 17 00:00:00 2001
From: codcod <nikos@linux.com>
Date: Thu, 23 Oct 2025 23:38:17 +0200
Subject: [PATCH 4/4] chore: add mock health plugin

---
 plugins/repos-health/Cargo.toml  |  17 +++
 plugins/repos-health/README.md   |  39 +++++++
 plugins/repos-health/src/main.rs | 190 +++++++++++++++++++++++++++++++
 3 files changed, 246 insertions(+)
 create mode 100644 plugins/repos-health/Cargo.toml
 create mode 100644 plugins/repos-health/README.md
 create mode 100644 plugins/repos-health/src/main.rs

diff --git a/plugins/repos-health/Cargo.toml b/plugins/repos-health/Cargo.toml
new file mode 100644
index 0000000..a35879f
--- /dev/null
+++ b/plugins/repos-health/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "repos-health"
+version = "0.1.0"
+edition = "2024"
+
+[[bin]]
+name = "repos-health"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+chrono = { version = "0.4", features = ["serde"] }
+
+[dependencies.repos]
+path = "../.."
diff --git a/plugins/repos-health/README.md b/plugins/repos-health/README.md
new file mode 100644
index 0000000..c1d5f3c
--- /dev/null
+++ b/plugins/repos-health/README.md
@@ -0,0 +1,39 @@
+# repos-health
+
+A health check plugin for the repos tool that:
+
+- Scans each repository for `package.json` files
+- Checks for outdated npm dependencies using `npm outdated`
+- Updates dependencies using `npm update`
+- Creates git branches and commits changes
+- Opens pull requests for dependency updates
+
+## Requirements
+
+- Node.js and npm installed
+- Git repository with push permissions
+- GitHub token configured for PR creation
+
+## Usage
+
+```bash
+repos health
+```
+
+The plugin will:
+
+1. Load the default repos configuration
+2. Process each repository that contains a `package.json`
+3. Check for outdated dependencies
+4. Update dependencies if found
+5. Create a branch and commit changes
+6. Push the branch and open a PR
+
+## Output
+
+The plugin reports:
+
+- Repositories processed
+- Outdated packages found
+- Successful dependency updates
+- PR creation status
diff --git a/plugins/repos-health/src/main.rs b/plugins/repos-health/src/main.rs
new file mode 100644
index 0000000..9e12d4b
--- /dev/null
+++ b/plugins/repos-health/src/main.rs
@@ -0,0 +1,190 @@
+use anyhow::{Context, Result};
+use chrono::Utc;
+use repos::{Repository, load_default_config};
+use std::env;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+
+    // Handle --help
+    if args.len() > 1 && (args[1] == "--help" || args[1] == "-h") {
+        print_help();
+        return Ok(());
+    }
+
+    let config = load_default_config().context("load repos config")?;
+    let repos = config.repositories;
+    let mut processed = 0;
+    for repo in repos {
+        if let Err(e) = process_repo(&repo) {
+            eprintln!("health: {} skipped: {}", repo.name, e);
+        } else {
+            processed += 1;
+        }
+    }
+    println!("health: processed {} repositories", processed);
+    Ok(())
+}
+
+fn print_help() {
+    println!("repos-health - Check and update npm dependencies in repositories");
+    println!();
+    println!("USAGE:");
+    println!("    repos health [OPTIONS]");
+    println!();
+    println!("DESCRIPTION:");
+    println!("    Scans repositories for outdated npm packages and automatically");
+    println!("    updates them, creates branches, and commits changes.");
+    println!();
+    println!("    For each repository with a package.json file:");
+    println!("    1. Checks for outdated npm packages");
+    println!("    2. Updates packages if found");
+    println!("    3. Creates a branch and commits changes");
+    println!("    4. Pushes the branch to origin");
+    println!();
+    println!("    To create pull requests for the updated branches, use:");
+    println!("    repos pr --title 'chore: dependency updates' <repo-names>");
+    println!();
+    println!("REQUIREMENTS:");
+    println!("    - npm must be installed and available in PATH");
+    println!("    - Repositories must have package.json files");
+    println!("    - Git repositories must be properly initialized");
+    println!();
+    println!("OPTIONS:");
+    println!("    -h, --help    Print this help message");
+}
+
+fn process_repo(repo: &Repository) -> Result<()> {
+    let repo_path = repo.get_target_dir();
+    let path = Path::new(&repo_path);
+    let pkg = path.join("package.json");
+    if !pkg.exists() {
+        anyhow::bail!("no package.json");
+    }
+
+    let outdated = check_outdated(path)?;
+    if outdated.is_empty() {
+        println!("health: {} up-to-date", repo.name);
+        return Ok(());
+    }
+
+    println!(
+        "health: {} outdated packages: {}",
+        repo.name,
+        outdated.join(", ")
+    );
+    update_dependencies(path)?;
+    let changed = has_lockfile_changes(path)?;
+    if !changed {
+        println!("health: {} no lockfile changes after update", repo.name);
+        return Ok(());
+    }
+
+    let branch = format!("health/deps-{}", short_timestamp());
+    create_branch_and_commit(path, &branch, repo, &outdated)?;
+    push_branch(path, &branch)?;
+    println!(
+        "health: {} branch {} pushed - use 'repos pr' to create pull request",
+        repo.name, branch
+    );
+    Ok(())
+}
+
+fn check_outdated(repo_path: &Path) -> Result<Vec<String>> {
+    // Try npm outdated --json; if npm missing or error, return mock info
+    let output = Command::new("npm")
+        .arg("outdated")
+        .arg("--json")
+        .current_dir(repo_path)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .output();
+
+    match output {
+        Ok(o) if o.status.success() || o.status.code() == Some(1) => {
+            // npm outdated exits 1 if there are outdated deps
+            if o.stdout.is_empty() {
+                return Ok(vec![]);
+            }
+            let v: serde_json::Value =
+                serde_json::from_slice(&o.stdout).context("parse npm outdated json")?;
+            let mut deps = Vec::new();
+            if let serde_json::Value::Object(map) = v {
+                for (name, info) in map {
+                    if info.get("latest").is_some() {
+                        deps.push(name);
+                    }
+                }
+            }
+            Ok(deps)
+        }
+        Ok(_) => Ok(vec![]),
+        Err(_) => {
+            // Mock fallback when npm not present
+            Ok(vec![]) // keep empty for minimal intrusive behavior
+        }
+    }
+}
+
+fn update_dependencies(repo_path: &Path) -> Result<()> {
+    // Best effort upgrade; ignore failures to keep minimal
+    let _ = Command::new("npm")
+        .arg("update")
+        .current_dir(repo_path)
+        .status();
+    Ok(())
+}
+
+fn has_lockfile_changes(repo_path: &Path) -> Result<bool> {
+    // Check git diff for package-lock.json / yarn.lock / pnpm-lock.yaml
+    let patterns = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
+    let output = Command::new("git")
+        .arg("status")
+        .arg("--porcelain")
+        .current_dir(repo_path)
+        .output()
+        .context("git status")?;
+    let text = String::from_utf8_lossy(&output.stdout);
+    Ok(patterns.iter().any(|p| text.contains(p)))
+}
+
+fn create_branch_and_commit(
+    repo_path: &Path,
+    branch: &str,
+    repo: &Repository,
+    deps: &[String],
+) -> Result<()> {
+    run(repo_path, ["git", "checkout", "-b", branch])?;
+    run(repo_path, ["git", "add", "."])?; // minimal; could restrict
+    let msg = format!("chore(health): update dependencies ({})", deps.join(", "));
+    run(repo_path, ["git", "commit", "-m", &msg])?;
+    println!(
+        "health: {} committed dependency updates on {}",
+        repo.name, branch
+    );
+    Ok(())
+}
+
+fn push_branch(repo_path: &Path, branch: &str) -> Result<()> {
+    run(repo_path, ["git", "push", "-u", "origin", branch])?;
+    Ok(())
+}
+
+fn run<P: AsRef<Path>, const N: usize>(cwd: P, cmd: [&str; N]) -> Result<()> {
+    let status = Command::new(cmd[0])
+        .args(&cmd[1..])
+        .current_dir(cwd.as_ref())
+        .status()
+        .with_context(|| format!("exec {:?}", cmd))?;
+    if !status.success() {
+        anyhow::bail!("command {:?} failed", cmd);
+    }
+    Ok(())
+}
+
+fn short_timestamp() -> String {
+    let now = Utc::now();
+    format!("{}", now.format("%Y%m%d"))
+}