refactor: split discussion command helpers

Separate interactive discussion looping from single-turn execution so follow-up flow control no longer lives inside one command body.

Made-with: Cursor

Author: haasonsaas

TODO.md

@@ -87,7 +87,7 @@
 - [x] `src/commands/review/command.rs`: split review/check/compare entrypoints if they keep diverging.
 - [x] `src/commands/misc/feedback/command.rs`: separate file loading/ID normalization from store persistence.
 - [x] `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.
+- [x] `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/changelog.rs`: evaluate splitting changelog collection from output formatting.
 - [x] `src/commands/eval/command.rs`: separate CLI option prep, fixture execution, and report lifecycle.

src/commands/misc/discussion/command.rs

@@ -1,13 +1,20 @@
 use anyhow::Result;
 use std::path::PathBuf;
 
+#[path = "command/interactive.rs"]
+mod interactive;
+#[path = "command/single.rs"]
+mod single;
+#[path = "command/turn.rs"]
+mod turn;
+
 use crate::adapters;
 use crate::config;
 
-use super::prompt::answer_discussion_question;
 use super::selection::{load_discussion_comments, select_discussion_comment};
-use super::thread::{load_discussion_thread, read_follow_up_question, save_discussion_thread};
-use super::types::DiscussionTurn;
+use super::thread::load_discussion_thread;
+use interactive::run_interactive_discussion;
+use single::run_single_discussion;
 
 pub async fn discuss_command(
     config: config::Config,
@@ -25,45 +32,28 @@ pub async fn discuss_command(
     let model_config = config.to_model_config();
     let adapter = adapters::llm::create_adapter(&model_config)?;
 
-    let mut next_question = question;
-    if next_question.is_none() && !interactive {
+    if question.is_none() && !interactive {
         anyhow::bail!("Provide --question or use --interactive");
     }
 
-    loop {
-        let current_question = if let Some(question) = next_question.take() {
-            question
-        } else if interactive {
-            match read_follow_up_question()? {
-                Some(question) => question,
-                None => break,
-            }
-        } else {
-            break;
-        };
-
-        let answer =
-            answer_discussion_question(adapter.as_ref(), &selected, &thread, &current_question)
-                .await?;
-
-        println!("{}", answer.trim());
-
-        thread.turns.push(DiscussionTurn {
-            role: "user".to_string(),
-            message: current_question,
-        });
-        thread.turns.push(DiscussionTurn {
-            role: "assistant".to_string(),
-            message: answer,
-        });
-
-        if let Some(path) = &thread_path {
-            save_discussion_thread(path, &thread)?;
-        }
-
-        if !interactive {
-            break;
-        }
+    if interactive {
+        run_interactive_discussion(
+            adapter.as_ref(),
+            &selected,
+            &mut thread,
+            question,
+            thread_path.as_deref(),
+        )
+        .await?;
+    } else if let Some(question) = question {
+        run_single_discussion(
+            adapter.as_ref(),
+            &selected,
+            &mut thread,
+            question,
+            thread_path.as_deref(),
+        )
+        .await?;
     }
 
     Ok(())

src/commands/misc/discussion/command/interactive.rs

@@ -0,0 +1,28 @@
+use anyhow::Result;
+use std::path::Path;
+
+use crate::adapters;
+use crate::core;
+
+use super::super::thread::read_follow_up_question;
+use super::super::types::DiscussionThread;
+use super::turn::run_discussion_turn;
+
+pub(super) async fn run_interactive_discussion(
+    adapter: &dyn adapters::llm::LLMAdapter,
+    selected: &core::Comment,
+    thread: &mut DiscussionThread,
+    initial_question: Option<String>,
+    thread_path: Option<&Path>,
+) -> Result<()> {
+    let mut next_question = initial_question;
+
+    loop {
+        let Some(question) = next_question.take().or(read_follow_up_question()?) else {
+            break;
+        };
+        run_discussion_turn(adapter, selected, thread, question, thread_path).await?;
+    }
+
+    Ok(())
+}

src/commands/misc/discussion/command/single.rs

@@ -0,0 +1,18 @@
+use anyhow::Result;
+use std::path::Path;
+
+use crate::adapters;
+use crate::core;
+
+use super::super::types::DiscussionThread;
+use super::turn::run_discussion_turn;
+
+pub(super) async fn run_single_discussion(
+    adapter: &dyn adapters::llm::LLMAdapter,
+    selected: &core::Comment,
+    thread: &mut DiscussionThread,
+    question: String,
+    thread_path: Option<&Path>,
+) -> Result<()> {
+    run_discussion_turn(adapter, selected, thread, question, thread_path).await
+}

src/commands/misc/discussion/command/turn.rs

@@ -0,0 +1,36 @@
+use anyhow::Result;
+use std::path::Path;
+
+use crate::adapters;
+use crate::core;
+
+use super::super::prompt::answer_discussion_question;
+use super::super::thread::save_discussion_thread;
+use super::super::types::{DiscussionThread, DiscussionTurn};
+
+pub(super) async fn run_discussion_turn(
+    adapter: &dyn adapters::llm::LLMAdapter,
+    selected: &core::Comment,
+    thread: &mut DiscussionThread,
+    question: String,
+    thread_path: Option<&Path>,
+) -> Result<()> {
+    let answer = answer_discussion_question(adapter, selected, thread, &question).await?;
+
+    println!("{}", answer.trim());
+
+    thread.turns.push(DiscussionTurn {
+        role: "user".to_string(),
+        message: question,
+    });
+    thread.turns.push(DiscussionTurn {
+        role: "assistant".to_string(),
+        message: answer,
+    });
+
+    if let Some(path) = thread_path {
+        save_discussion_thread(path, thread)?;
+    }
+
+    Ok(())
+}