fix: scope refactor generation before planning fixes

Author: chubes4

src/core/code_audit/report.rs

@@ -176,7 +176,11 @@ pub fn compute_fixability(result: &CodeAuditResult) -> Option<AuditFixability> {
     }
 
     // Generate fix plan (dry-run — never writes)
-    let mut fix_result = crate::refactor::plan::generate::generate_audit_fixes(result, source_path);
+    let mut fix_result = crate::refactor::plan::generate::generate_audit_fixes(
+        result,
+        source_path,
+        &crate::refactor::auto::FixPolicy::default(),
+    );
 
     if fix_result.fixes.is_empty() && fix_result.new_files.is_empty() {
         return None;

src/core/refactor/add.rs

@@ -48,7 +48,7 @@ pub fn fixes_from_audit(audit: &CodeAuditResult, write: bool) -> Result<FixResul
         ));
     }
 
-    let mut fix_result = plan::generate_audit_fixes(audit, root);
+    let mut fix_result = plan::generate_audit_fixes(audit, root, &auto::FixPolicy::default());
 
     if write && !fix_result.fixes.is_empty() {
         let applied = auto::apply_fixes(&mut fix_result.fixes, root);

src/core/refactor/plan/generate/mod.rs

@@ -12,7 +12,7 @@ mod signatures;
 mod test_gen_fixes;
 
 use crate::code_audit::{AuditFinding, CodeAuditResult};
-use crate::core::refactor::auto::{DecomposeFixPlan, Fix, FixResult, SkippedFile};
+use crate::core::refactor::auto::{DecomposeFixPlan, Fix, FixPolicy, FixResult, SkippedFile};
 use crate::core::refactor::decompose;
 use crate::core::refactor::plan::file_intent::{FileIntent, FileIntentMap};
 use std::path::Path;
@@ -30,8 +30,8 @@ pub(crate) use signatures::{
     primary_type_name_from_declaration,
 };
 
-pub fn generate_audit_fixes(result: &CodeAuditResult, root: &Path) -> FixResult {
-    generate_fixes_impl(result, root)
+pub fn generate_audit_fixes(result: &CodeAuditResult, root: &Path, policy: &FixPolicy) -> FixResult {
+    generate_fixes_impl(result, root, policy)
 }
 
 pub(crate) fn merge_fixes_per_file(fixes: Vec<Fix>) -> Vec<Fix> {
@@ -63,9 +63,16 @@ pub(crate) fn merge_fixes_per_file(fixes: Vec<Fix>) -> Vec<Fix> {
         .collect()
 }
 
-pub(crate) fn generate_fixes_impl(result: &CodeAuditResult, root: &Path) -> FixResult {
+pub(crate) fn generate_fixes_impl(result: &CodeAuditResult, root: &Path, policy: &FixPolicy) -> FixResult {
     let mut fixes = Vec::new();
     let mut skipped = Vec::new();
+    let finding_enabled = |finding: &AuditFinding| {
+        policy
+            .only
+            .as_ref()
+            .is_none_or(|only| only.contains(finding))
+            && !policy.exclude.contains(finding)
+    };
 
     // ── Phase 0: Build file intent map ─────────────────────────────────
     // Identify structural operations (decompose, move, delete) planned for
@@ -75,6 +82,9 @@ pub(crate) fn generate_fixes_impl(result: &CodeAuditResult, root: &Path) -> FixR
     // declarative conflict rules.
     let mut intent_map = FileIntentMap::new();
     for finding in &result.findings {
+        if !finding_enabled(&finding.kind) {
+            continue;
+        }
         if matches!(
             finding.kind,
             AuditFinding::GodFile | AuditFinding::HighItemCount
@@ -87,68 +97,100 @@ pub(crate) fn generate_fixes_impl(result: &CodeAuditResult, root: &Path) -> FixR
     // ── Phase 1: Generate all content fixes ────────────────────────────
     // Fixers run freely against the audit data. Conflicts with structural
     // intents are resolved after generation, not during.
-    apply_convention_fixes(result, root, &mut fixes, &mut skipped);
+    if policy.only.is_none() && policy.exclude.is_empty() {
+        apply_convention_fixes(result, root, &mut fixes, &mut skipped);
+    }
 
     let mut new_files = Vec::new();
-    generate_unreferenced_export_fixes(result, root, &mut fixes, &mut skipped);
-    generate_duplicate_function_fixes(result, root, &mut fixes, &mut new_files, &mut skipped);
-    orphaned_test_fixes::generate_orphaned_test_fixes(result, root, &mut fixes, &mut skipped);
+    if finding_enabled(&AuditFinding::UnreferencedExport) {
+        generate_unreferenced_export_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::DuplicateFunction) {
+        generate_duplicate_function_fixes(result, root, &mut fixes, &mut new_files, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::OrphanedTest) {
+        orphaned_test_fixes::generate_orphaned_test_fixes(result, root, &mut fixes, &mut skipped);
+    }
 
     // ── Phase 2: Build decompose plans ─────────────────────────────────
     let mut decompose_plans = Vec::new();
     let mut decompose_seen = std::collections::HashSet::new();
-    for finding in &result.findings {
-        if !matches!(
-            finding.kind,
-            AuditFinding::GodFile | AuditFinding::HighItemCount
-        ) {
-            continue;
-        }
-        // A file can trigger both GodFile and HighItemCount — only plan once.
-        if decompose_seen.contains(&finding.file) {
-            continue;
-        }
-        let is_test = crate::code_audit::walker::is_test_path(&finding.file);
-        if is_test {
-            continue;
-        }
-        match decompose::build_plan(&finding.file, root, "grouped") {
-            Ok(plan) => {
-                if plan.groups.len() > 1 {
+    if finding_enabled(&AuditFinding::GodFile) || finding_enabled(&AuditFinding::HighItemCount) {
+        for finding in &result.findings {
+            if !finding_enabled(&finding.kind) {
+                continue;
+            }
+            if !matches!(
+                finding.kind,
+                AuditFinding::GodFile | AuditFinding::HighItemCount
+            ) {
+                continue;
+            }
+            if decompose_seen.contains(&finding.file) {
+                continue;
+            }
+            let is_test = crate::code_audit::walker::is_test_path(&finding.file);
+            if is_test {
+                continue;
+            }
+            match decompose::build_plan(&finding.file, root, "grouped") {
+                Ok(plan) => {
+                    if plan.groups.len() > 1 {
+                        decompose_seen.insert(finding.file.clone());
+                        decompose_plans.push(DecomposeFixPlan {
+                            file: finding.file.clone(),
+                            plan,
+                            source_finding: finding.kind.clone(),
+                            applied: false,
+                        });
+                    }
+                }
+                Err(error) => {
                     decompose_seen.insert(finding.file.clone());
-                    decompose_plans.push(DecomposeFixPlan {
+                    skipped.push(SkippedFile {
                         file: finding.file.clone(),
-                        plan,
-                        source_finding: finding.kind.clone(),
-                        applied: false,
+                        reason: format!("Decompose plan failed: {}", error),
                     });
                 }
             }
-            Err(error) => {
-                decompose_seen.insert(finding.file.clone());
-                skipped.push(SkippedFile {
-                    file: finding.file.clone(),
-                    reason: format!("Decompose plan failed: {}", error),
-                });
-            }
         }
     }
 
-    doc_fixes::apply_stale_doc_reference_fixes(result, &mut fixes);
-    doc_fixes::apply_broken_doc_reference_fixes(result, root, &mut fixes);
-    parameter_fixes::generate_parameter_fixes(result, root, &mut fixes, &mut skipped);
-    test_gen_fixes::generate_test_file_fixes(
-        result,
-        root,
-        &mut new_files,
-        &mut fixes,
-        &mut skipped,
-    );
-    test_gen_fixes::generate_test_method_fixes(result, root, &mut fixes, &mut skipped);
-    compiler_warning_fixes::generate_compiler_warning_fixes(result, root, &mut fixes, &mut skipped);
-    comment_fixes::generate_comment_fixes(result, root, &mut fixes, &mut skipped);
-    near_duplicate_fixes::generate_near_duplicate_fixes(result, root, &mut fixes, &mut skipped);
-    intra_duplicate_fixes::generate_intra_duplicate_fixes(result, root, &mut fixes, &mut skipped);
+    if finding_enabled(&AuditFinding::StaleDocReference) {
+        doc_fixes::apply_stale_doc_reference_fixes(result, &mut fixes);
+    }
+    if finding_enabled(&AuditFinding::BrokenDocReference) {
+        doc_fixes::apply_broken_doc_reference_fixes(result, root, &mut fixes);
+    }
+    if finding_enabled(&AuditFinding::UnusedParameter) {
+        parameter_fixes::generate_parameter_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::MissingTestFile) {
+        test_gen_fixes::generate_test_file_fixes(
+            result,
+            root,
+            &mut new_files,
+            &mut fixes,
+            &mut skipped,
+        );
+    }
+    if finding_enabled(&AuditFinding::MissingTestMethod) {
+        test_gen_fixes::generate_test_method_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::CompilerWarning) {
+        compiler_warning_fixes::generate_compiler_warning_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::TodoMarker)
+        || finding_enabled(&AuditFinding::LegacyComment)
+    {
+        comment_fixes::generate_comment_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::NearDuplicate) {
+        near_duplicate_fixes::generate_near_duplicate_fixes(result, root, &mut fixes, &mut skipped);
+    }
+    if finding_enabled(&AuditFinding::IntraMethodDuplicate) {
+        intra_duplicate_fixes::generate_intra_duplicate_fixes(result, root, &mut fixes, &mut skipped);
+    }
 
     let mut fixes = merge_fixes_per_file(fixes);
 

src/core/refactor/plan/planner.rs

@@ -589,11 +589,11 @@ fn plan_audit_stage(
         crate::code_audit::audit_path_with_id(component_id, &root.to_string_lossy())?
     };
 
-    let mut fix_result = super::generate::generate_audit_fixes(&result, root);
     let policy = fixer::FixPolicy {
         only: (!only.is_empty()).then_some(only.to_vec()),
         exclude: exclude.to_vec(),
     };
+    let mut fix_result = super::generate::generate_audit_fixes(&result, root, &policy);
     let preflight_context = fixer::PreflightContext { root };
     let (fix_result, policy_summary, changed_files, stage_warnings): (
         fixer::FixResult,

src/core/refactor/plan/verify.rs

@@ -121,12 +121,12 @@ pub fn run_audit_refactor(
 
         iterations.push(iteration_summary);
     } else {
-        let root = Path::new(&current_result.source_path);
-        let mut fix_result = super::generate::generate_audit_fixes(&current_result, root);
         let policy = fixer::FixPolicy {
             only: (!only_kinds.is_empty()).then_some(only_kinds.to_vec()),
             exclude: exclude_kinds.to_vec(),
         };
+        let root = Path::new(&current_result.source_path);
+        let mut fix_result = super::generate::generate_audit_fixes(&current_result, root, &policy);
         let preflight_context = fixer::PreflightContext { root };
         final_policy_summary =
             fixer::apply_fix_policy(&mut fix_result, false, &policy, &preflight_context);
@@ -151,12 +151,12 @@ fn run_fix_iteration(
     fixer::PolicySummary,
     AuditRefactorIterationSummary,
 )> {
-    let root = Path::new(&audit_result.source_path);
-    let mut fix_result = super::generate::generate_audit_fixes(audit_result, root);
     let policy = fixer::FixPolicy {
         only: (!only_kinds.is_empty()).then_some(only_kinds.to_vec()),
         exclude: exclude_kinds.to_vec(),
     };
+    let root = Path::new(&audit_result.source_path);
+    let mut fix_result = super::generate::generate_audit_fixes(audit_result, root, &policy);
     let preflight_context = fixer::PreflightContext { root };
     let policy_summary =
         fixer::apply_fix_policy(&mut fix_result, true, &policy, &preflight_context);