1use colored::Colorize;
24use std::fs;
25use std::path::Path;
26use std::process::Command;
27
28use crate::models::{CheckStatus, ProjectStack};
29
30const NODE_MARKERS: &[&str] = &["package.json"];
32const PYTHON_MARKERS: &[&str] = &["requirements.txt", "pyproject.toml", "setup.py"];
34const RUST_MARKERS: &[&str] = &["Cargo.toml"];
36const GO_MARKERS: &[&str] = &["go.mod"];
38const JAVA_MARKERS: &[&str] = &["pom.xml", "build.gradle", "build.gradle.kts"];
40const DOCKER_MARKERS: &[&str] = &["docker-compose.yml", "docker-compose.yaml", "Dockerfile"];
42
43pub fn detect_stack(repo_path: &str) -> ProjectStack {
63 let root = Path::new(repo_path);
64
65 if !root.is_dir() {
66 eprintln!(
67 "{} {repo_path} is not a readable directory",
68 "WARN:".yellow().bold()
69 );
70 return ProjectStack::Unknown;
71 }
72
73 let mut present: Vec<StackKind> = Vec::new();
76 for kind in [
77 StackKind::Node,
78 StackKind::Python,
79 StackKind::Rust,
80 StackKind::Go,
81 StackKind::Java,
82 StackKind::Docker,
83 ] {
84 if kind.has_marker(root) {
85 present.push(kind);
86 }
87 }
88
89 if present.is_empty() {
90 eprintln!(
91 "{} No recognized project marker found in {repo_path}",
92 "WARN:".yellow().bold()
93 );
94 eprintln!(
95 " Hint: run `limit check` from your project root \
96 (where package.json / Cargo.toml / requirements.txt lives)."
97 );
98 return ProjectStack::Unknown;
99 }
100
101 for kind in &present[1..] {
103 eprintln!(
104 "{} Detected secondary stack: {} (primary: {})",
105 "WARN:".yellow().bold(),
106 kind.label(),
107 present[0].label()
108 );
109 }
110
111 match present[0] {
112 StackKind::Node => build_node_stack(root),
113 StackKind::Python => build_python_stack(root),
114 StackKind::Rust => build_rust_stack(root),
115 StackKind::Go => ProjectStack::Go { version: String::new() },
116 StackKind::Java => ProjectStack::Java { version: String::new() },
117 StackKind::Docker => ProjectStack::Docker,
118 }
119}
120
121#[derive(Debug, Clone, Copy, PartialEq, Eq)]
123enum StackKind {
124 Node,
125 Python,
126 Rust,
127 Go,
128 Java,
129 Docker,
130}
131
132impl StackKind {
133 fn markers(self) -> &'static [&'static str] {
134 match self {
135 StackKind::Node => NODE_MARKERS,
136 StackKind::Python => PYTHON_MARKERS,
137 StackKind::Rust => RUST_MARKERS,
138 StackKind::Go => GO_MARKERS,
139 StackKind::Java => JAVA_MARKERS,
140 StackKind::Docker => DOCKER_MARKERS,
141 }
142 }
143
144 fn has_marker(self, root: &Path) -> bool {
145 self.markers().iter().any(|m| root.join(m).is_file())
146 }
147
148 fn label(self) -> &'static str {
149 match self {
150 StackKind::Node => "Node.js",
151 StackKind::Python => "Python",
152 StackKind::Rust => "Rust",
153 StackKind::Go => "Go",
154 StackKind::Java => "Java",
155 StackKind::Docker => "Docker",
156 }
157 }
158}
159
160fn build_node_stack(root: &Path) -> ProjectStack {
165 let version = detect_node_version(root).unwrap_or_default();
166 let package_manager = detect_package_manager(root);
167 ProjectStack::Node {
168 version,
169 package_manager,
170 }
171}
172
173fn detect_node_version(root: &Path) -> Option<String> {
176 if let Some(raw) = read_first_non_empty(root, &[".nvmrc", ".node-version"]) {
177 return extract_version(&raw);
178 }
179
180 let pkg = root.join("package.json");
181 let content = read_clean(pkg).ok()?;
182 let json: serde_json::Value = serde_json::from_str(&content).ok()?;
183
184 json.pointer("/engines/node")
185 .and_then(|v| v.as_str())
186 .and_then(extract_version)
187}
188
189fn detect_package_manager(root: &Path) -> String {
192 if root.join("pnpm-lock.yaml").is_file() || root.join("pnpm-workspace.yaml").is_file() {
193 "pnpm".to_string()
194 } else if root.join("yarn.lock").is_file() {
195 "yarn".to_string()
196 } else if root.join("bun.lockb").is_file() || root.join("bun.lock").is_file() {
197 "bun".to_string()
198 } else {
199 "npm".to_string()
200 }
201}
202
203fn build_python_stack(root: &Path) -> ProjectStack {
208 let version = detect_python_version(root).unwrap_or_default();
209 ProjectStack::Python { version }
210}
211
212fn detect_python_version(root: &Path) -> Option<String> {
216 if let Some(raw) = read_first_non_empty(root, &[".python-version"]) {
217 return extract_version(&raw);
218 }
219
220 let pyproject = root.join("pyproject.toml");
221 if let Ok(content) = read_clean(&pyproject) {
222 if let Some(spec) = python_version_from_pyproject(&content) {
223 return extract_version(&spec);
224 }
225 }
226
227 for cfg in [
228 ".venv/pyvenv.cfg",
229 "venv/pyvenv.cfg",
230 "virtualenv/pyvenv.cfg",
231 ] {
232 if let Ok(content) = read_clean(root.join(cfg)) {
233 if let Some(version) = python_version_from_pyvenv(&content) {
234 return Some(version);
235 }
236 }
237 }
238
239 None
240}
241
242pub(crate) fn python_version_from_pyproject(content: &str) -> Option<String> {
244 let mut section = String::new();
245
246 for line in content.lines() {
247 let trimmed = line.trim();
248
249 if trimmed.starts_with('[') {
250 section = trimmed.to_string();
251 continue;
252 }
253
254 match section.as_str() {
255 "[project]" => {
256 if let Some(spec) = parse_key_value(trimmed, "requires-python") {
257 if !spec.is_empty() {
258 return Some(spec);
259 }
260 }
261 }
262 "[tool.poetry.dependencies]" => {
263 if let Some(spec) = parse_key_value(trimmed, "python") {
264 if !spec.is_empty() {
265 return Some(spec);
266 }
267 }
268 }
269 _ => {}
270 }
271 }
272
273 None
274}
275
276fn python_version_from_pyvenv(content: &str) -> Option<String> {
278 for line in content.lines() {
279 let trimmed = line.trim();
280 if trimmed.starts_with("version") {
281 if let Some(spec) = parse_key_value(trimmed, "version") {
282 if !spec.is_empty() {
283 return Some(spec);
284 }
285 }
286 }
287 }
288 None
289}
290
291pub(crate) fn parse_key_value(line: &str, key: &str) -> Option<String> {
293 let candidate = line.trim().strip_prefix(key)?;
294 if candidate.is_empty() || candidate.starts_with('-') {
295 return None;
296 }
297 let spec = candidate
298 .trim()
299 .trim_start_matches('=')
300 .trim()
301 .trim_matches('"')
302 .trim_matches('\'')
303 .trim();
304 if spec.is_empty() {
305 None
306 } else {
307 Some(spec.to_string())
308 }
309}
310
311fn build_rust_stack(root: &Path) -> ProjectStack {
316 let version = detect_rust_version(root).unwrap_or_default();
317 ProjectStack::Rust { version }
318}
319
320fn detect_rust_version(root: &Path) -> Option<String> {
323 let toolchain = root.join("rust-toolchain");
324 if toolchain.is_file() {
325 if let Ok(content) = read_clean(&toolchain) {
326 let trimmed = content.trim();
327 if !trimmed.is_empty() {
328 return Some(trimmed.to_string());
329 }
330 }
331 }
332
333 let toolchain_toml = root.join("rust-toolchain.toml");
334 if toolchain_toml.is_file() {
335 if let Ok(content) = read_clean(&toolchain_toml) {
336 let mut in_toolchain = false;
337 for line in content.lines() {
338 let trimmed = line.trim();
339 if trimmed.starts_with('[') {
340 in_toolchain = trimmed == "[toolchain]";
341 continue;
342 }
343 if in_toolchain {
344 if let Some(channel) = parse_key_value(trimmed, "channel") {
345 if !channel.is_empty() {
346 return Some(channel);
347 }
348 }
349 }
350 }
351 }
352 }
353
354 let cargo = root.join("Cargo.toml");
355 if cargo.is_file() {
356 if let Ok(content) = read_clean(&cargo) {
357 let mut in_package = false;
358 for line in content.lines() {
359 let trimmed = line.trim();
360 if trimmed.starts_with('[') {
361 in_package = trimmed == "[package]";
362 continue;
363 }
364 if in_package {
365 if let Some(version) = parse_key_value(trimmed, "rust-version") {
366 if !version.is_empty() {
367 return Some(version);
368 }
369 }
370 }
371 }
372 }
373 }
374
375 None
376}
377
378fn read_first_non_empty(root: &Path, names: &[&str]) -> Option<String> {
385 for name in names {
386 let path = root.join(name);
387 if path.is_file() {
388 if let Ok(content) = read_clean(&path) {
389 let trimmed = content.trim();
390 if !trimmed.is_empty() {
391 return Some(trimmed.to_string());
392 }
393 }
394 }
395 }
396 None
397}
398
399pub(crate) fn read_clean(path: impl AsRef<Path>) -> std::io::Result<String> {
401 let bytes = fs::read(path)?;
402 let bytes = bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(&bytes);
403 Ok(String::from_utf8_lossy(bytes).into_owned())
404}
405
406pub(crate) fn extract_version(raw: &str) -> Option<String> {
410 for token in raw.split(|c: char| c.is_whitespace() || c == ',') {
411 let cleaned = token.trim_start_matches(['>', '<', '=', '^', '~', 'v', 'V', ' ', '\t']);
412 if cleaned.chars().any(|c| c.is_ascii_digit()) {
413 return Some(cleaned.to_string());
414 }
415 }
416
417 let trimmed = raw.trim();
418 if !trimmed.is_empty() {
419 Some(trimmed.to_string())
420 } else {
421 None
422 }
423}
424
425pub fn run_check() {
430 println!("{}", "=== Environment Check ===".bold().cyan());
431 println!();
432
433 detect_os();
434 detect_shell();
435 detect_language_tools();
436
437 println!();
438 println!(" {} {}", "Project:".bold(), detect_stack(".").label());
439 print_runtime_validation();
440 print_env_audit();
441 print_dep_audit();
442
443 println!();
444 println!("{}", "Check complete!".green().bold());
445}
446
447fn print_runtime_validation() {
450 use crate::modules::runtime_validator::validate_installed_runtime;
451
452 if let Some(report) = validate_installed_runtime(".") {
453 println!();
454 println!(
455 " {} {}",
456 report.status_label(),
457 format!("Runtime: {}", report.message).dimmed()
458 );
459 if let Some(remediation) = report.remediation {
460 println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
461 }
462 }
463}
464
465fn print_env_audit() {
467 use crate::modules::env_auditor::audit_env_files;
468
469 let result = audit_env_files(".");
470 let label = match result.status {
471 CheckStatus::Pass => "PASS".green().bold(),
472 CheckStatus::Warn => "WARN".yellow().bold(),
473 CheckStatus::Fail => "FAIL".red().bold(),
474 };
475 println!(
476 " {} {}",
477 label,
478 format!("Env Audit: {}", result.message).dimmed()
479 );
480 if let Some(remediation) = result.remediation {
481 println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
482 }
483}
484
485fn print_dep_audit() {
488 use crate::modules::dependency_checker::check_dependencies;
489
490 let stack = detect_stack(".");
491 let result = check_dependencies(".", &stack);
492 let label = match result.status {
493 CheckStatus::Pass => "PASS".green().bold(),
494 CheckStatus::Warn => "WARN".yellow().bold(),
495 CheckStatus::Fail => "FAIL".red().bold(),
496 };
497 println!(
498 " {} {}",
499 label,
500 format!("Dependencies: {}", result.message).dimmed()
501 );
502 if let Some(remediation) = result.remediation {
503 println!(" {} {}", "Fix:".cyan().bold(), remediation.dimmed());
504 }
505}
506
507fn detect_os() {
508 let os = std::env::consts::OS;
509 let arch = std::env::consts::ARCH;
510 println!(" {} {} / {}", "OS:".bold(), os, arch);
511}
512
513fn detect_shell() {
514 if cfg!(windows) {
515 if let Ok(shell) = std::env::var("COMSPEC") {
516 println!(" {} {}", "Shell:".bold(), shell);
517 }
518 } else if let Ok(shell) = std::env::var("SHELL") {
519 println!(" {} {}", "Shell:".bold(), shell);
520 }
521}
522
523fn detect_language_tools() {
524 let tools = vec![
525 ("rustc", "--version"),
526 ("cargo", "--version"),
527 ("node", "--version"),
528 ("npm", "--version"),
529 ("python", "--version"),
530 ("go", "version"),
531 ("java", "-version"),
532 ];
533
534 for (cmd, flag) in tools {
535 match Command::new(cmd).arg(flag).output() {
536 Ok(output) => {
537 let stdout = String::from_utf8_lossy(&output.stdout);
538 let stderr = String::from_utf8_lossy(&output.stderr);
539 let version = if stdout.trim().is_empty() {
540 stderr.trim().lines().next().unwrap_or("unknown")
541 } else {
542 stdout.trim().lines().next().unwrap_or("unknown")
543 };
544 println!(
545 " {} {} {}",
546 "Found:".green(),
547 format!("{}:", cmd).bold(),
548 version
549 );
550 }
551 Err(_) => {
552 println!(
553 " {} {} {}",
554 "Missing:".yellow(),
555 cmd,
556 "(not installed)".dimmed()
557 );
558 }
559 }
560 }
561}
562
563#[cfg(test)]
564mod tests {
565 use super::*;
566 use crate::models::ProjectStack;
567 use std::fs;
568 use std::path::{Path, PathBuf};
569 use std::time::{SystemTime, UNIX_EPOCH};
570
571 struct TempProject {
573 path: PathBuf,
574 }
575
576 impl TempProject {
577 fn new(label: &str) -> Self {
578 let stamp = SystemTime::now()
579 .duration_since(UNIX_EPOCH)
580 .expect("system clock")
581 .as_nanos();
582 let path = std::env::temp_dir()
583 .join(format!("limitless_{label}_{}_{stamp}", std::process::id()));
584 fs::create_dir_all(&path).expect("create temp project");
585 TempProject { path }
586 }
587
588 fn path(&self) -> &Path {
589 &self.path
590 }
591
592 fn write(self, relative: &str, content: &str) -> Self {
595 let full = self.path.join(relative);
596 if let Some(parent) = full.parent() {
597 fs::create_dir_all(parent).expect("create parent dirs");
598 }
599 fs::write(full, content).expect("write fixture file");
600 self
601 }
602 }
603
604 impl Drop for TempProject {
605 fn drop(&mut self) {
606 let _ = fs::remove_dir_all(&self.path);
607 }
608 }
609
610 fn as_str(project: &TempProject) -> &str {
611 project.path().to_str().expect("utf8 path")
612 }
613
614 #[test]
617 fn detects_node_with_version_from_engines() {
618 let p = TempProject::new("node_engines").write(
619 "package.json",
620 r#"{ "name": "demo", "engines": { "node": ">=18.12.0 <20" } }"#,
621 );
622
623 match detect_stack(as_str(&p)) {
624 ProjectStack::Node {
625 version,
626 package_manager,
627 } => {
628 assert_eq!(version, "18.12.0");
629 assert_eq!(package_manager, "npm");
630 }
631 other => panic!("expected Node, got {:?}", other),
632 }
633 }
634
635 #[test]
636 fn detects_node_version_from_nvmrc() {
637 let p = TempProject::new("node_nvmrc")
638 .write("package.json", "{}")
639 .write(".nvmrc", "20.11.1\n");
640
641 match detect_stack(as_str(&p)) {
642 ProjectStack::Node {
643 version,
644 package_manager,
645 } => {
646 assert_eq!(version, "20.11.1");
647 assert_eq!(package_manager, "npm");
648 }
649 other => panic!("expected Node, got {:?}", other),
650 }
651 }
652
653 #[test]
654 fn detects_node_package_managers_from_lockfiles() {
655 let p = TempProject::new("node_pnpm")
656 .write("package.json", "{}")
657 .write("pnpm-lock.yaml", "lockfileVersion: '9.0'");
658 assert!(matches!(
659 detect_stack(as_str(&p)),
660 ProjectStack::Node {
661 package_manager: ref m,
662 ..
663 } if m == "pnpm"
664 ));
665
666 let p = TempProject::new("node_yarn")
667 .write("package.json", "{}")
668 .write("yarn.lock", "# yarn lockfile");
669 assert!(matches!(
670 detect_stack(as_str(&p)),
671 ProjectStack::Node {
672 package_manager: ref m,
673 ..
674 } if m == "yarn"
675 ));
676 }
677
678 #[test]
679 fn node_without_version_uses_npm_default() {
680 let p = TempProject::new("node_noversion").write("package.json", "{}");
681 match detect_stack(as_str(&p)) {
682 ProjectStack::Node {
683 version,
684 package_manager,
685 } => {
686 assert!(version.is_empty());
687 assert_eq!(package_manager, "npm");
688 }
689 other => panic!("expected Node, got {:?}", other),
690 }
691 }
692
693 #[test]
696 fn detects_python_from_requirements_txt() {
697 let p = TempProject::new("python_reqs").write("requirements.txt", "flask==3.0.0\n");
698 assert!(matches!(
699 detect_stack(as_str(&p)),
700 ProjectStack::Python { .. }
701 ));
702 }
703
704 #[test]
705 fn detects_python_version_from_python_version_file() {
706 let p = TempProject::new("python_verfile")
707 .write("requirements.txt", "")
708 .write(".python-version", "3.12.1\n");
709
710 match detect_stack(as_str(&p)) {
711 ProjectStack::Python { version } => assert_eq!(version, "3.12.1"),
712 other => panic!("expected Python, got {:?}", other),
713 }
714 }
715
716 #[test]
717 fn detects_python_version_from_pyproject() {
718 let p = TempProject::new("python_pyproject").write(
719 "pyproject.toml",
720 "[project]\nname = \"demo\"\nrequires-python = \">=3.12\"\n",
721 );
722
723 match detect_stack(as_str(&p)) {
724 ProjectStack::Python { version } => assert_eq!(version, "3.12"),
725 other => panic!("expected Python, got {:?}", other),
726 }
727 }
728
729 #[test]
730 fn detects_python_version_from_virtualenv() {
731 let p = TempProject::new("python_venv")
732 .write("requirements.txt", "")
733 .write(
734 ".venv/pyvenv.cfg",
735 "home = /usr/bin\nversion = 3.10.12\ninclude-system-site-packages = false\n",
736 );
737
738 match detect_stack(as_str(&p)) {
739 ProjectStack::Python { version } => assert_eq!(version, "3.10.12"),
740 other => panic!("expected Python, got {:?}", other),
741 }
742 }
743
744 #[test]
747 fn detects_rust_from_cargo_toml() {
748 let p = TempProject::new("rust_cargo").write(
749 "Cargo.toml",
750 "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
751 );
752 assert!(matches!(
753 detect_stack(as_str(&p)),
754 ProjectStack::Rust { .. }
755 ));
756 }
757
758 #[test]
759 fn detects_rust_version_from_rust_version_field() {
760 let p = TempProject::new("rust_rustversion").write(
761 "Cargo.toml",
762 "[package]\nname = \"demo\"\nrust-version = \"1.75\"\n",
763 );
764
765 match detect_stack(as_str(&p)) {
766 ProjectStack::Rust { version } => assert_eq!(version, "1.75"),
767 other => panic!("expected Rust, got {:?}", other),
768 }
769 }
770
771 #[test]
772 fn detects_rust_version_from_rust_toolchain_toml() {
773 let p = TempProject::new("rust_toolchain")
774 .write("Cargo.toml", "[package]\nname = \"demo\"\n")
775 .write(
776 "rust-toolchain.toml",
777 "[toolchain]\nchannel = \"1.85.0\"\ncomponents = [\"clippy\"]\n",
778 );
779
780 match detect_stack(as_str(&p)) {
781 ProjectStack::Rust { version } => assert_eq!(version, "1.85.0"),
782 other => panic!("expected Rust, got {:?}", other),
783 }
784 }
785
786 #[test]
789 fn detects_docker_from_dockerfiles() {
790 for marker in ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"] {
791 let p = TempProject::new("docker_marker").write(marker, "FROM node:20\n");
792 assert_eq!(
793 detect_stack(as_str(&p)),
794 ProjectStack::Docker,
795 "marker: {marker}"
796 );
797 }
798 }
799
800 #[test]
803 fn node_wins_over_docker_and_python() {
804 let p = TempProject::new("multi_node")
805 .write("package.json", r#"{ "name": "web" }"#)
806 .write("Dockerfile", "FROM node:20")
807 .write("requirements.txt", "flask");
808
809 match detect_stack(as_str(&p)) {
810 ProjectStack::Node { .. } => {}
811 other => panic!("expected Node primary, got {:?}", other),
812 }
813 }
814
815 #[test]
816 fn python_wins_over_docker() {
817 let p = TempProject::new("multi_python")
818 .write("requirements.txt", "flask")
819 .write("Dockerfile", "FROM python:3.12");
820
821 assert!(matches!(
822 detect_stack(as_str(&p)),
823 ProjectStack::Python { .. }
824 ));
825 }
826
827 #[test]
828 fn rust_wins_over_docker() {
829 let p = TempProject::new("multi_rust")
830 .write("Cargo.toml", "[package]\nname = \"svc\"\n")
831 .write("Dockerfile", "FROM rust:latest");
832
833 assert!(matches!(
834 detect_stack(as_str(&p)),
835 ProjectStack::Rust { .. }
836 ));
837 }
838
839 #[test]
840 fn no_stack_returns_unknown_gracefully() {
841 let p = TempProject::new("unknown_empty");
842 assert_eq!(detect_stack(as_str(&p)), ProjectStack::Unknown);
843 }
844
845 #[test]
846 fn missing_directory_returns_unknown_gracefully() {
847 let missing = PathBuf::from("definitely/not/a/real/dir/xyz");
848 assert_eq!(
849 detect_stack(missing.to_str().unwrap()),
850 ProjectStack::Unknown
851 );
852 }
853
854 #[test]
857 fn extract_version_handles_specifier_glyphs() {
858 assert_eq!(extract_version(">=18 <20").as_deref(), Some("18"));
859 assert_eq!(extract_version("^18.12.0").as_deref(), Some("18.12.0"));
860 assert_eq!(extract_version("~22.4, <23").as_deref(), Some("22.4"));
861 assert_eq!(extract_version("v1.85.0").as_deref(), Some("1.85.0"));
862 assert_eq!(extract_version(" "), None);
863 }
864
865 #[test]
866 fn ignores_utf8_bom_in_version_files() {
867 let p = TempProject::new("python_bom")
869 .write(
870 "pyproject.toml",
871 "[project]\nrequires-python = \">=3.12\"\n",
872 )
873 .write(".python-version", "\u{FEFF}3.11.5\n");
874
875 match detect_stack(as_str(&p)) {
876 ProjectStack::Python { version } => assert_eq!(version, "3.11.5"),
877 other => panic!("expected Python, got {:?}", other),
878 }
879 }
880
881 #[test]
882 fn priority_order_is_node_python_rust_docker() {
883 let p = TempProject::new("priority_node")
885 .write("package.json", "{}")
886 .write("Cargo.toml", "[package]\nname = \"x\"\n")
887 .write("requirements.txt", "")
888 .write("Dockerfile", "FROM scratch");
889 assert!(matches!(
890 detect_stack(as_str(&p)),
891 ProjectStack::Node { .. }
892 ));
893
894 let p = TempProject::new("priority_rust_docker")
896 .write("Cargo.toml", "[package]\nname = \"x\"\n")
897 .write("Dockerfile", "FROM scratch");
898 assert!(matches!(
899 detect_stack(as_str(&p)),
900 ProjectStack::Rust { .. }
901 ));
902 }
903
904 #[test]
907 fn test_detect_node_js_project() {
908 let p = TempProject::new("t_node").write(
909 "package.json",
910 r#"{ "name": "node-fixture", "scripts": { "dev": "node index.js" } }"#,
911 );
912 match detect_stack(as_str(&p)) {
913 ProjectStack::Node { package_manager, .. } => {
914 assert_eq!(package_manager, "npm");
915 }
916 other => panic!("expected Node, got {other:?}"),
917 }
918 }
919
920 #[test]
921 fn test_detect_python_project() {
922 let p = TempProject::new("t_python").write("requirements.txt", "flask>=2.0\n");
923 assert!(matches!(
924 detect_stack(as_str(&p)),
925 ProjectStack::Python { .. }
926 ));
927 }
928
929 #[test]
930 fn test_detect_rust_project() {
931 let p = TempProject::new("t_rust").write("Cargo.toml", "[package]\nname = \"demo\"\n");
932 assert!(matches!(
933 detect_stack(as_str(&p)),
934 ProjectStack::Rust { .. }
935 ));
936 }
937
938 #[test]
939 fn test_unknown_stack() {
940 let p = TempProject::new("t_unknown").write("README.md", "just docs\n");
941 assert!(matches!(detect_stack(as_str(&p)), ProjectStack::Unknown));
942 }
943
944 #[test]
945 fn test_multi_stack_priority() {
946 let node_python = TempProject::new("t_prior_np")
948 .write("package.json", "{}")
949 .write("requirements.txt", "flask\n");
950 assert!(matches!(
951 detect_stack(as_str(&node_python)),
952 ProjectStack::Node { .. }
953 ));
954
955 let python_rust = TempProject::new("t_prior_pr")
957 .write("requirements.txt", "flask\n")
958 .write("Cargo.toml", "[package]\nname = \"x\"\n");
959 assert!(matches!(
960 detect_stack(as_str(&python_rust)),
961 ProjectStack::Python { .. }
962 ));
963 }
964}