use colored::Colorize;
use std::fs;
use std::path::Path;
use std::process::Command;
use crate::models::{CheckStatus, ProjectStack};
const NODE_MARKERS: &[&str] = &["package.json"];
const PYTHON_MARKERS: &[&str] = &["requirements.txt", "pyproject.toml", "setup.py"];
const RUST_MARKERS: &[&str] = &["Cargo.toml"];
const GO_MARKERS: &[&str] = &["go.mod"];
const JAVA_MARKERS: &[&str] = &["pom.xml", "build.gradle", "build.gradle.kts"];
const DOCKER_MARKERS: &[&str] = &["docker-compose.yml", "docker-compose.yaml", "Dockerfile"];
pub fn detect_stack(repo_path: &str) -> ProjectStack {
let root = Path::new(repo_path);
if !root.is_dir() {
eprintln!(
"{} {repo_path} is not a readable directory",
"WARN:".yellow().bold()
);
return ProjectStack::Unknown;
}
let mut present: Vec<StackKind> = Vec::new();
for kind in [
StackKind::Node,
StackKind::Python,
StackKind::Rust,
StackKind::Go,
StackKind::Java,
StackKind::Docker,
] {
if kind.has_marker(root) {
present.push(kind);
}
}
if present.is_empty() {
eprintln!(
"{} No recognized project marker found in {repo_path}",
"WARN:".yellow().bold()
);
eprintln!(
" Hint: run `limit check` from your project root \
(where package.json / Cargo.toml / requirements.txt lives)."
);
return ProjectStack::Unknown;
}
for kind in &present[1..] {
eprintln!(
"{} Detected secondary stack: {} (primary: {})",
"WARN:".yellow().bold(),
kind.label(),
present[0].label()
);
}
match present[0] {
StackKind::Node => build_node_stack(root),
StackKind::Python => build_python_stack(root),
StackKind::Rust => build_rust_stack(root),
StackKind::Go => ProjectStack::Go { version: String::new() },
StackKind::Java => ProjectStack::Java { version: String::new() },
StackKind::Docker => ProjectStack::Docker,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum StackKind {
Node,
Python,
Rust,
Go,
Java,
Docker,
}
impl StackKind {
fn markers(self) -> &'static [&'static str] {
match self {
StackKind::Node => NODE_MARKERS,
StackKind::Python => PYTHON_MARKERS,
StackKind::Rust => RUST_MARKERS,
StackKind::Go => GO_MARKERS,
StackKind::Java => JAVA_MARKERS,
StackKind::Docker => DOCKER_MARKERS,
}
}
fn has_marker(self, root: &Path) -> bool {
self.markers().iter().any(|m| root.join(m).is_file())
}
fn label(self) -> &'static str {
match self {
StackKind::Node => "Node.js",
StackKind::Python => "Python",
StackKind::Rust => "Rust",
StackKind::Go => "Go",
StackKind::Java => "Java",
StackKind::Docker => "Docker",
}
}
}
fn build_node_stack(root: &Path) -> ProjectStack {
let version = detect_node_version(root).unwrap_or_default();
let package_manager = detect_package_manager(root);
ProjectStack::Node {
version,
package_manager,
}
}
fn detect_node_version(root: &Path) -> Option<String> {
if let Some(raw) = read_first_non_empty(root, &[".nvmrc", ".node-version"]) {
return extract_version(&raw);
}
let pkg = root.join("package.json");
let content = read_clean(pkg).ok()?;
let json: serde_json::Value = serde_json::from_str(&content).ok()?;
json.pointer("/engines/node")
.and_then(|v| v.as_str())
.and_then(extract_version)
}
fn detect_package_manager(root: &Path) -> String {
if root.join("pnpm-lock.yaml").is_file() || root.join("pnpm-workspace.yaml").is_file() {
"pnpm".to_string()
} else if root.join("yarn.lock").is_file() {
"yarn".to_string()
} else if root.join("bun.lockb").is_file() || root.join("bun.lock").is_file() {
"bun".to_string()
} else {
"npm".to_string()
}
}
fn build_python_stack(root: &Path) -> ProjectStack {
let version = detect_python_version(root).unwrap_or_default();
ProjectStack::Python { version }
}
fn detect_python_version(root: &Path) -> Option<String> {
if let Some(raw) = read_first_non_empty(root, &[".python-version"]) {
return extract_version(&raw);
}
let pyproject = root.join("pyproject.toml");
if let Ok(content) = read_clean(&pyproject) {
if let Some(spec) = python_version_from_pyproject(&content) {
return extract_version(&spec);
}
}
for cfg in [
".venv/pyvenv.cfg",
"venv/pyvenv.cfg",
"virtualenv/pyvenv.cfg",
] {
if let Ok(content) = read_clean(root.join(cfg)) {
if let Some(version) = python_version_from_pyvenv(&content) {
return Some(version);
}
}
}
None
}
pub(crate) fn python_version_from_pyproject(content: &str) -> Option<String> {
let mut section = String::new();
for line in content.lines() {
let trimmed = line.trim();
if trimmed.starts_with('[') {
section = trimmed.to_string();
continue;
}
match section.as_str() {
"[project]" => {
if let Some(spec) = parse_key_value(trimmed, "requires-python") {
if !spec.is_empty() {
return Some(spec);
}
}
}
"[tool.poetry.dependencies]" => {
if let Some(spec) = parse_key_value(trimmed, "python") {
if !spec.is_empty() {
return Some(spec);
}
}
}
_ => {}
}
}
None
}
fn python_version_from_pyvenv(content: &str) -> Option<String> {
for line in content.lines() {
let trimmed = line.trim();
if trimmed.starts_with("version") {
if let Some(spec) = parse_key_value(trimmed, "version") {
if !spec.is_empty() {
return Some(spec);
}
}
}
}
None
}
pub(crate) fn parse_key_value(line: &str, key: &str) -> Option<String> {
let candidate = line.trim().strip_prefix(key)?;
if candidate.is_empty() || candidate.starts_with('-') {
return None;
}
let spec = candidate
.trim()
.trim_start_matches('=')
.trim()
.trim_matches('"')
.trim_matches('\'')
.trim();
if spec.is_empty() {
None
} else {
Some(spec.to_string())
}
}
fn build_rust_stack(root: &Path) -> ProjectStack {
let version = detect_rust_version(root).unwrap_or_default();
ProjectStack::Rust { version }
}
fn detect_rust_version(root: &Path) -> Option<String> {
let toolchain = root.join("rust-toolchain");
if toolchain.is_file() {
if let Ok(content) = read_clean(&toolchain) {
let trimmed = content.trim();
if !trimmed.is_empty() {
return Some(trimmed.to_string());
}
}
}
let toolchain_toml = root.join("rust-toolchain.toml");
if toolchain_toml.is_file() {
if let Ok(content) = read_clean(&toolchain_toml) {
let mut in_toolchain = false;
for line in content.lines() {
let trimmed = line.trim();
if trimmed.starts_with('[') {
in_toolchain = trimmed == "[toolchain]";
continue;
}
if in_toolchain {
if let Some(channel) = parse_key_value(trimmed, "channel") {
if !channel.is_empty() {
return Some(channel);
}
}
}
}
}
}
let cargo = root.join("Cargo.toml");
if cargo.is_file() {
if let Ok(content) = read_clean(&cargo) {
let mut in_package = false;
for line in content.lines() {
let trimmed = line.trim();
if trimmed.starts_with('[') {
in_package = trimmed == "[package]";
continue;
}
if in_package {
if let Some(version) = parse_key_value(trimmed, "rust-version") {
if !version.is_empty() {
return Some(version);
}
}
}
}
}
}
None
}
fn read_first_non_empty(root: &Path, names: &[&str]) -> Option<String> {
for name in names {
let path = root.join(name);
if path.is_file() {
if let Ok(content) = read_clean(&path) {
let trimmed = content.trim();
if !trimmed.is_empty() {
return Some(trimmed.to_string());
}
}
}
}
None
}
pub(crate) fn read_clean(path: impl AsRef<Path>) -> std::io::Result<String> {
let bytes = fs::read(path)?;
let bytes = bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(&bytes);
Ok(String::from_utf8_lossy(bytes).into_owned())
}
pub(crate) fn extract_version(raw: &str) -> Option<String> {
for token in raw.split(|c: char| c.is_whitespace() || c == ',') {
let cleaned = token.trim_start_matches(['>', '<', '=', '^', '~', 'v', 'V', ' ', '\t']);
if cleaned.chars().any(|c| c.is_ascii_digit()) {
return Some(cleaned.to_string());
}
}
let trimmed = raw.trim();
if !trimmed.is_empty() {
Some(trimmed.to_string())
} else {
None
}
}
pub fn run_check() {
println!("{}", "=== Environment Check ===".bold().cyan());
println!();
detect_os();
detect_shell();
detect_language_tools();
println!();
println!(" {} {}", "Project:".bold(), detect_stack(".").label());
print_runtime_validation();
print_env_audit();
print_dep_audit();
println!();
println!("{}", "Check complete!".green().bold());
}
fn print_runtime_validation() {
use crate::modules::runtime_validator::validate_installed_runtime;
if let Some(report) = validate_installed_runtime(".") {
println!();
println!(
" {} {}",
report.status_label(),
format!("Runtime: {}", report.message).dimmed()
);
if let Some(remediation) = report.remediation {
println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
}
}
}
fn print_env_audit() {
use crate::modules::env_auditor::audit_env_files;
let result = audit_env_files(".");
let label = match result.status {
CheckStatus::Pass => "PASS".green().bold(),
CheckStatus::Warn => "WARN".yellow().bold(),
CheckStatus::Fail => "FAIL".red().bold(),
};
println!(
" {} {}",
label,
format!("Env Audit: {}", result.message).dimmed()
);
if let Some(remediation) = result.remediation {
println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
}
}
fn print_dep_audit() {
use crate::modules::dependency_checker::check_dependencies;
let stack = detect_stack(".");
let result = check_dependencies(".", &stack);
let label = match result.status {
CheckStatus::Pass => "PASS".green().bold(),
CheckStatus::Warn => "WARN".yellow().bold(),
CheckStatus::Fail => "FAIL".red().bold(),
};
println!(
" {} {}",
label,
format!("Dependencies: {}", result.message).dimmed()
);
if let Some(remediation) = result.remediation {
println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
}
}
fn detect_os() {
let os = std::env::consts::OS;
let arch = std::env::consts::ARCH;
println!(" {} {} / {}", "OS:".bold(), os, arch);
}
fn detect_shell() {
if cfg!(windows) {
if let Ok(shell) = std::env::var("COMSPEC") {
println!(" {} {}", "Shell:".bold(), shell);
}
} else if let Ok(shell) = std::env::var("SHELL") {
println!(" {} {}", "Shell:".bold(), shell);
}
}
fn detect_language_tools() {
let tools = vec![
("rustc", "--version"),
("cargo", "--version"),
("node", "--version"),
("npm", "--version"),
("python", "--version"),
("go", "version"),
("java", "-version"),
];
for (cmd, flag) in tools {
match Command::new(cmd).arg(flag).output() {
Ok(output) => {
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
let version = if stdout.trim().is_empty() {
stderr.trim().lines().next().unwrap_or("unknown")
} else {
stdout.trim().lines().next().unwrap_or("unknown")
};
println!(
" {} {} {}",
"Found:".green(),
format!("{}:", cmd).bold(),
version
);
}
Err(_) => {
println!(
" {} {} {}",
"Missing:".yellow(),
cmd,
"(not installed)".dimmed()
);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::ProjectStack;
use std::fs;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
struct TempProject {
path: PathBuf,
}
impl TempProject {
fn new(label: &str) -> Self {
let stamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("system clock")
.as_nanos();
let path = std::env::temp_dir()
.join(format!("limitless_{label}_{}_{stamp}", std::process::id()));
fs::create_dir_all(&path).expect("create temp project");
TempProject { path }
}
fn path(&self) -> &Path {
&self.path
}
fn write(self, relative: &str, content: &str) -> Self {
let full = self.path.join(relative);
if let Some(parent) = full.parent() {
fs::create_dir_all(parent).expect("create parent dirs");
}
fs::write(full, content).expect("write fixture file");
self
}
}
impl Drop for TempProject {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.path);
}
}
fn as_str(project: &TempProject) -> &str {
project.path().to_str().expect("utf8 path")
}
#[test]
fn detects_node_with_version_from_engines() {
let p = TempProject::new("node_engines").write(
"package.json",
r#"{ "name": "demo", "engines": { "node": ">=18.12.0 <20" } }"#,
);
match detect_stack(as_str(&p)) {
ProjectStack::Node {
version,
package_manager,
} => {
assert_eq!(version, "18.12.0");
assert_eq!(package_manager, "npm");
}
other => panic!("expected Node, got {:?}", other),
}
}
#[test]
fn detects_node_version_from_nvmrc() {
let p = TempProject::new("node_nvmrc")
.write("package.json", "{}")
.write(".nvmrc", "20.11.1\n");
match detect_stack(as_str(&p)) {
ProjectStack::Node {
version,
package_manager,
} => {
assert_eq!(version, "20.11.1");
assert_eq!(package_manager, "npm");
}
other => panic!("expected Node, got {:?}", other),
}
}
#[test]
fn detects_node_package_managers_from_lockfiles() {
let p = TempProject::new("node_pnpm")
.write("package.json", "{}")
.write("pnpm-lock.yaml", "lockfileVersion: '9.0'");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Node {
package_manager: ref m,
..
} if m == "pnpm"
));
let p = TempProject::new("node_yarn")
.write("package.json", "{}")
.write("yarn.lock", "# yarn lockfile");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Node {
package_manager: ref m,
..
} if m == "yarn"
));
}
#[test]
fn node_without_version_uses_npm_default() {
let p = TempProject::new("node_noversion").write("package.json", "{}");
match detect_stack(as_str(&p)) {
ProjectStack::Node {
version,
package_manager,
} => {
assert!(version.is_empty());
assert_eq!(package_manager, "npm");
}
other => panic!("expected Node, got {:?}", other),
}
}
#[test]
fn detects_python_from_requirements_txt() {
let p = TempProject::new("python_reqs").write("requirements.txt", "flask==3.0.0\n");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Python { .. }
));
}
#[test]
fn detects_python_version_from_python_version_file() {
let p = TempProject::new("python_verfile")
.write("requirements.txt", "")
.write(".python-version", "3.12.1\n");
match detect_stack(as_str(&p)) {
ProjectStack::Python { version } => assert_eq!(version, "3.12.1"),
other => panic!("expected Python, got {:?}", other),
}
}
#[test]
fn detects_python_version_from_pyproject() {
let p = TempProject::new("python_pyproject").write(
"pyproject.toml",
"[project]\nname = \"demo\"\nrequires-python = \">=3.12\"\n",
);
match detect_stack(as_str(&p)) {
ProjectStack::Python { version } => assert_eq!(version, "3.12"),
other => panic!("expected Python, got {:?}", other),
}
}
#[test]
fn detects_python_version_from_virtualenv() {
let p = TempProject::new("python_venv")
.write("requirements.txt", "")
.write(
".venv/pyvenv.cfg",
"home = /usr/bin\nversion = 3.10.12\ninclude-system-site-packages = false\n",
);
match detect_stack(as_str(&p)) {
ProjectStack::Python { version } => assert_eq!(version, "3.10.12"),
other => panic!("expected Python, got {:?}", other),
}
}
#[test]
fn detects_rust_from_cargo_toml() {
let p = TempProject::new("rust_cargo").write(
"Cargo.toml",
"[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
);
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Rust { .. }
));
}
#[test]
fn detects_rust_version_from_rust_version_field() {
let p = TempProject::new("rust_rustversion").write(
"Cargo.toml",
"[package]\nname = \"demo\"\nrust-version = \"1.75\"\n",
);
match detect_stack(as_str(&p)) {
ProjectStack::Rust { version } => assert_eq!(version, "1.75"),
other => panic!("expected Rust, got {:?}", other),
}
}
#[test]
fn detects_rust_version_from_rust_toolchain_toml() {
let p = TempProject::new("rust_toolchain")
.write("Cargo.toml", "[package]\nname = \"demo\"\n")
.write(
"rust-toolchain.toml",
"[toolchain]\nchannel = \"1.85.0\"\ncomponents = [\"clippy\"]\n",
);
match detect_stack(as_str(&p)) {
ProjectStack::Rust { version } => assert_eq!(version, "1.85.0"),
other => panic!("expected Rust, got {:?}", other),
}
}
#[test]
fn detects_docker_from_dockerfiles() {
for marker in ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"] {
let p = TempProject::new("docker_marker").write(marker, "FROM node:20\n");
assert_eq!(
detect_stack(as_str(&p)),
ProjectStack::Docker,
"marker: {marker}"
);
}
}
#[test]
fn node_wins_over_docker_and_python() {
let p = TempProject::new("multi_node")
.write("package.json", r#"{ "name": "web" }"#)
.write("Dockerfile", "FROM node:20")
.write("requirements.txt", "flask");
match detect_stack(as_str(&p)) {
ProjectStack::Node { .. } => {}
other => panic!("expected Node primary, got {:?}", other),
}
}
#[test]
fn python_wins_over_docker() {
let p = TempProject::new("multi_python")
.write("requirements.txt", "flask")
.write("Dockerfile", "FROM python:3.12");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Python { .. }
));
}
#[test]
fn rust_wins_over_docker() {
let p = TempProject::new("multi_rust")
.write("Cargo.toml", "[package]\nname = \"svc\"\n")
.write("Dockerfile", "FROM rust:latest");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Rust { .. }
));
}
#[test]
fn no_stack_returns_unknown_gracefully() {
let p = TempProject::new("unknown_empty");
assert_eq!(detect_stack(as_str(&p)), ProjectStack::Unknown);
}
#[test]
fn missing_directory_returns_unknown_gracefully() {
let missing = PathBuf::from("definitely/not/a/real/dir/xyz");
assert_eq!(
detect_stack(missing.to_str().unwrap()),
ProjectStack::Unknown
);
}
#[test]
fn extract_version_handles_specifier_glyphs() {
assert_eq!(extract_version(">=18 <20").as_deref(), Some("18"));
assert_eq!(extract_version("^18.12.0").as_deref(), Some("18.12.0"));
assert_eq!(extract_version("~22.4, <23").as_deref(), Some("22.4"));
assert_eq!(extract_version("v1.85.0").as_deref(), Some("1.85.0"));
assert_eq!(extract_version(" "), None);
}
#[test]
fn ignores_utf8_bom_in_version_files() {
let p = TempProject::new("python_bom")
.write(
"pyproject.toml",
"[project]\nrequires-python = \">=3.12\"\n",
)
.write(".python-version", "\u{FEFF}3.11.5\n");
match detect_stack(as_str(&p)) {
ProjectStack::Python { version } => assert_eq!(version, "3.11.5"),
other => panic!("expected Python, got {:?}", other),
}
}
#[test]
fn priority_order_is_node_python_rust_docker() {
let p = TempProject::new("priority_node")
.write("package.json", "{}")
.write("Cargo.toml", "[package]\nname = \"x\"\n")
.write("requirements.txt", "")
.write("Dockerfile", "FROM scratch");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Node { .. }
));
let p = TempProject::new("priority_rust_docker")
.write("Cargo.toml", "[package]\nname = \"x\"\n")
.write("Dockerfile", "FROM scratch");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Rust { .. }
));
}
#[test]
fn test_detect_node_js_project() {
let p = TempProject::new("t_node").write(
"package.json",
r#"{ "name": "node-fixture", "scripts": { "dev": "node index.js" } }"#,
);
match detect_stack(as_str(&p)) {
ProjectStack::Node { package_manager, .. } => {
assert_eq!(package_manager, "npm");
}
other => panic!("expected Node, got {other:?}"),
}
}
#[test]
fn test_detect_python_project() {
let p = TempProject::new("t_python").write("requirements.txt", "flask>=2.0\n");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Python { .. }
));
}
#[test]
fn test_detect_rust_project() {
let p = TempProject::new("t_rust").write("Cargo.toml", "[package]\nname = \"demo\"\n");
assert!(matches!(
detect_stack(as_str(&p)),
ProjectStack::Rust { .. }
));
}
#[test]
fn test_unknown_stack() {
let p = TempProject::new("t_unknown").write("README.md", "just docs\n");
assert!(matches!(detect_stack(as_str(&p)), ProjectStack::Unknown));
}
#[test]
fn test_multi_stack_priority() {
let node_python = TempProject::new("t_prior_np")
.write("package.json", "{}")
.write("requirements.txt", "flask\n");
assert!(matches!(
detect_stack(as_str(&node_python)),
ProjectStack::Node { .. }
));
let python_rust = TempProject::new("t_prior_pr")
.write("requirements.txt", "flask\n")
.write("Cargo.toml", "[package]\nname = \"x\"\n");
assert!(matches!(
detect_stack(as_str(&python_rust)),
ProjectStack::Python { .. }
));
}
}