auto-detect project type and stage from repo signals

Scanner extracts richer signals: CI, tags, tests, licence,
framework deps, game engine files, notebooks. Autoscorer uses
these to infer project type (only upgrades from default oss)
and auto-promote stage based on repo maturity. Webapp detection
limited to frontend frameworks to avoid false positives from
HTTP server deps.

Author: Mark

src/autoscore.rs

@@ -1,5 +1,6 @@
 use crate::adapters;
-use crate::domain::Project;
+use crate::domain::{Project, ProjectType, RepoSignals};
+use crate::scanner;
 use crate::scoring::{distinctness, leverage, velocity};
 use crate::store::Store;
 use std::path::Path;
@@ -18,6 +19,7 @@ fn score_one(store: &Store, project: &Project, all: &[Project], fetch_remote: bo
         _ => return Ok(()),
     };
     let repo = Path::new(&path);
+    let signals = scanner::scan_signals(repo);
 
     if let Some(vel) = velocity::compute(repo) {
         store.update_axis(project.id, "velocity", Some(vel.score))
@@ -41,37 +43,54 @@ fn score_one(store: &Store, project: &Project, all: &[Project], fetch_remote: bo
         }
     }
 
-    if project.stage == 0 {
-        if let Some(suggested) = suggest_stage(repo) {
-            if suggested > project.stage {
-                store.record_stage_event(
-                    project.id,
-                    project.stage,
-                    suggested,
-                    Some("autoscore suggestion"),
-                ).map_err(|e| e.to_string())?;
-            }
-        }
+    let detected_type = detect_project_type(&signals);
+    if detected_type != ProjectType::Oss && project.project_type == ProjectType::Oss {
+        store.update_project_type(project.id, &detected_type)
+            .map_err(|e| e.to_string())?;
+    }
+
+    let suggested = suggest_stage(&signals);
+    if suggested > project.stage {
+        store.update_stage(project.id, suggested)
+            .map_err(|e| e.to_string())?;
+        store.record_stage_event(
+            project.id,
+            project.stage,
+            suggested,
+            Some("auto-detected from repo signals"),
+        ).map_err(|e| e.to_string())?;
     }
 
     Ok(())
 }
 
-fn suggest_stage(path: &Path) -> Option<u8> {
-    let has_readme = path.join("README.md").exists();
-    let has_src = path.join("src").is_dir();
-    let has_tests = path.join("tests").is_dir();
+fn detect_project_type(signals: &RepoSignals) -> ProjectType {
+    if signals.has_game_engine {
+        return ProjectType::Game;
+    }
+    if signals.has_notebooks {
+        return ProjectType::Research;
+    }
+    if signals.has_webapp_framework {
+        return ProjectType::Webapp;
+    }
+    ProjectType::Oss
+}
 
-    if !has_src && !has_readme {
-        return Some(0);
+fn suggest_stage(signals: &RepoSignals) -> u8 {
+    if signals.has_tags && signals.has_ci && signals.has_readme {
+        return 4;
     }
-    if has_src && has_readme && has_tests {
-        return Some(2);
+    if signals.has_ci || (signals.has_tags && signals.has_tests) {
+        return 3;
     }
-    if has_src || has_readme {
-        return Some(1);
+    if signals.has_src && signals.has_readme && signals.has_tests {
+        return 2;
     }
-    Some(0)
+    if signals.has_src || signals.has_readme {
+        return 1;
+    }
+    0
 }
 
 #[cfg(test)]
@@ -106,6 +125,12 @@ mod tests {
         }
     }
 
+    fn signals(f: impl FnOnce(&mut RepoSignals)) -> RepoSignals {
+        let mut s = RepoSignals::default();
+        f(&mut s);
+        s
+    }
+
     #[test]
     fn score_one_skips_no_path() {
         let store = Store::open_in_memory().unwrap();
@@ -114,25 +139,70 @@ mod tests {
     }
 
     #[test]
-    fn suggest_stage_empty_dir_is_zero() {
-        let tmp = tempfile::tempdir().unwrap();
-        assert_eq!(suggest_stage(tmp.path()), Some(0));
+    fn stage_empty_is_zero() {
+        assert_eq!(suggest_stage(&RepoSignals::default()), 0);
+    }
+
+    #[test]
+    fn stage_src_only_is_one() {
+        assert_eq!(suggest_stage(&signals(|s| s.has_src = true)), 1);
+    }
+
+    #[test]
+    fn stage_src_readme_tests_is_two() {
+        assert_eq!(suggest_stage(&signals(|s| {
+            s.has_src = true;
+            s.has_readme = true;
+            s.has_tests = true;
+        })), 2);
+    }
+
+    #[test]
+    fn stage_with_ci_is_three() {
+        assert_eq!(suggest_stage(&signals(|s| {
+            s.has_src = true;
+            s.has_readme = true;
+            s.has_tests = true;
+            s.has_ci = true;
+        })), 3);
+    }
+
+    #[test]
+    fn stage_tags_ci_readme_is_four() {
+        assert_eq!(suggest_stage(&signals(|s| {
+            s.has_src = true;
+            s.has_readme = true;
+            s.has_tests = true;
+            s.has_ci = true;
+            s.has_tags = true;
+        })), 4);
+    }
+
+    #[test]
+    fn type_game_engine_detected() {
+        assert_eq!(detect_project_type(&signals(|s| s.has_game_engine = true)), ProjectType::Game);
+    }
+
+    #[test]
+    fn type_notebooks_detected_as_research() {
+        assert_eq!(detect_project_type(&signals(|s| s.has_notebooks = true)), ProjectType::Research);
+    }
+
+    #[test]
+    fn type_webapp_framework_detected() {
+        assert_eq!(detect_project_type(&signals(|s| s.has_webapp_framework = true)), ProjectType::Webapp);
     }
 
     #[test]
-    fn suggest_stage_with_src_and_readme_is_one() {
-        let tmp = tempfile::tempdir().unwrap();
-        std::fs::create_dir(tmp.path().join("src")).unwrap();
-        std::fs::write(tmp.path().join("README.md"), "hello").unwrap();
-        assert_eq!(suggest_stage(tmp.path()), Some(1));
+    fn type_default_is_oss() {
+        assert_eq!(detect_project_type(&RepoSignals::default()), ProjectType::Oss);
     }
 
     #[test]
-    fn suggest_stage_with_tests_is_two() {
-        let tmp = tempfile::tempdir().unwrap();
-        std::fs::create_dir(tmp.path().join("src")).unwrap();
-        std::fs::create_dir(tmp.path().join("tests")).unwrap();
-        std::fs::write(tmp.path().join("README.md"), "hello").unwrap();
-        assert_eq!(suggest_stage(tmp.path()), Some(2));
+    fn game_engine_takes_priority_over_webapp() {
+        assert_eq!(detect_project_type(&signals(|s| {
+            s.has_game_engine = true;
+            s.has_webapp_framework = true;
+        })), ProjectType::Game);
     }
 }

src/domain.rs

@@ -251,6 +251,24 @@ pub struct ScanResult {
     pub last_commit_date: Option<chrono::NaiveDate>,
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct RepoSignals {
+    pub has_src: bool,
+    pub has_readme: bool,
+    pub has_tests: bool,
+    pub has_ci: bool,
+    pub has_tags: bool,
+    pub tag_count: usize,
+    pub has_license: bool,
+    pub has_changelog: bool,
+    pub has_cargo_toml: bool,
+    pub has_package_json: bool,
+    pub has_game_engine: bool,
+    pub has_notebooks: bool,
+    pub has_webapp_framework: bool,
+    pub contributor_count: usize,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/scanner.rs

@@ -1,4 +1,4 @@
-use crate::domain::ScanResult;
+use crate::domain::{RepoSignals, ScanResult};
 use chrono::NaiveDate;
 use std::path::Path;
 use std::process::Command;
@@ -9,6 +9,155 @@ pub fn scan_project(project_path: &str) -> ScanResult {
     ScanResult { last_commit_date }
 }
 
+pub fn scan_signals(path: &Path) -> RepoSignals {
+    let has_src = path.join("src").is_dir();
+    let has_readme = has_file_prefix(path, "readme");
+    let has_tests = path.join("tests").is_dir()
+        || path.join("test").is_dir()
+        || path.join("__tests__").is_dir()
+        || path.join("spec").is_dir();
+    let has_ci = path.join(".github/workflows").is_dir()
+        || path.join(".gitlab-ci.yml").exists()
+        || path.join("Jenkinsfile").exists()
+        || path.join(".circleci").is_dir();
+    let has_license = has_file_prefix(path, "licen");
+    let has_changelog = has_file_prefix(path, "changelog")
+        || has_file_prefix(path, "changes");
+    let has_cargo_toml = path.join("Cargo.toml").exists();
+    let has_package_json = path.join("package.json").exists();
+    let has_game_engine = path.join("project.godot").exists()
+        || has_bevy_dep(path)
+        || path.join("Assets").is_dir() && path.join("ProjectSettings").is_dir();
+    let has_notebooks = has_extension_in_dir(path, "ipynb");
+    let has_webapp_framework = detect_webapp_framework(path);
+    let (has_tags, tag_count) = count_git_tags(path);
+    let contributor_count = count_contributors(path);
+
+    RepoSignals {
+        has_src,
+        has_readme,
+        has_tests,
+        has_ci,
+        has_tags,
+        tag_count,
+        has_license,
+        has_changelog,
+        has_cargo_toml,
+        has_package_json,
+        has_game_engine,
+        has_notebooks,
+        has_webapp_framework,
+        contributor_count,
+    }
+}
+
+fn has_file_prefix(path: &Path, prefix: &str) -> bool {
+    let entries = match std::fs::read_dir(path) {
+        Ok(e) => e,
+        Err(_) => return false,
+    };
+    for entry in entries.flatten() {
+        let name = entry.file_name().to_string_lossy().to_lowercase();
+        if name.starts_with(prefix) {
+            return true;
+        }
+    }
+    false
+}
+
+fn has_extension_in_dir(path: &Path, ext: &str) -> bool {
+    let entries = match std::fs::read_dir(path) {
+        Ok(e) => e,
+        Err(_) => return false,
+    };
+    for entry in entries.flatten() {
+        if let Some(e) = entry.path().extension() {
+            if e.to_string_lossy().eq_ignore_ascii_case(ext) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn has_bevy_dep(path: &Path) -> bool {
+    let cargo = path.join("Cargo.toml");
+    if let Ok(content) = std::fs::read_to_string(cargo) {
+        return content.contains("bevy");
+    }
+    false
+}
+
+fn detect_webapp_framework(path: &Path) -> bool {
+    let pkg = path.join("package.json");
+    if let Ok(content) = std::fs::read_to_string(pkg) {
+        let frameworks = ["react", "vue", "svelte", "next", "nuxt", "angular", "express", "fastify"];
+        let lower = content.to_lowercase();
+        if frameworks.iter().any(|f| lower.contains(f)) {
+            return true;
+        }
+    }
+    let cargo = path.join("Cargo.toml");
+    if let Ok(content) = std::fs::read_to_string(cargo) {
+        let frameworks = ["leptos", "yew", "dioxus"];
+        let in_deps = extract_deps_section(&content);
+        if frameworks.iter().any(|f| in_deps.contains(f)) {
+            return true;
+        }
+    }
+    false
+}
+
+fn extract_deps_section(toml: &str) -> String {
+    let mut in_deps = false;
+    let mut result = String::new();
+    for line in toml.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('[') {
+            in_deps = trimmed == "[dependencies]";
+            continue;
+        }
+        if in_deps {
+            result.push_str(&trimmed.to_lowercase());
+            result.push('\n');
+        }
+    }
+    result
+}
+
+fn count_git_tags(path: &Path) -> (bool, usize) {
+    let output = Command::new("git")
+        .args(["tag", "--list"])
+        .current_dir(path)
+        .output();
+    match output {
+        Ok(o) if o.status.success() => {
+            let count = String::from_utf8_lossy(&o.stdout)
+                .lines()
+                .filter(|l| !l.trim().is_empty())
+                .count();
+            (count > 0, count)
+        }
+        _ => (false, 0),
+    }
+}
+
+fn count_contributors(path: &Path) -> usize {
+    let output = Command::new("git")
+        .args(["shortlog", "-sn", "--no-merges", "HEAD"])
+        .current_dir(path)
+        .output();
+    match output {
+        Ok(o) if o.status.success() => {
+            String::from_utf8_lossy(&o.stdout)
+                .lines()
+                .filter(|l| !l.trim().is_empty())
+                .count()
+        }
+        _ => 0,
+    }
+}
+
 pub fn get_last_commit_date(path: &Path) -> Option<NaiveDate> {
     let output = Command::new("git")
         .args(["log", "-1", "--format=%ad", "--date=format:%Y-%m-%d"])