Skip to main content

limitless_cli/modules/
stack_detector.rs

1//! Project stack detection for Limitless CLI.
2//!
3//! Scans a repository root for marker files and returns the primary
4//! [`ProjectStack`] with exact runtime versions where possible.
5//!
6//! # Detection priorities
7//!
8//! A project can contain markers for several stacks (e.g. a Node app that
9//! is also deployed with Docker). When that happens, the primary stack is
10//! chosen in this order: **Node > Python > Rust > Docker**, and any
11//! secondary stacks are logged as warnings.
12//!
13//! # Example detection outputs
14//!
15//! ```text
16//!   package.json + .nvmrc  ->  ProjectStack::Node { version: "18.12.0", package_manager: "npm" }
17//!   pyproject.toml         ->  ProjectStack::Python { version: ">=3.12" }
18//!   Cargo.toml             ->  ProjectStack::Rust { version: "1.98.0" }
19//!   Dockerfile             ->  ProjectStack::Docker
20//!   (nothing)              ->  ProjectStack::Unknown  (+ "run from project root" hint)
21//! ```
22
23use colored::Colorize;
24use std::fs;
25use std::path::Path;
26use std::process::Command;
27
28use crate::models::{CheckStatus, ProjectStack};
29
30/// Marker files for Node.js projects, checked in order.
31const NODE_MARKERS: &[&str] = &["package.json"];
32/// Marker files for Python projects, checked in order.
33const PYTHON_MARKERS: &[&str] = &["requirements.txt", "pyproject.toml", "setup.py"];
34/// Marker files for Rust projects, checked in order.
35const RUST_MARKERS: &[&str] = &["Cargo.toml"];
36/// Marker files for Go projects, checked in order.
37const GO_MARKERS: &[&str] = &["go.mod"];
38/// Marker files for Java projects, checked in order.
39const JAVA_MARKERS: &[&str] = &["pom.xml", "build.gradle", "build.gradle.kts"];
40/// Marker files for Docker projects, checked in order.
41const DOCKER_MARKERS: &[&str] = &["docker-compose.yml", "docker-compose.yaml", "Dockerfile"];
42
43/// Identifies the project stack in `repo_path`.
44///
45/// # Arguments
46///
47/// * `repo_path` — an absolute or relative path to the repository root.
48///
49/// # Returns
50///
51/// The primary [`ProjectStack`]. Returns `Unknown` (with a warning) when
52/// no recognized marker file exists.
53///
54/// ```
55/// use limitless_cli::models::ProjectStack;
56/// use limitless_cli::modules::stack_detector::detect_stack;
57///
58/// // This crate's own directory IS a Rust project.
59/// let stack = detect_stack(env!("CARGO_MANIFEST_DIR"));
60/// assert!(matches!(stack, ProjectStack::Rust { .. }));
61/// ```
62pub 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    // Collect every stack whose markers are present, in priority order.
74    // `present[0]` is therefore always the primary stack.
75    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    // Log every secondary stack as a warning.
102    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/// A supported project stack kind, ordered by detection priority.
122#[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
160// ---------------------------------------------------------------------------
161// Node.js
162// ---------------------------------------------------------------------------
163
164fn 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
173/// Resolves the Node version from `.nvmrc`, `.node-version`, or the
174/// `engines.node` field in `package.json` (in that order).
175fn 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
189/// Detects the package manager from lockfiles present in the repo. npm is
190/// the default when no lockfile pins another manager.
191fn 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
203// ---------------------------------------------------------------------------
204// Python
205// ---------------------------------------------------------------------------
206
207fn build_python_stack(root: &Path) -> ProjectStack {
208    let version = detect_python_version(root).unwrap_or_default();
209    ProjectStack::Python { version }
210}
211
212/// Resolves the Python version from `.python-version`, the `requires-python`
213/// / `[tool.poetry.dependencies] python` field in `pyproject.toml`, or the
214/// `version` key inside a virtualenv's `pyvenv.cfg` (in that order).
215fn 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
242/// Line-based scan of `pyproject.toml` for a Python version constraint.
243pub(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
276/// Line-based scan of a virtualenv `pyvenv.cfg` for the `version` key.
277fn 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
291/// Parses `key = "value"` lines, tolerating missing quotes and spaces.
292pub(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
311// ---------------------------------------------------------------------------
312// Rust
313// ---------------------------------------------------------------------------
314
315fn build_rust_stack(root: &Path) -> ProjectStack {
316    let version = detect_rust_version(root).unwrap_or_default();
317    ProjectStack::Rust { version }
318}
319
320/// Resolves the Rust version from `rust-toolchain`, `rust-toolchain.toml`,
321/// or the `rust-version` field in `Cargo.toml` (in that order).
322fn 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
378// ---------------------------------------------------------------------------
379// Shared helpers
380// ---------------------------------------------------------------------------
381
382/// Returns the trimmed content of the first existing, non-empty file among
383/// `names` (relative to `root`).
384fn 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
399/// Reads a file and strips a leading UTF-8 byte-order mark if present.
400pub(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
406/// Pulls a clean version string out of raw specifiers such as
407/// `">=18 <20"`, `"^18.12.0"`, or `"~22.4"`, returning the first
408/// token that contains a digit. Falls back to the trimmed raw input.
409pub(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
425// ---------------------------------------------------------------------------
426// CLI entry point (`limit check`)
427// ---------------------------------------------------------------------------
428
429pub 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
447/// Validates the installed runtime for the detected project stack and
448/// prints the resulting report.
449fn 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
465/// Audits the `.env` configuration and prints the resulting report.
466fn 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
485/// Audits installed dependencies for the detected stack and prints the
486/// resulting report.
487fn 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    /// A self-cleaning temporary directory for mock projects.
572    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        /// Creates a nested file, creating parent directories as needed.
593        /// Consumes `self` so chains of `.write(...)` build an owned project.
594        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    // --- Node.js -----------------------------------------------------------
615
616    #[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    // --- Python ------------------------------------------------------------
694
695    #[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    // --- Rust --------------------------------------------------------------
745
746    #[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    // --- Docker ------------------------------------------------------------
787
788    #[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    // --- Multi-stack priority ---------------------------------------------
801
802    #[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    // --- Helpers -----------------------------------------------------------
855
856    #[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        // Windows editors commonly prepend a UTF-8 BOM to `.python-version`.
868        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        // Node beats everything when every marker is present.
884        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        // Rust beats Docker when both are present (without Node/Python).
895        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    // --- Named coverage tests ----------------------------------------------
905
906    #[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        // Node beats Python when both markers are present.
947        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        // Python beats Rust when both markers are present.
956        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}