use clap::{Parser, Subcommand};
use colored::control;
use colored::Colorize;
use limitless_cli::models::{CheckStatus, EnvironmentState, ProjectStack};
use limitless_cli::modules::{
achievements, arcade, auto_fix, config, diagnostics, fixes, planetary, progress, tui,
};
use limitless_cli::VERSION;
use std::io::{self, Write};
use std::path::Path;
use std::process::ExitCode;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
const REPO_ROOT: &str = ".";
const MANIFESTS: &[&str] = &[
"package.json",
"requirements.txt",
"pyproject.toml",
"setup.py",
"Cargo.toml",
"go.mod",
];
#[derive(Parser, Clone)]
#[command(
name = "limit",
bin_name = "limit",
about = "Limitless CLI — a beginner-friendly environment diagnostic tool",
version = env!("CARGO_PKG_VERSION"),
long_about = "Limitless CLI helps you detect, diagnose, and fix development environment issues.\nRun 'limit check' to scan your environment, or explore other commands in 'limit --help'."
)]
struct Args {
#[arg(short, long, global = true)]
fast: bool,
#[arg(short, long, global = true)]
verbose: bool,
#[arg(long, global = true)]
color: bool,
#[arg(long, global = true)]
no_color: bool,
#[command(subcommand)]
command: Option<Command>,
}
#[derive(Subcommand, Clone)]
enum Command {
Check,
Dev,
Fix {
#[arg(long)]
all: bool,
},
Orbit,
Arcade,
}
#[tokio::main]
async fn main() -> ExitCode {
let raw: Vec<String> = std::env::args().skip(1).collect();
if raw.len() == 1 && (raw[0] == "--help" || raw[0] == "-h") {
println!("{}", display_help());
return ExitCode::SUCCESS;
}
match route(Args::parse()).await {
Ok(0) => ExitCode::SUCCESS,
Ok(code) => ExitCode::from(code.clamp(0, 255) as u8),
Err(message) => {
println!();
eprintln!("{}{}", "error: ".red().bold(), screen_error(&message));
ExitCode::from(1)
}
}
}
const HELP_RULE: &str = "═══════════════════════════════════════════════════";
pub fn display_help() -> String {
format!(
r#"{rule}
🚀 LIMITLESS v{version} — Developer Environment CLI
{rule}
USAGE:
limit [COMMAND] [OPTIONS]
COMMANDS:
check, (default) Run complete environment audit
dev Audit + launch dev server (if healthy)
fix --all Auto-fix all detected issues
orbit Sci-fi themed diagnostic view
arcade Terminal typing game
--help Show this help message
OPTIONS:
--fast Skip animations (speed up output)
--verbose Show technical error details
--color Force colored output
--no-color Disable colors
--version Show version
EXAMPLES:
# Run a complete health check
$ limit
# Check health, then start dev server
$ limit dev
# Fix all issues automatically
$ limit fix --all
# View in sci-fi theme
$ limit orbit
# Play typing game
$ limit arcade
WHAT LIMITLESS DOES:
✓ Detects your project stack (Node.js, Python, Rust, Docker)
✓ Checks runtime versions match requirements
✓ Audits .env configuration files
✓ Detects blocked ports (ghost processes)
✓ Inspects dependency health
✓ Translates errors into plain English
✓ Suggests one-click fixes
WHEN TO USE:
- Starting a new project? → limit
- Getting "port already in use" error? → limit fix --all
- Want to understand your project setup? → limit orbit
- Procrastinating on real work? → limit arcade 😄
LEARN MORE:
GitHub: https://github.com/limitless-cli/limitless
Docs: https://limitless-cli.dev/docs
Issues: https://github.com/limitless-cli/limitless/issues
TROUBLESHOOTING:
Q: limit command not found
A: Make sure Limitless is installed:
$ cargo install limitless-cli
Then add ~/.cargo/bin to your PATH
Q: Permission denied errors
A: Some fixes (killing processes) need elevated privileges:
$ sudo limit fix --all
Q: My project is not detected
A: Ensure you have:
- Node: package.json
- Python: requirements.txt or setup.py
- Rust: Cargo.toml
- Run from your project root: $ cd my-project && limit
{rule}
"#,
rule = HELP_RULE,
version = VERSION
)
}
async fn route(args: Args) -> Result<i32, String> {
let settings = config::init_config()?;
let color_override = match (args.color, args.no_color) {
(true, false) => true,
(false, true) => false,
(true, true) => false,
(false, false) => settings.color_enabled,
};
control::set_override(color_override);
let mut progress = load_progress();
let effective = effective_args(&args, &settings);
let code = match args.command {
None | Some(Command::Check) => cmd_check(&effective, &mut progress)?,
Some(Command::Dev) => cmd_dev(&effective, &mut progress).await?,
Some(Command::Fix { all }) => cmd_fix(all, &effective, &mut progress).await?,
Some(Command::Orbit) => cmd_orbit(&effective, &mut progress)?,
Some(Command::Arcade) => cmd_arcade(&effective, &mut progress)?,
};
let newly_unlocked = progress.check_unlocked();
if !newly_unlocked.is_empty() {
print_new_badges(&newly_unlocked);
}
if progress.stats != achievements::ArcadeStats::default() || !newly_unlocked.is_empty() {
save_progress(&progress)?;
config::save_stats(&progress.stats)?;
}
Ok(code)
}
fn effective_args(args: &Args, settings: &config::LimitlessConfig) -> Args {
Args {
fast: args.fast || !settings.animation_enabled,
verbose: args.verbose || settings.verbose_mode,
color: args.color,
no_color: args.no_color,
command: args.command.clone(),
}
}
fn cmd_check(args: &Args, progress: &mut achievements::AchievementProgress) -> Result<i32, String> {
ensure_project()?;
if args.verbose {
if let Some(manifest) = find_manifest() {
println!(" {} {}", "Manifest:".bold(), manifest);
}
}
let started = Instant::now();
let cached = if args.fast {
config::get_cached_diagnostics()
} else {
None
};
let reused = cached.is_some();
let state = cached.unwrap_or_else(|| scan_with_progress(!args.fast));
let elapsed_ms = started.elapsed().as_millis() as u32;
print!("{}", tui::render_dashboard(&state));
println!();
if reused {
println!(
" {}",
"cached snapshot (≤5m old; run without --fast to rescan)".dimmed()
);
}
if state.ready_for_dev() {
println!(
"{}",
" ✓ Environment is ready — happy coding!".green().bold()
);
} else {
println!(
"{}",
" ! Review the notes above before continuing. (Run `limit fix --all` to fix issues.)"
.yellow()
.bold()
);
}
if !reused {
progress.stats.record_diagnostic(elapsed_ms);
}
record_health(&mut progress.stats, &state);
if args.verbose {
print_diagnostic_details(&state);
}
Ok(exit_code_for(&state))
}
async fn cmd_dev(
args: &Args,
progress: &mut achievements::AchievementProgress,
) -> Result<i32, String> {
ensure_project()?;
let started = Instant::now();
let state = scan_with_progress(!args.fast);
let elapsed_ms = started.elapsed().as_millis() as u32;
progress.stats.record_diagnostic(elapsed_ms);
record_health(&mut progress.stats, &state);
if state.health_score.percentage == 100 {
println!(
" ✓ Environment is 100% healthy — {}",
"launching the dev server…".green().bold()
);
if args.verbose {
println!(" {} {}", "Stack:".bold(), state.detected_stack.label());
}
launch_dev_server(&state.detected_stack)?;
return Ok(0);
}
print!("{}", tui::render_dashboard(&state));
println!();
suggest_fixes(&state);
Ok(exit_code_for(&state))
}
async fn cmd_fix(
all: bool,
args: &Args,
progress: &mut achievements::AchievementProgress,
) -> Result<i32, String> {
ensure_project()?;
let started = Instant::now();
let state = scan_with_progress(!args.fast);
let elapsed_ms = started.elapsed().as_millis() as u32;
progress.stats.record_diagnostic(elapsed_ms);
record_health(&mut progress.stats, &state);
if all {
let issues = identify_fixable_issues(&state);
println!();
println!(
" Found {} fixable issue{s}. Applying the auto-fix suite…",
issues.len(),
s = if issues.len() == 1 { "" } else { "s" }
);
let report = auto_fix::run_auto_fix_all(&state, REPO_ROOT).await;
for _ in 0..report.fixes_applied {
progress.stats.record_fix();
}
Ok(if report.issues_remaining.is_empty() { 0 } else { 1 })
} else {
fixes::run_fix(false).await;
Ok(exit_code_for(&state))
}
}
fn cmd_orbit(args: &Args, progress: &mut achievements::AchievementProgress) -> Result<i32, String> {
ensure_project()?;
let started = Instant::now();
let state = scan_with_progress(!args.fast);
let elapsed_ms = started.elapsed().as_millis() as u32;
progress.stats.record_diagnostic(elapsed_ms);
record_health(&mut progress.stats, &state);
print!("{}", planetary::render_planetary_diagnostics(&state.diagnostics));
println!();
if args.verbose {
print_diagnostic_details(&state);
}
Ok(exit_code_for(&state))
}
fn cmd_arcade(args: &Args, progress: &mut achievements::AchievementProgress) -> Result<i32, String> {
let result = arcade::run_typing_game();
if args.verbose {
println!(
" {} {} pts · {} wpm · {} snippets",
"Result:".bold(),
result.score,
result.wpm,
result.snippets_completed
);
}
show_high_scores();
progress.stats.record_arcade_game(result.score.max(0) as u32);
Ok(0)
}
fn find_manifest_at(root: &Path) -> Option<&'static str> {
MANIFESTS
.iter()
.copied()
.find(|manifest| root.join(manifest).is_file())
}
fn find_manifest() -> Option<&'static str> {
find_manifest_at(Path::new(REPO_ROOT))
}
fn ensure_project_at(root: &Path) -> Result<(), String> {
if !root.is_dir() {
return Err("Run `limit` from your project root.".to_string());
}
if find_manifest_at(root).is_none() {
return Err(
"No package.json/requirements.txt/Cargo.toml found — run `limit` from your project root."
.to_string(),
);
}
Ok(())
}
fn ensure_project() -> Result<(), String> {
ensure_project_at(Path::new(REPO_ROOT))
}
fn scan_with_progress(animate: bool) -> EnvironmentState {
let is_tty = crossterm::tty::IsTty::is_tty(&io::stdout());
let state = if !animate || !is_tty {
diagnostics::run_full_diagnostics(REPO_ROOT)
} else {
let snapshot = Arc::new(Mutex::new(None));
let done = Arc::new(AtomicBool::new(false));
let (slot, flag) = (Arc::clone(&snapshot), Arc::clone(&done));
let handle = std::thread::spawn(move || {
let state = diagnostics::run_full_diagnostics(REPO_ROOT);
*slot.lock().expect("snapshot slot") = Some(state);
flag.store(true, Ordering::SeqCst);
});
let mut out = io::stdout();
let mut frame = 0usize;
while !done.load(Ordering::SeqCst) {
let line = progress::spinner_line("Scanning your environment", frame);
let _ = out.write_all(line.as_bytes());
let _ = out.flush();
frame += 1;
std::thread::sleep(Duration::from_millis(80));
}
let _ = handle.join();
let _ = out.write_all(b"\r\x1b[2K");
let _ = out.flush();
let state = snapshot
.lock()
.expect("snapshot slot")
.take()
.expect("scan finished before snapshot was taken");
state
};
let _ = config::cache_diagnostics(&state);
state
}
fn identify_fixable_issues(state: &EnvironmentState) -> Vec<String> {
auto_fix::build_auto_fixes(state, REPO_ROOT, true)
.into_iter()
.map(|fix| fix.name)
.collect()
}
fn suggest_fixes(state: &EnvironmentState) {
let suggestions = fixes::recommended_fixes(state, REPO_ROOT);
if suggestions.is_empty() {
println!(
" {} No auto-fixes available — review the manual notes above.",
"Hint:".cyan().bold()
);
return;
}
println!(" {} Suggested fixes:", "🛠️".bold());
for (i, fix) in suggestions.iter().enumerate() {
let tag = if fix.requires_approval {
"approval required".yellow()
} else {
"safe".green()
};
println!(" {}. {} — {tag}", i + 1, fix.name);
}
println!();
println!(
" {} Run `limit fix --all` to apply everything automatically.",
"Next:".cyan().bold()
);
}
fn dev_command(stack: &ProjectStack) -> Option<(String, Vec<String>)> {
match stack {
ProjectStack::Node { package_manager, .. } => {
let program = match package_manager.as_str() {
"yarn" => "yarn",
"pnpm" => "pnpm",
_ => "npm",
};
Some((
program.to_string(),
if program == "npm" {
vec!["run".to_string(), "dev".to_string()]
} else {
vec!["dev".to_string()]
},
))
}
ProjectStack::Python { .. } => {
let root = Path::new(REPO_ROOT);
if root.join("manage.py").is_file() {
Some((
"python".to_string(),
vec!["manage.py".to_string(), "runserver".to_string()],
))
} else if root.join("main.py").is_file() || root.join("app.py").is_file() {
Some((
"python".to_string(),
vec![
"-m".to_string(),
"uvicorn".to_string(),
"main:app".to_string(),
"--reload".to_string(),
],
))
} else {
Some((
"python".to_string(),
vec!["-m".to_string(), "flask".to_string(), "run".to_string()],
))
}
}
ProjectStack::Rust { .. } => {
Some(("cargo".to_string(), vec!["run".to_string()]))
}
ProjectStack::Go { .. } => {
Some(("go".to_string(), vec!["run".to_string(), ".".to_string()]))
}
ProjectStack::Java { .. } => {
let root = Path::new(REPO_ROOT);
if root.join("mvnw").is_file() || root.join("pom.xml").is_file() {
Some(("mvn".to_string(), vec!["spring-boot:run".to_string()]))
} else {
Some(("./gradlew".to_string(), vec!["bootRun".to_string()]))
}
}
ProjectStack::Docker => Some((
"docker".to_string(),
vec!["compose".to_string(), "up".to_string()],
)),
ProjectStack::Unknown => None,
}
}
fn launch_dev_server(stack: &ProjectStack) -> Result<(), String> {
let (program, args) = dev_command(stack).ok_or_else(|| {
format!(
"No dev-server recipe for {} — start it manually.",
stack.label()
)
})?;
let shown = format!("{program} {}", args.join(" "));
println!(
"{}",
format!("🚀 {shown}").bold().cyan()
);
println!(
"{}",
" Press Ctrl+C to stop the server.".dimmed()
);
let status = std::process::Command::new(&program)
.args(&args)
.status()
.map_err(|err| {
format!(
"could not run `{shown}`: {err}. Install the runtime, or start the dev server yourself."
)
})?;
if status.success() {
Ok(())
} else {
Err(format!("`{shown}` exited with {status}."))
}
}
fn show_high_scores() {
let board = arcade::ArcadeScoreboard::load(&arcade::score_file_path());
println!();
print!("{}", arcade::render_scoreboard(&board));
}
fn exit_code_for(state: &EnvironmentState) -> i32 {
if state.health_score.failed == 0 {
0
} else {
1
}
}
fn record_health(stats: &mut achievements::ArcadeStats, state: &EnvironmentState) {
if state.health_score.failed == 0 {
stats.record_perfect_health();
} else {
stats.reset_perfect_health();
}
}
fn load_progress() -> achievements::AchievementProgress {
achievements::load_progress_migrated()
}
fn save_progress(progress: &achievements::AchievementProgress) -> Result<(), String> {
if let Some(path) = achievements::progress_file_path() {
progress
.save(&path)
.map_err(|err| format!("could not save badge progress: {err}"))?;
}
Ok(())
}
fn print_new_badges(names: &[String]) {
for name in names {
if let Some(badge) = achievements::BADGES.iter().find(|b| b.name == *name) {
println!();
println!("{}", achievements::render_badge_popup(badge));
}
}
}
fn print_diagnostic_details(state: &EnvironmentState) {
println!();
println!(
" {} ({})",
"Technical details".dimmed().bold(),
state.diagnostics.len()
);
for diagnostic in &state.diagnostics {
let icon = match diagnostic.status {
CheckStatus::Pass => "✓".green(),
CheckStatus::Warn => "⚠".yellow(),
CheckStatus::Fail => "✖".red(),
};
println!(" {icon} {}", diagnostic.check_name.dimmed());
println!(" {}", diagnostic.message.dimmed());
if let Some(step) = &diagnostic.remediation {
println!(
" {} {}",
"fix:".cyan().dimmed(),
step.dimmed()
);
}
}
}
fn screen_error(raw: &str) -> String {
let lower = raw.to_lowercase();
if lower.contains("permission denied")
|| lower.contains("access is denied")
|| lower.contains("eacces")
|| lower.contains("access denied")
{
return format!(
"{raw}\n Hint: Run with sudo — process kills and file writes may need \
elevated permissions."
);
}
if lower.contains("timed out")
|| lower.contains("connection")
|| lower.contains("resolve")
|| lower.contains("network")
|| lower.contains("offline")
{
return format!("{raw}\n Hint: Check your internet connection.");
}
raw.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
use limitless_cli::models::{DiagnosticResult, HealthScore};
use std::fs;
#[test]
fn effective_args_applies_config_defaults_when_flags_absent() {
let parsed = Args {
fast: false,
verbose: false,
color: false,
no_color: false,
command: None,
};
let quiet = config::LimitlessConfig {
animation_enabled: false,
verbose_mode: true,
..config::LimitlessConfig::default()
};
let effective = effective_args(&parsed, &quiet);
assert!(effective.fast);
assert!(effective.verbose);
}
#[test]
fn effective_args_cli_flags_always_win() {
let parsed = Args {
fast: true,
verbose: true,
color: false,
no_color: false,
command: None,
};
let loud = config::LimitlessConfig {
animation_enabled: true,
verbose_mode: false,
color_enabled: true,
..config::LimitlessConfig::default()
};
let effective = effective_args(&parsed, &loud);
assert!(effective.fast);
assert!(effective.verbose);
}
#[test]
fn display_help_lists_every_command_and_option() {
let help = display_help();
for section in [
"USAGE:",
"COMMANDS:",
"OPTIONS:",
"EXAMPLES:",
"WHAT LIMITLESS DOES:",
"WHEN TO USE:",
"LEARN MORE:",
"TROUBLESHOOTING:",
] {
assert!(help.contains(section), "missing section: {section}");
}
for entry in [
"check, (default)",
"dev",
"fix --all",
"orbit",
"arcade",
"--fast",
"--verbose",
"--color",
"--no-color",
"--version",
] {
assert!(help.contains(entry), "missing entry: {entry}");
}
}
#[test]
fn display_help_has_boxed_header_and_footer() {
let help = display_help();
assert!(help.starts_with(HELP_RULE));
assert!(help.contains(&format!("🚀 LIMITLESS v{VERSION} — Developer Environment CLI")));
assert!(help.trim_end().ends_with(HELP_RULE));
assert_eq!(help.matches(HELP_RULE).count(), 3);
}
#[test]
fn display_help_includes_troubleshooting_faq() {
let help = display_help();
for faq in ["limit command not found", "Permission denied errors", "My project is not detected"] {
assert!(help.contains(faq), "missing FAQ: {faq}");
}
assert!(help.contains("$ cargo install limitless-cli"));
assert!(help.contains("$ sudo limit fix --all"));
assert!(help.contains("$ cd my-project && limit"));
}
fn temp_project(tag: &str, files: &[&str]) -> std::path::PathBuf {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let dir = std::env::temp_dir().join(format!(
"limitless_main_{}_{}_{}",
tag,
std::process::id(),
nanos
));
fs::create_dir_all(&dir).unwrap();
for file in files {
fs::write(dir.join(file), "x").unwrap();
}
dir
}
#[test]
fn dev_command_for_node_defaults_to_npm_run_dev() {
let stack = ProjectStack::Node {
version: "22.0.0".into(),
package_manager: "npm".into(),
};
assert_eq!(
dev_command(&stack),
Some(("npm".to_string(), vec!["run".to_string(), "dev".to_string()]))
);
}
#[test]
fn dev_command_honors_detected_package_manager() {
let yarn = ProjectStack::Node {
version: "22.0.0".into(),
package_manager: "yarn".into(),
};
let pnpm = ProjectStack::Node {
version: "22.0.0".into(),
package_manager: "pnpm".into(),
};
assert_eq!(
dev_command(&yarn),
Some(("yarn".to_string(), vec!["dev".to_string()]))
);
assert_eq!(
dev_command(&pnpm),
Some(("pnpm".to_string(), vec!["dev".to_string()]))
);
}
#[test]
fn dev_command_for_python_rust_and_docker() {
assert_eq!(
dev_command(&ProjectStack::Python { version: "3.12".into() }),
Some((
"python".to_string(),
vec!["-m".to_string(), "flask".to_string(), "run".to_string()]
))
);
assert_eq!(
dev_command(&ProjectStack::Rust { version: "1.80".into() }),
Some(("cargo".to_string(), vec!["run".to_string()]))
);
assert_eq!(
dev_command(&ProjectStack::Docker),
Some((
"docker".to_string(),
vec!["compose".to_string(), "up".to_string()]
))
);
}
#[test]
fn dev_command_for_unknown_stack_has_no_recipe() {
assert_eq!(dev_command(&ProjectStack::Unknown), None);
}
#[test]
fn find_manifest_recognizes_each_stack_marker() {
let node = temp_project("manifest_node", &["package.json"]);
assert_eq!(find_manifest_at(&node), Some("package.json"));
let pyproject = temp_project("manifest_py", &["pyproject.toml"]);
assert_eq!(find_manifest_at(&pyproject), Some("pyproject.toml"));
let requirements = temp_project("manifest_reqs", &["requirements.txt"]);
assert_eq!(find_manifest_at(&requirements), Some("requirements.txt"));
let rust = temp_project("manifest_rust", &["Cargo.toml"]);
assert_eq!(find_manifest_at(&rust), Some("Cargo.toml"));
}
#[test]
fn find_manifest_none_for_empty_directory() {
let empty = temp_project("manifest_empty", &[]);
assert!(find_manifest_at(&empty).is_none());
}
#[test]
fn ensure_project_errors_are_beginner_friendly() {
let empty = temp_project("ensure_empty", &[]);
let err = ensure_project_at(&empty).unwrap_err();
assert!(err.contains("project root"));
assert!(err.contains("package.json"));
assert!(err.contains("requirements.txt"));
assert!(err.contains("Cargo.toml"));
}
#[test]
fn screen_error_adds_sudo_hint_for_permission_errors() {
let msg = screen_error("Permission denied while writing .env");
assert!(msg.contains("sudo"));
assert!(msg.contains("permission"));
}
#[test]
fn screen_error_adds_internet_hint_for_network_errors() {
let msg = screen_error("Connection timed out resolving registry.npmjs.org");
assert!(msg.contains("internet connection"));
}
#[test]
fn screen_error_passes_through_other_errors() {
let raw = "something completely unrelated";
assert_eq!(screen_error(raw), raw);
}
fn fake_state(statuses: &[CheckStatus]) -> EnvironmentState {
let diagnostics: Vec<DiagnosticResult> = statuses
.iter()
.enumerate()
.map(|(i, status)| {
DiagnosticResult::new(format!("Check {i}"), *status, "ok")
})
.collect();
EnvironmentState {
detected_stack: ProjectStack::Node {
version: "22.0.0".into(),
package_manager: "npm".into(),
},
runtime_version: None,
env_file_exists: false,
env_example_exists: true,
dependencies_healthy: true,
blocked_ports: vec![],
health_score: HealthScore::from_results(&diagnostics),
diagnostics,
}
}
#[test]
fn exit_code_mirrors_failed_diagnostics() {
assert_eq!(exit_code_for(&fake_state(&[CheckStatus::Pass])), 0);
assert_eq!(
exit_code_for(&fake_state(&[CheckStatus::Pass, CheckStatus::Warn])),
0
);
assert_eq!(
exit_code_for(&fake_state(&[CheckStatus::Pass, CheckStatus::Fail])),
1
);
}
#[test]
fn identify_fixable_issues_lists_ghost_and_env_fixes() {
let mut state = fake_state(&[CheckStatus::Fail]);
state.blocked_ports = vec![(3000, 1234)];
let issues = identify_fixable_issues(&state);
let joined = issues.join("\n");
assert!(joined.contains("Kill"), "{joined}");
assert!(joined.contains("Copy .env.example"), "{joined}");
}
#[test]
fn perfect_health_streak_tracks_failed_checks() {
use achievements::ArcadeStats;
let mut stats = ArcadeStats::default();
record_health(&mut stats, &fake_state(&[CheckStatus::Pass]));
assert_eq!(stats.perfect_health_streak, 1);
record_health(&mut stats, &fake_state(&[CheckStatus::Fail]));
assert_eq!(stats.perfect_health_streak, 0);
}
}