chore: add mock health plugin

Author: codcod

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 = "../.."

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

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"))
+}