zesdex/crates/zesdex-backend/src/app/workflow/hive_mind/complexity.rs

//! Request-complexity heuristic for the Hive Mind.
//!
//! `is_complex_request` determines whether LO's request is worth stirring
//! the Hive for, based on string heuristics (length, keywords, sentence
//! count).

/// Determine whether LO's request is worth stirring the Hive for. The
/// Hive's plan shape (cycle count, directives, access tiers) is entirely
/// up to the Core Intelligence; this only gates whether the Hive is asked
/// to design one at all.
///
/// Simple = single file, minor fix, quick lookup, config change — handle
/// inline without disturbing the Hive.
/// Complex = new feature, multi-file refactor, architecture change — the
/// Hive must be deployed.
///
/// Heuristics:
/// - Very short requests (< 10 chars) are never complex — the Hive rests.
/// - Negative keywords (simple/trivial/typo/quick) skip planning.
/// - Positive keywords (refactor/api/implement/architecture) rouse the Hive.
/// - Multi-sentence requests are more likely complex.
pub fn is_complex_request(request: &str) -> bool {
    let trimmed = request.trim();
    // Very short requests are never complex
    if trimmed.len() < 10 {
        return false;
    }
    // Single-line simple update patterns
    let lower = trimmed.to_lowercase();
    let negative_keywords = [
        "simple",
        "trivial",
        "typo",
        "just a",
        "only a",
        "minor",
        "quick",
        "tiny",
        "small fix",
        "rename",
        "nitpick",
        "cosmetic",
        "formatting",
        "spelling",
        "grammar",
        "bump",
        "version bump",
        "update comment",
    ];
    if negative_keywords.iter().any(|k| lower.contains(k)) {
        return false;
    }
    // Multi-line/multi-sentence → likely complex
    let sentences = trimmed
        .split(['.', '!', '?'])
        .filter(|s| !s.trim().is_empty())
        .count();
    if sentences >= 3 {
        return true;
    }
    // Positive complexity keywords
    let complexity_keywords = [
        "refactor",
        "redesign",
        "architecture",
        "feature",
        "implement",
        "migrate",
        "restructure",
        "rewrite",
        "new module",
        "new component",
        "scaffold",
        "multi",
        "multiple files",
        "api",
        "endpoint",
        "integration",
        "system",
        "workflow",
        "pipeline",
        "database",
        "authentication",
        "authorization",
        "full stack",
    ];
    complexity_keywords.iter().any(|k| lower.contains(k))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_is_complex_request_too_short() {
        assert!(!is_complex_request("abc"));
    }

    #[test]
    fn test_is_complex_request_simple_keywords() {
        assert!(!is_complex_request("just a simple update to the readme"));
        assert!(!is_complex_request("minor typo fix in main.rs"));
    }

    #[test]
    fn test_is_complex_request_multi_sentence() {
        assert!(is_complex_request(
            "This is sentence one. This is sentence two. This is sentence three."
        ));
    }

    #[test]
    fn test_is_complex_request_complex_keywords() {
        assert!(is_complex_request("implement user authentication endpoint"));
        assert!(is_complex_request("refactor the whole engine module"));
    }
}