Crate standarbuild_detect 

Detect the kind of a project (Rust, Node, Bun, Deno, Python, Lua, C, C++, or any custom kind you register) AND the workspace organizer (Cargo, Npm, Pnpm, Yarn, Bun, Deno, Go, Lerna, Nx, Turborepo, Mira) from on-disk signals, and scan a polyglot monorepo recursively.

Two ways in

For the common case where the built-ins are enough:

use std::path::Path;
use standarbuild_detect::{detect_in_dir, discover, DiscoverOptions};

for hit in detect_in_dir(Path::new("./my-app")) {
    println!("{:?}", hit);
}

let result = discover(Path::new("./my-monorepo"), &DiscoverOptions::default());
for p in &result.projects {
    println!("{} -> {} at {} (member_of {:?})", p.label, p.kind, p.rel_path, p.member_of);
}
for w in &result.workspaces {
    println!("{} workspace at {:?} with {} members", w.kind, w.root, w.members.len());
}

To extend the detection space (custom kinds, custom precedence, or disabling a built-in), build your own registry:

use std::path::Path;
use standarbuild_detect::{
    builtin, Detector, DetectorHit, DetectorRegistry, KindId,
};

struct WgslDetector;
impl Detector for WgslDetector {
    fn name(&self) -> &str { "wgsl" }
    fn priority(&self) -> i32 { 60 }
    fn detect(&self, dir: &Path) -> Option<DetectorHit> {
        dir.join("shaders").is_dir().then(|| DetectorHit::Project {
            kind: KindId::custom("wgsl"),
            signals: vec!["shaders/".into()],
        })
    }
}

let mut registry = DetectorRegistry::with_builtins();
registry.remove("c"); // we don't care about plain C
registry.add(WgslDetector);

Features

• serde (default) — derives Serialize/Deserialize on the public types and exposes POSIX-path serializers in path_norm. Disable with default-features = false for the leanest dep tree.

Breaking changes vs 0.2

• Detector::kind() -> KindId was replaced by Detector::name() -> &str (string identifier for registry removal). Each detector decides what facet(s) to emit via its DetectorHit return.
• Detector::detect() -> Option<DetectMatch> is now Option<DetectorHit>. DetectMatch is gone; DetectorHit carries project + workspace info.
• DetectorRegistry::detect(dir) returns Vec<DetectorHit> (previously Option<DetectMatch>) so multiple facets at the same dir (e.g. Cargo workspace + npm workspace) can all surface.
• discover() / discover_with() return DetectionResult { projects, workspaces } instead of Vec<Discovered>. Discovered was renamed to ProjectInfo and gained member_of: Vec<PathBuf>.
• DetectorRegistry::remove now takes &str (detector name) instead of &KindId, and returns the count of removed detectors instead of a bool.

Re-exports

pub use detect::detect_in_dir;

pub use detector::Detector;

pub use detector::DetectorHit;

pub use detector::DetectorRegistry;

pub use discover::discover;

pub use discover::discover_with;

pub use discover::DetectionResult;

pub use discover::DiscoverOptions;

pub use discover::LabelStrategy;

pub use discover::ProjectInfo;

pub use discover::WorkspaceInfo;

pub use kind::KindId;

pub use path_norm::to_posix;

pub use path_norm::serialize_path;

pub use path_norm::serialize_path_opt;

pub use workspace::WorkspaceKindId;

Modules

builtin

Built-in detectors for the project AND workspace kinds the library knows about. Each type is pub and Default-constructible so callers can pick and choose, tweak the registry, or use register_all to install the whole lot.

detect

Convenience entry point: build a built-in registry on the fly and run a single detection on one directory. For repeated calls, build a crate::DetectorRegistry once and reuse it.

detector

Detector trait + DetectorRegistry for composing project-AND-workspace detection. Built-ins live in crate::builtin; downstream crates implement Detector for any extra kind (project or workspace, or both).

discover

Recursive workspace scan: starting from a root directory, walk down up to max_depth levels, run every registered crate::Detector, and build a DetectionResult containing both the projects and the workspace manifests found.

kind

Opaque string-based identifier for a project kind. Built-in kinds are exposed as const items; custom kinds (KindId::custom("wgsl")) let downstream crates extend the detection space without touching the lib.

path_norm

POSIX-style path normalisation. Strips Windows verbatim prefixes (\\?\), drops CurDir segments, and replaces \ with /. Useful when emitting paths into JSON / cross-platform tooling.

workspace

WorkspaceKindId — twin of crate::KindId for monorepo organizers.