refactor: split feedback command helpers

Separate feedback file loading and ID normalization from store persistence so command-side wiring stays distinct from mutation logic.

Made-with: Cursor

Author: haasonsaas

TODO.md

@@ -85,7 +85,7 @@
 - [x] `src/commands/pr/gh.rs`: carve PR resolution, diff fetching, and metadata fetching.
 - [x] `src/commands/git/suggest.rs`: split commit-message prompting from PR-title prompting and response extraction.
 - [x] `src/commands/review/command.rs`: split review/check/compare entrypoints if they keep diverging.
-- [ ] `src/commands/misc/feedback/command.rs`: separate file loading/ID normalization from store persistence.
+- [x] `src/commands/misc/feedback/command.rs`: separate file loading/ID normalization from store persistence.
 - [ ] `src/commands/misc/feedback/apply.rs`: split acceptance/rejection counters from store mutation helpers.
 - [ ] `src/commands/misc/discussion/command.rs`: separate the interactive loop from single-shot execution.
 - [ ] `src/commands/misc/discussion/selection.rs`: split file loading/ID repair from selection rules.

src/commands/misc/feedback/command.rs

@@ -1,60 +1,45 @@
+#[path = "command/input.rs"]
+mod input;
+#[path = "command/store.rs"]
+mod store;
+
 use anyhow::Result;
 use std::path::PathBuf;
 
 use crate::config;
-use crate::core;
 use crate::review;
 
-use super::apply::{apply_feedback_accept, apply_feedback_reject};
 use super::conventions::record_convention_feedback;
+use input::{load_feedback_command_input, FeedbackAction};
+use store::apply_feedback_store_update;
 
 pub async fn feedback_command(
     mut config: config::Config,
     accept: Option<PathBuf>,
     reject: Option<PathBuf>,
     feedback_path: Option<PathBuf>,
 ) -> Result<()> {
-    let (action, input_path) = match (accept, reject) {
-        (Some(path), None) => ("accept", path),
-        (None, Some(path)) => ("reject", path),
-        _ => {
-            anyhow::bail!("Specify exactly one of --accept or --reject");
-        }
-    };
-
-    let feedback_path = feedback_path.unwrap_or_else(|| config.feedback_path.clone());
-    config.feedback_path = feedback_path.clone();
-    let content = tokio::fs::read_to_string(&input_path).await?;
-    let mut comments: Vec<core::Comment> = serde_json::from_str(&content)?;
-
-    for comment in &mut comments {
-        if comment.id.trim().is_empty() {
-            comment.id = core::comment::compute_comment_id(
-                &comment.file_path,
-                &comment.content,
-                &comment.category,
-            );
-        }
-    }
-
-    let mut store = review::load_feedback_store_from_path(&feedback_path);
-    let updated = if action == "accept" {
-        apply_feedback_accept(&mut store, &comments)
-    } else {
-        apply_feedback_reject(&mut store, &comments)
-    };
-
-    review::save_feedback_store(&feedback_path, &store)?;
+    let command_input = load_feedback_command_input(&config, accept, reject, feedback_path).await?;
+    config.feedback_path = command_input.feedback_path.clone();
+
+    let updated = apply_feedback_store_update(
+        &command_input.feedback_path,
+        command_input.action,
+        &command_input.comments,
+    )?;
+
     println!(
         "Updated feedback store at {} ({} {} comment(s))",
-        feedback_path.display(),
+        command_input.feedback_path.display(),
         updated,
-        action
+        command_input.action.as_str()
     );
 
-    let is_accepted = action == "accept";
-    let _ = review::record_semantic_feedback_examples(&config, &comments, is_accepted).await;
-    record_convention_feedback(&config, &comments, is_accepted);
+    let is_accepted = matches!(command_input.action, FeedbackAction::Accept);
+    let _ =
+        review::record_semantic_feedback_examples(&config, &command_input.comments, is_accepted)
+            .await;
+    record_convention_feedback(&config, &command_input.comments, is_accepted);
 
     Ok(())
 }

src/commands/misc/feedback/command/input.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+use std::path::PathBuf;
+
+use crate::config;
+use crate::core;
+
+#[derive(Clone, Copy)]
+pub(super) enum FeedbackAction {
+    Accept,
+    Reject,
+}
+
+impl FeedbackAction {
+    pub(super) fn as_str(&self) -> &'static str {
+        match self {
+            Self::Accept => "accept",
+            Self::Reject => "reject",
+        }
+    }
+}
+
+pub(super) struct FeedbackCommandInput {
+    pub(super) action: FeedbackAction,
+    pub(super) feedback_path: PathBuf,
+    pub(super) comments: Vec<core::Comment>,
+}
+
+pub(super) async fn load_feedback_command_input(
+    config: &config::Config,
+    accept: Option<PathBuf>,
+    reject: Option<PathBuf>,
+    feedback_path: Option<PathBuf>,
+) -> Result<FeedbackCommandInput> {
+    let (action, input_path) = match (accept, reject) {
+        (Some(path), None) => (FeedbackAction::Accept, path),
+        (None, Some(path)) => (FeedbackAction::Reject, path),
+        _ => {
+            anyhow::bail!("Specify exactly one of --accept or --reject");
+        }
+    };
+
+    let feedback_path = feedback_path.unwrap_or_else(|| config.feedback_path.clone());
+    let content = tokio::fs::read_to_string(&input_path).await?;
+    let mut comments: Vec<core::Comment> = serde_json::from_str(&content)?;
+    normalize_comment_ids(&mut comments);
+
+    Ok(FeedbackCommandInput {
+        action,
+        feedback_path,
+        comments,
+    })
+}
+
+fn normalize_comment_ids(comments: &mut [core::Comment]) {
+    for comment in comments {
+        if comment.id.trim().is_empty() {
+            comment.id = core::comment::compute_comment_id(
+                &comment.file_path,
+                &comment.content,
+                &comment.category,
+            );
+        }
+    }
+}

src/commands/misc/feedback/command/store.rs

@@ -0,0 +1,23 @@
+use anyhow::Result;
+use std::path::Path;
+
+use crate::core;
+use crate::review;
+
+use super::super::apply::{apply_feedback_accept, apply_feedback_reject};
+use super::input::FeedbackAction;
+
+pub(super) fn apply_feedback_store_update(
+    feedback_path: &Path,
+    action: FeedbackAction,
+    comments: &[core::Comment],
+) -> Result<usize> {
+    let mut store = review::load_feedback_store_from_path(feedback_path);
+    let updated = match action {
+        FeedbackAction::Accept => apply_feedback_accept(&mut store, comments),
+        FeedbackAction::Reject => apply_feedback_reject(&mut store, comments),
+    };
+
+    review::save_feedback_store(feedback_path, &store)?;
+    Ok(updated)
+}