feat: port rust workspace discovery primitives

Author: JeremyDev87

crates/legolas-core/src/project_shape.rs

@@ -1,13 +1,126 @@
-use std::path::Path;
+use std::{collections::HashSet, path::Path};
 
 use serde_json::Value;
 
-use crate::{error::Result, LegolasError};
+use crate::{error::Result, workspace::exists};
 
-pub fn detect_frameworks(_project_root: &Path, _manifest: &Value) -> Result<Vec<String>> {
-    Err(LegolasError::NotImplemented("detect_frameworks"))
+struct FrameworkMarker {
+    name: &'static str,
+    packages: &'static [&'static str],
+    files: &'static [&'static str],
 }
 
-pub fn detect_package_manager(_project_root: &Path, _manifest: &Value) -> Result<String> {
-    Err(LegolasError::NotImplemented("detect_package_manager"))
+const FRAMEWORK_MARKERS: [FrameworkMarker; 9] = [
+    FrameworkMarker {
+        name: "Next.js",
+        packages: &["next"],
+        files: &["next.config.js", "next.config.mjs", "next.config.ts"],
+    },
+    FrameworkMarker {
+        name: "Vite",
+        packages: &["vite"],
+        files: &["vite.config.js", "vite.config.ts", "vite.config.mjs"],
+    },
+    FrameworkMarker {
+        name: "Webpack",
+        packages: &["webpack"],
+        files: &["webpack.config.js", "webpack.config.ts"],
+    },
+    FrameworkMarker {
+        name: "Rollup",
+        packages: &["rollup"],
+        files: &["rollup.config.js", "rollup.config.mjs", "rollup.config.ts"],
+    },
+    FrameworkMarker {
+        name: "Astro",
+        packages: &["astro"],
+        files: &["astro.config.mjs", "astro.config.ts"],
+    },
+    FrameworkMarker {
+        name: "Nuxt",
+        packages: &["nuxt"],
+        files: &["nuxt.config.ts", "nuxt.config.js"],
+    },
+    FrameworkMarker {
+        name: "React",
+        packages: &["react"],
+        files: &[],
+    },
+    FrameworkMarker {
+        name: "Vue",
+        packages: &["vue"],
+        files: &[],
+    },
+    FrameworkMarker {
+        name: "Svelte",
+        packages: &["svelte", "@sveltejs/kit"],
+        files: &[],
+    },
+];
+
+const PACKAGE_MANAGER_CHECKS: [(&str, &str); 5] = [
+    ("pnpm-lock.yaml", "pnpm"),
+    ("yarn.lock", "yarn"),
+    ("package-lock.json", "npm"),
+    ("bun.lockb", "bun"),
+    ("bun.lock", "bun"),
+];
+
+pub fn detect_frameworks(project_root: &Path, manifest: &Value) -> Result<Vec<String>> {
+    let all_dependencies = dependency_names(manifest);
+    let mut detected = Vec::new();
+
+    for marker in FRAMEWORK_MARKERS {
+        let package_hit = marker
+            .packages
+            .iter()
+            .any(|package| all_dependencies.contains(*package));
+        let file_hit = any_exists(project_root, marker.files)?;
+
+        if package_hit || file_hit {
+            detected.push(marker.name.to_string());
+        }
+    }
+
+    Ok(detected)
+}
+
+pub fn detect_package_manager(project_root: &Path, manifest: &Value) -> Result<String> {
+    if let Some(explicit) = manifest
+        .get("packageManager")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+    {
+        return Ok(explicit.to_string());
+    }
+
+    for (file, name) in PACKAGE_MANAGER_CHECKS {
+        if exists(project_root.join(file))? {
+            return Ok(name.to_string());
+        }
+    }
+
+    Ok("unknown".to_string())
+}
+
+fn dependency_names(manifest: &Value) -> HashSet<String> {
+    let mut dependencies = HashSet::new();
+
+    for field in ["dependencies", "devDependencies"] {
+        if let Some(entries) = manifest.get(field).and_then(Value::as_object) {
+            dependencies.extend(entries.keys().cloned());
+        }
+    }
+
+    dependencies
+}
+
+fn any_exists(project_root: &Path, files: &[&str]) -> Result<bool> {
+    for file in files {
+        if exists(project_root.join(file))? {
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
 }

crates/legolas-core/src/workspace.rs

@@ -1,25 +1,112 @@
-use std::path::{Path, PathBuf};
+use std::{
+    fs,
+    io::ErrorKind,
+    path::{Component, Path, PathBuf},
+};
 
 use serde::de::DeserializeOwned;
 
 use crate::{error::Result, LegolasError};
 
-pub fn find_project_root<P: AsRef<Path>>(_input_path: P) -> Result<PathBuf> {
-    Err(LegolasError::NotImplemented("find_project_root"))
+const ROOT_MARKERS: [&str; 6] = [
+    "package.json",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+];
+
+pub fn find_project_root<P: AsRef<Path>>(input_path: P) -> Result<PathBuf> {
+    let resolved = resolve_absolute(input_path.as_ref())?;
+    let mut current = normalize_to_directory(&resolved)?;
+    let initial_directory = current.clone();
+
+    loop {
+        for marker in ROOT_MARKERS {
+            if exists(current.join(marker))? {
+                return Ok(current);
+            }
+        }
+
+        let Some(parent) = current.parent() else {
+            return Ok(initial_directory);
+        };
+        let parent = parent.to_path_buf();
+
+        if parent == current {
+            return Ok(initial_directory);
+        }
+
+        current = parent;
+    }
 }
 
-pub fn read_text_if_exists<P: AsRef<Path>>(_file_path: P) -> Result<Option<String>> {
-    Err(LegolasError::NotImplemented("read_text_if_exists"))
+pub fn read_text_if_exists<P: AsRef<Path>>(file_path: P) -> Result<Option<String>> {
+    match fs::read_to_string(file_path.as_ref()) {
+        Ok(contents) => Ok(Some(contents)),
+        Err(error) if error.kind() == ErrorKind::NotFound => Ok(None),
+        Err(error) => Err(error.into()),
+    }
 }
 
-pub fn read_json_if_exists<T, P>(_file_path: P) -> Result<Option<T>>
+pub fn read_json_if_exists<T, P>(file_path: P) -> Result<Option<T>>
 where
     T: DeserializeOwned,
     P: AsRef<Path>,
 {
-    Err(LegolasError::NotImplemented("read_json_if_exists"))
+    match read_text_if_exists(file_path)? {
+        Some(contents) if contents.is_empty() => Ok(None),
+        Some(contents) => Ok(Some(serde_json::from_str(&contents)?)),
+        None => Ok(None),
+    }
+}
+
+pub fn exists<P: AsRef<Path>>(file_path: P) -> Result<bool> {
+    match fs::metadata(file_path.as_ref()) {
+        Ok(_) => Ok(true),
+        Err(_) => Ok(false),
+    }
 }
 
-pub fn exists<P: AsRef<Path>>(_file_path: P) -> Result<bool> {
-    Err(LegolasError::NotImplemented("exists"))
+fn normalize_to_directory(target_path: &Path) -> Result<PathBuf> {
+    match fs::metadata(target_path) {
+        Ok(stats) => {
+            if stats.is_dir() {
+                Ok(target_path.to_path_buf())
+            } else {
+                Ok(target_path.parent().unwrap_or(target_path).to_path_buf())
+            }
+        }
+        Err(error) if error.kind() == ErrorKind::NotFound => Err(LegolasError::PathNotFound(
+            target_path.display().to_string(),
+        )),
+        Err(error) => Err(error.into()),
+    }
+}
+
+fn resolve_absolute(input_path: &Path) -> Result<PathBuf> {
+    let absolute = if input_path.is_absolute() {
+        input_path.to_path_buf()
+    } else {
+        std::env::current_dir()?.join(input_path)
+    };
+
+    Ok(normalize_path(&absolute))
+}
+
+fn normalize_path(path: &Path) -> PathBuf {
+    let mut normalized = PathBuf::new();
+
+    for component in path.components() {
+        match component {
+            Component::CurDir => {}
+            Component::ParentDir => {
+                normalized.pop();
+            }
+            other => normalized.push(other.as_os_str()),
+        }
+    }
+
+    normalized
 }