TaskComplexity

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TaskComplexity {
    /// Docs, typos, renames — fast single-shot agent call.
    Simple,
    /// Features, refactors, integrations — TDD plan→test→implement flow.
    Standard,
    /// Bug fixes — diagnostic investigate→plan→test→fix flow.
    BugFix,
}

pub async fn classify_task(
    task: &str,
    dry_run: bool,
    trace_dir: Option<&PathBuf>,
) -> TaskComplexity {
    let lower = task.to_lowercase();

    // 1. Simple keywords (checked first — "fix typo" is Simple, not BugFix)
    if SIMPLE_KEYWORDS.iter().any(|kw| lower.contains(kw)) {
        return TaskComplexity::Simple;
    }

    // 2. BugFix keywords
    if BUGFIX_KEYWORDS.iter().any(|kw| lower.contains(kw)) {
        return TaskComplexity::BugFix;
    }

    // 3. Standard keywords
    if STANDARD_KEYWORDS.iter().any(|kw| lower.contains(kw)) {
        return TaskComplexity::Standard;
    }

    // 4. Ambiguous — use Claude to classify (or default to Simple in dry_run)
    if dry_run {
        return TaskComplexity::Simple;
    }

    // Call Claude CLI with classification prompt
    match claude_call(&prompt, "classify", trace_dir).await {
        Ok(response) => {
            let upper = response.trim().to_uppercase();
            if upper.contains("SIMPLE") {
                TaskComplexity::Simple
            } else if upper.contains("BUGFIX") {
                TaskComplexity::BugFix
            } else {
                TaskComplexity::Standard  // default for ambiguous
            }
        }
        Err(_) => TaskComplexity::Standard,  // fallback on error
    }
}

Classify this task as either SIMPLE, STANDARD, or BUGFIX.

SIMPLE = documentation changes, typo fixes, renames, formatting, trivial edits.
STANDARD = new features, refactors, integrations, anything that needs tests.
BUGFIX = fixing bugs, crashes, errors, regressions, investigating broken behavior.

Task: <user task>

Reply with ONLY the word SIMPLE, STANDARD, or BUGFIX, nothing else.

use magpie_core::pipeline::{classify_task, TaskComplexity};

let complexity = classify_task(
    "add health check endpoint",
    false,  // not dry_run
    None,   // no trace_dir
).await;

assert_eq!(complexity, TaskComplexity::Standard);  // matches "add" keyword

let complexity = classify_task(task, config.dry_run, config.trace_dir.as_ref()).await;

let (blueprint, ctx) = match complexity {
    TaskComplexity::Simple => build_main_blueprint(&trigger, config, &working_dir)?,
    TaskComplexity::Standard => build_tdd_blueprint(&trigger, config, &working_dir)?,
    TaskComplexity::BugFix => build_diagnostic_blueprint(&trigger, config, &working_dir)?,
};

let result = BlueprintRunner::new(ctx, &*sandbox).run(&blueprint).await?;

// In dry_run mode, ambiguous tasks default to Simple (skips LLM call)
let complexity = classify_task(
    "do something",  // ambiguous
    true,  // dry_run
    None,
).await;

assert_eq!(complexity, TaskComplexity::Simple);

[
    "fix typo", "fix the typo",
    "update readme", "update the readme",
    "fix docs", "fix the docs",
    "update docs", "update the docs",
    "update changelog", "update the changelog",
    "rename",
    "fix comment", "fix comments",
    "fix spelling", "fix whitespace", "fix formatting",
    "update license", "fix license",
]

[
    "fix bug", "fix the bug",
    "fix crash", "fix the crash",
    "fix error", "fix the error",
    "fix panic", "fix the panic",
    "broken", "not working",
    "regression", "debug",
    "investigate", "root cause", "diagnose",
]

[
    "add", "implement", "create", "build",
    "refactor", "migrate", "integrate", "introduce",
    "design", "architect",
    "extract", "replace", "rewrite",
    "optimize", "convert",
]