use std::collections::HashMap;
use std::path::Path;
use std::process::Command;
use crate::models::{CheckStatus, DiagnosticResult, ProjectStack};
pub fn check_dependencies(repo_path: &str, stack: &ProjectStack) -> DiagnosticResult {
match stack {
ProjectStack::Node { .. } => check_node_deps(repo_path),
ProjectStack::Python { .. } => check_python_deps(repo_path),
ProjectStack::Rust { .. } => check_rust_deps(repo_path),
ProjectStack::Go { .. } | ProjectStack::Java { .. } | ProjectStack::Docker | ProjectStack::Unknown => DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
"no dependency audit needed for this stack",
),
}
}
pub fn run_npm_list(repo_path: &str) -> Option<serde_json::Value> {
let output = Command::new("npm")
.args(["list", "--depth=0", "--json"])
.current_dir(repo_path)
.output()
.ok()?;
if !output.status.success() && output.stdout.is_empty() {
return None;
}
serde_json::from_slice(&output.stdout).ok()
}
pub fn run_pip_list() -> Option<Vec<(String, String)>> {
let output = Command::new("pip")
.args(["list", "--format=json"])
.output()
.ok()?;
if !output.status.success() {
return None;
}
let parsed: Vec<HashMap<String, String>> = serde_json::from_slice(&output.stdout).ok()?;
Some(
parsed
.into_iter()
.filter_map(|p| {
let name = p.get("name")?.to_lowercase();
let version = p.get("version")?.clone();
Some((name, version))
})
.collect(),
)
}
pub fn run_cargo_tree(repo_path: &str) -> Option<Vec<String>> {
let output = Command::new("cargo")
.args(["tree", "--depth=1", "--prefix=depth"])
.current_dir(repo_path)
.output()
.ok()?;
if !output.status.success() {
return None;
}
let text = String::from_utf8_lossy(&output.stdout);
Some(
text.lines()
.filter_map(|line| {
let trimmed = line.trim_start();
let rest = trimmed
.split_whitespace()
.skip(1) .collect::<Vec<_>>()
.join(" ");
if rest.is_empty() || rest.starts_with('(') || rest.contains("proc-macro") {
None
} else {
Some(rest)
}
})
.collect(),
)
}
fn read_package_json(repo_path: &str) -> (Vec<String>, Vec<String>) {
let path = Path::new(repo_path).join("package.json");
let Ok(text) = std::fs::read_to_string(&path) else {
return (Vec::new(), Vec::new());
};
let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) else {
return (Vec::new(), Vec::new());
};
let deps = extract_dep_keys(&value, "dependencies");
let dev_deps = extract_dep_keys(&value, "devDependencies");
(deps, dev_deps)
}
fn extract_dep_keys(value: &serde_json::Value, field: &str) -> Vec<String> {
value
.get(field)
.and_then(|v| v.as_object())
.map(|obj| obj.keys().cloned().collect())
.unwrap_or_default()
}
fn parse_npm_list(value: &serde_json::Value) -> HashMap<String, String> {
let mut installed = HashMap::new();
if let Some(deps) = value.get("dependencies").and_then(|v| v.as_object()) {
for (name, info) in deps {
let status = if info.get("missing").and_then(|v| v.as_bool()) == Some(true) {
"missing".to_string()
} else if info.get("invalid").and_then(|v| v.as_bool()) == Some(true) {
let ver = info.get("version").and_then(|v| v.as_str()).unwrap_or("?");
format!("invalid({ver})")
} else {
info.get("version")
.and_then(|v| v.as_str())
.unwrap_or("?")
.to_string()
};
installed.insert(name.to_lowercase(), status);
}
}
installed
}
fn check_node_deps(repo_path: &str) -> DiagnosticResult {
let root = Path::new(repo_path);
let has_modules = root.join("node_modules").is_dir();
let has_package_json = root.join("package.json").is_file();
if !has_package_json {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
"no package.json found; nothing to audit",
);
}
if !has_modules {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Fail,
"node_modules/ is missing",
)
.with_remediation("Run `npm install` to install dependencies");
}
let (all_deps, dev_deps) = read_package_json(repo_path);
let total_expected = all_deps.len() + dev_deps.len();
match run_npm_list(repo_path) {
None => DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
"node_modules/ exists but npm is not available to audit",
)
.with_remediation("Install npm and run `npm list` to check dependency health"),
Some(value) => {
let installed = parse_npm_list(&value);
let missing: Vec<&String> = all_deps
.iter()
.chain(dev_deps.iter())
.filter(|name| installed.get(name.as_str()) == Some(&"missing".to_string()))
.collect();
let invalid: Vec<(&String, &String)> = all_deps
.iter()
.chain(dev_deps.iter())
.filter_map(|name| {
let status = installed.get(name.as_str())?;
if status.starts_with("invalid(") {
Some((name, status))
} else {
None
}
})
.collect();
if !missing.is_empty() {
let names: Vec<&str> = missing.iter().map(|n| n.as_str()).collect();
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Fail,
format!("{} dependencies missing from node_modules", missing.len()),
)
.with_remediation(format!(
"Run `npm install` to install: {}",
names.join(", ")
));
}
if !invalid.is_empty() {
let details: Vec<String> = invalid
.iter()
.map(|(name, status)| format!("{name} ({status})"))
.collect();
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
format!("{} dependencies have version mismatches", invalid.len()),
)
.with_remediation(format!("Run `npm install` to fix: {}", details.join(", ")));
}
DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
format!(
"node_modules present and consistent with package.json ({total_expected} deps)"
),
)
}
}
}
pub fn parse_requirements(content: &str) -> Vec<(String, String)> {
content
.lines()
.filter_map(|line| {
let line = line.trim();
if line.is_empty() || line.starts_with('#') || line.starts_with('-') {
return None;
}
let (name, spec) = if let Some(pos) = line.find(|c: char| "><=!~".contains(c)) {
(&line[..pos], line[pos..].trim_end())
} else {
(line, "")
};
let name = name.trim().to_lowercase();
if name.is_empty() {
None
} else {
Some((name, spec.to_string()))
}
})
.collect()
}
fn check_python_deps(repo_path: &str) -> DiagnosticResult {
check_python_deps_impl(repo_path, run_pip_list())
}
fn check_python_deps_impl(
repo_path: &str,
pip_output: Option<Vec<(String, String)>>,
) -> DiagnosticResult {
let root = Path::new(repo_path);
let has_requirements = root.join("requirements.txt").is_file();
let has_pyproject = root.join("pyproject.toml").is_file();
if !has_requirements && !has_pyproject {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
"no requirements.txt or pyproject.toml found",
);
}
match pip_output {
None => DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
"requirements file found but pip is not available to audit",
)
.with_remediation("Activate a virtual environment and run `pip list` to check"),
Some(installed) => {
if !has_requirements {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
format!(
"pyproject.toml present; {} packages installed via pip",
installed.len()
),
);
}
let reqs = std::fs::read_to_string(root.join("requirements.txt")).unwrap_or_default();
let required = parse_requirements(&reqs);
let installed_map: HashMap<&str, &str> = installed
.iter()
.map(|(n, v)| (n.as_str(), v.as_str()))
.collect();
let missing: Vec<&str> = required
.iter()
.filter(|(name, _)| !installed_map.contains_key(name.as_str()))
.map(|(name, _)| name.as_str())
.collect();
if !missing.is_empty() {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Fail,
format!(
"{} packages from requirements.txt are not installed",
missing.len()
),
)
.with_remediation(format!(
"Run `pip install -r requirements.txt` to install: {}",
missing.join(", ")
));
}
DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
format!(
"all {} required packages are installed ({} packages total)",
required.len(),
installed.len()
),
)
}
}
}
fn check_rust_deps(repo_path: &str) -> DiagnosticResult {
let root = Path::new(repo_path);
let has_cargo_toml = root.join("Cargo.toml").is_file();
let has_cargo_lock = root.join("Cargo.lock").is_file();
if !has_cargo_toml {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
"no Cargo.toml found; nothing to audit",
);
}
if !has_cargo_lock {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
"Cargo.toml present but Cargo.lock is missing",
)
.with_remediation("Run `cargo build` to generate Cargo.lock (required for binaries)");
}
match run_cargo_tree(repo_path) {
None => DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
"Cargo.lock exists but cargo is not available to audit",
)
.with_remediation("Install rustup and run `cargo tree` to check dependency health"),
Some(tree) => {
if tree.is_empty() {
return DiagnosticResult::new(
"Dependencies",
CheckStatus::Warn,
"cargo tree returned no dependencies",
)
.with_remediation("Run `cargo check` to resolve dependency issues");
}
DiagnosticResult::new(
"Dependencies",
CheckStatus::Pass,
format!(
"Cargo.lock present; {} direct dependencies resolved",
tree.len()
),
)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
struct TempDir {
path: PathBuf,
}
impl TempDir {
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_dep_{label}_{stamp}"));
fs::create_dir_all(&path).expect("create temp dir");
TempDir { 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 TempDir {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.path);
}
}
#[test]
fn parse_npm_list_extracts_versions_and_flags() {
let json = serde_json::json!({
"dependencies": {
"react": { "version": "18.2.0" },
"lodash": { "version": "4.17.21", "missing": true },
"axios": { "version": "1.6.0", "invalid": true }
}
});
let installed = parse_npm_list(&json);
assert_eq!(installed.get("react").unwrap(), "18.2.0");
assert_eq!(installed.get("lodash").unwrap(), "missing");
assert!(installed.get("axios").unwrap().starts_with("invalid("));
}
#[test]
fn parse_npm_list_handles_empty() {
let json = serde_json::json!({ "dependencies": {} });
assert!(parse_npm_list(&json).is_empty());
}
#[test]
fn parse_requirements_captures_packages_and_specs() {
let content = "flask>=3.0\nrequests\n# commented\nurllib3~=2.1\n";
let reqs = parse_requirements(content);
assert_eq!(reqs.len(), 3);
assert_eq!(reqs[0].0, "flask");
assert_eq!(reqs[0].1, ">=3.0");
assert_eq!(reqs[1].0, "requests");
assert!(reqs[1].1.is_empty());
assert_eq!(reqs[2].0, "urllib3");
assert_eq!(reqs[2].1, "~=2.1");
}
#[test]
fn parse_requirements_skips_empty_and_options() {
let content = "\n\n-r constraints.txt\n--index-url https://example.com\nflask\n";
let reqs = parse_requirements(content);
assert_eq!(reqs.len(), 1);
assert_eq!(reqs[0].0, "flask");
}
#[test]
fn node_no_package_json_passes() {
let dir = TempDir::new("node_empty");
let result = check_dependencies(dir.path().to_str().unwrap(), &node_stack());
assert_eq!(result.status, CheckStatus::Pass);
assert!(result.message.contains("no package.json"));
}
#[test]
fn node_missing_node_modules_fails() {
let dir = TempDir::new("node_no_modules").write("package.json", r#"{ "name": "web" }"#);
let result = check_dependencies(dir.path().to_str().unwrap(), &node_stack());
assert_eq!(result.status, CheckStatus::Fail);
assert!(result.message.contains("node_modules"));
assert!(result.remediation.unwrap().contains("npm install"));
}
#[test]
fn node_with_modules_but_no_npm_warns() {
let dir = TempDir::new("node_modules_no_npm")
.write("package.json", r#"{ "name": "web", "dependencies": {} }"#);
fs::create_dir_all(dir.path().join("node_modules")).expect("create node_modules");
let result = check_dependencies(dir.path().to_str().unwrap(), &node_stack());
assert_eq!(result.status, CheckStatus::Warn);
assert!(result.message.contains("npm"));
}
#[test]
fn python_no_manifest_passes() {
let dir = TempDir::new("python_empty");
let result = check_dependencies(dir.path().to_str().unwrap(), &python_stack());
assert_eq!(result.status, CheckStatus::Pass);
assert!(result.message.contains("no requirements"));
}
#[test]
fn python_with_requirements_but_no_pip_warns() {
let dir =
TempDir::new("python_reqs_no_pip").write("requirements.txt", "flask>=3.0\nrequests\n");
let result = check_python_deps_impl(dir.path().to_str().unwrap(), None);
assert_eq!(result.status, CheckStatus::Warn);
assert!(result.message.contains("pip"));
}
#[test]
fn python_missing_required_packages_fails() {
let dir =
TempDir::new("python_missing").write("requirements.txt", "flask>=3.0\nrequests\n");
let pip = vec![
("requests".to_string(), "2.32.3".to_string()),
("urllib3".to_string(), "2.2.2".to_string()),
];
let result = check_python_deps_impl(dir.path().to_str().unwrap(), Some(pip));
assert_eq!(result.status, CheckStatus::Fail);
assert!(result.message.contains("not installed"));
assert!(result.remediation.unwrap().contains("flask"));
}
#[test]
fn rust_no_cargo_toml_passes() {
let dir = TempDir::new("rust_empty");
let result = check_dependencies(dir.path().to_str().unwrap(), &rust_stack());
assert_eq!(result.status, CheckStatus::Pass);
assert!(result.message.contains("no Cargo.toml"));
}
#[test]
fn rust_no_cargo_lock_warns() {
let dir = TempDir::new("rust_no_lock").write(
"Cargo.toml",
"[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
);
let result = check_dependencies(dir.path().to_str().unwrap(), &rust_stack());
assert_eq!(result.status, CheckStatus::Warn);
assert!(result.message.contains("Cargo.lock"));
}
#[test]
fn rust_with_lock_but_no_cargo_warns() {
let dir = TempDir::new("rust_lock_no_cargo")
.write(
"Cargo.toml",
"[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
)
.write("Cargo.lock", "[metadata]\n\"checksum\"");
let result = check_dependencies(dir.path().to_str().unwrap(), &rust_stack());
assert_eq!(result.status, CheckStatus::Warn);
}
#[test]
fn unknown_stack_passes() {
let result = check_dependencies("/tmp", &ProjectStack::Unknown);
assert_eq!(result.status, CheckStatus::Pass);
}
fn node_stack() -> ProjectStack {
ProjectStack::Node {
version: String::new(),
package_manager: "npm".to_string(),
}
}
fn python_stack() -> ProjectStack {
ProjectStack::Python {
version: String::new(),
}
}
fn rust_stack() -> ProjectStack {
ProjectStack::Rust {
version: String::new(),
}
}
}