story-kit: merge 328_refactor_split_commands_rs_into_individual_command_handler_modules

server/src/matrix/commands/status.rs

@@ -0,0 +1,354 @@
+//! Handler for the `status` command and pipeline status helpers.
+
+use crate::agents::{AgentPool, AgentStatus};
+use crate::config::ProjectConfig;
+use std::collections::{HashMap, HashSet};
+
+use super::CommandContext;
+
+pub(super) fn handle_status(ctx: &CommandContext) -> Option<String> {
+    Some(build_pipeline_status(ctx.project_root, ctx.agents))
+}
+
+/// Format a short display label for a work item.
+///
+/// Extracts the leading numeric ID from the file stem (e.g. `"293"` from
+/// `"293_story_register_all_bot_commands"`) and combines it with the human-
+/// readable name from the front matter when available.
+///
+/// Examples:
+/// - `("293_story_foo", Some("Register all bot commands"))` → `"293 — Register all bot commands"`
+/// - `("293_story_foo", None)` → `"293"`
+/// - `("no_number_here", None)` → `"no_number_here"`
+pub(super) fn story_short_label(stem: &str, name: Option<&str>) -> String {
+    let number = stem
+        .split('_')
+        .next()
+        .filter(|s| !s.is_empty() && s.chars().all(|c| c.is_ascii_digit()))
+        .unwrap_or(stem);
+    match name {
+        Some(n) => format!("{number} — {n}"),
+        None => number.to_string(),
+    }
+}
+
+/// Read all story IDs and names from a pipeline stage directory.
+fn read_stage_items(
+    project_root: &std::path::Path,
+    stage_dir: &str,
+) -> Vec<(String, Option<String>)> {
+    let dir = project_root
+        .join(".story_kit")
+        .join("work")
+        .join(stage_dir);
+    if !dir.exists() {
+        return Vec::new();
+    }
+    let mut items = Vec::new();
+    if let Ok(entries) = std::fs::read_dir(&dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("md") {
+                continue;
+            }
+            if let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
+                let name = std::fs::read_to_string(&path)
+                    .ok()
+                    .and_then(|contents| {
+                        crate::io::story_metadata::parse_front_matter(&contents)
+                            .ok()
+                            .and_then(|m| m.name)
+                    });
+                items.push((stem.to_string(), name));
+            }
+        }
+    }
+    items.sort_by(|a, b| a.0.cmp(&b.0));
+    items
+}
+
+/// Build the full pipeline status text formatted for Matrix (markdown).
+pub(super) fn build_pipeline_status(project_root: &std::path::Path, agents: &AgentPool) -> String {
+    // Build a map from story_id → active AgentInfo for quick lookup.
+    let active_agents = agents.list_agents().unwrap_or_default();
+    let active_map: HashMap<String, &crate::agents::AgentInfo> = active_agents
+        .iter()
+        .filter(|a| matches!(a.status, AgentStatus::Running | AgentStatus::Pending))
+        .map(|a| (a.story_id.clone(), a))
+        .collect();
+
+    // Read token usage once for all stories to avoid repeated file I/O.
+    let cost_by_story: HashMap<String, f64> =
+        crate::agents::token_usage::read_all(project_root)
+            .unwrap_or_default()
+            .into_iter()
+            .fold(HashMap::new(), |mut map, r| {
+                *map.entry(r.story_id).or_insert(0.0) += r.usage.total_cost_usd;
+                map
+            });
+
+    let config = ProjectConfig::load(project_root).ok();
+
+    let mut out = String::from("**Pipeline Status**\n\n");
+
+    let stages = [
+        ("1_backlog", "Backlog"),
+        ("2_current", "In Progress"),
+        ("3_qa", "QA"),
+        ("4_merge", "Merge"),
+        ("5_done", "Done"),
+    ];
+
+    for (dir, label) in &stages {
+        let items = read_stage_items(project_root, dir);
+        let count = items.len();
+        out.push_str(&format!("**{label}** ({count})\n"));
+        if items.is_empty() {
+            out.push_str("  *(none)*\n");
+        } else {
+            for (story_id, name) in &items {
+                let display = story_short_label(story_id, name.as_deref());
+                let cost_suffix = cost_by_story
+                    .get(story_id)
+                    .filter(|&&c| c > 0.0)
+                    .map(|c| format!(" — ${c:.2}"))
+                    .unwrap_or_default();
+                if let Some(agent) = active_map.get(story_id) {
+                    let model_str = config
+                        .as_ref()
+                        .and_then(|cfg| cfg.find_agent(&agent.agent_name))
+                        .and_then(|ac| ac.model.as_deref())
+                        .unwrap_or("?");
+                    out.push_str(&format!(
+                        "  • {display}{cost_suffix} — {} ({model_str})\n",
+                        agent.agent_name
+                    ));
+                } else {
+                    out.push_str(&format!("  • {display}{cost_suffix}\n"));
+                }
+            }
+        }
+        out.push('\n');
+    }
+
+    // Free agents: configured agents not currently running or pending.
+    out.push_str("**Free Agents**\n");
+    if let Some(cfg) = &config {
+        let busy_names: HashSet<String> = active_agents
+            .iter()
+            .filter(|a| matches!(a.status, AgentStatus::Running | AgentStatus::Pending))
+            .map(|a| a.agent_name.clone())
+            .collect();
+
+        let free: Vec<String> = cfg
+            .agent
+            .iter()
+            .filter(|a| !busy_names.contains(&a.name))
+            .map(|a| match &a.model {
+                Some(m) => format!("{} ({})", a.name, m),
+                None => a.name.clone(),
+            })
+            .collect();
+
+        if free.is_empty() {
+            out.push_str("  *(none — all agents busy)*\n");
+        } else {
+            for name in &free {
+                out.push_str(&format!("  • {name}\n"));
+            }
+        }
+    } else {
+        out.push_str("  *(no agent config found)*\n");
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agents::AgentPool;
+
+    #[test]
+    fn status_command_matches() {
+        let result = super::super::tests::try_cmd_addressed("Timmy", "@timmy:homeserver.local", "@timmy status");
+        assert!(result.is_some(), "status command should match");
+    }
+
+    #[test]
+    fn status_command_returns_pipeline_text() {
+        let result = super::super::tests::try_cmd_addressed("Timmy", "@timmy:homeserver.local", "@timmy status");
+        let output = result.unwrap();
+        assert!(
+            output.contains("Pipeline Status"),
+            "status output should contain pipeline info: {output}"
+        );
+    }
+
+    #[test]
+    fn status_command_case_insensitive() {
+        let result = super::super::tests::try_cmd_addressed("Timmy", "@timmy:homeserver.local", "@timmy STATUS");
+        assert!(result.is_some(), "STATUS should match case-insensitively");
+    }
+
+    // -- story_short_label --------------------------------------------------
+
+    #[test]
+    fn short_label_extracts_number_and_name() {
+        let label = story_short_label("293_story_register_all_bot_commands", Some("Register all bot commands"));
+        assert_eq!(label, "293 — Register all bot commands");
+    }
+
+    #[test]
+    fn short_label_number_only_when_no_name() {
+        let label = story_short_label("297_story_improve_bot_status_command_formatting", None);
+        assert_eq!(label, "297");
+    }
+
+    #[test]
+    fn short_label_falls_back_to_stem_when_no_numeric_prefix() {
+        let label = story_short_label("no_number_here", None);
+        assert_eq!(label, "no_number_here");
+    }
+
+    #[test]
+    fn short_label_does_not_include_underscore_slug() {
+        let label = story_short_label("293_story_register_all_bot_commands_in_the_command_registry", Some("Register all bot commands"));
+        assert!(
+            !label.contains("story_register"),
+            "label should not contain the slug portion: {label}"
+        );
+    }
+
+    // -- build_pipeline_status formatting -----------------------------------
+
+    #[test]
+    fn status_does_not_show_full_filename_stem() {
+        use std::io::Write;
+        use tempfile::TempDir;
+
+        let tmp = TempDir::new().unwrap();
+        let stage_dir = tmp.path().join(".story_kit/work/2_current");
+        std::fs::create_dir_all(&stage_dir).unwrap();
+
+        // Write a story file with a front-matter name
+        let story_path = stage_dir.join("293_story_register_all_bot_commands.md");
+        let mut f = std::fs::File::create(&story_path).unwrap();
+        writeln!(f, "---\nname: Register all bot commands\n---\n").unwrap();
+
+        let agents = AgentPool::new_test(3000);
+        let output = build_pipeline_status(tmp.path(), &agents);
+
+        assert!(
+            !output.contains("293_story_register_all_bot_commands"),
+            "output must not show full filename stem: {output}"
+        );
+        assert!(
+            output.contains("293 — Register all bot commands"),
+            "output must show number and title: {output}"
+        );
+    }
+
+    // -- token cost in status output ----------------------------------------
+
+    #[test]
+    fn status_shows_cost_when_token_usage_exists() {
+        use std::io::Write;
+        use tempfile::TempDir;
+
+        let tmp = TempDir::new().unwrap();
+        let stage_dir = tmp.path().join(".story_kit/work/2_current");
+        std::fs::create_dir_all(&stage_dir).unwrap();
+
+        let story_path = stage_dir.join("293_story_register_all_bot_commands.md");
+        let mut f = std::fs::File::create(&story_path).unwrap();
+        writeln!(f, "---\nname: Register all bot commands\n---\n").unwrap();
+
+        // Write token usage for this story.
+        let usage = crate::agents::TokenUsage {
+            input_tokens: 100,
+            output_tokens: 200,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: 0,
+            total_cost_usd: 0.29,
+        };
+        let record = crate::agents::token_usage::build_record(
+            "293_story_register_all_bot_commands",
+            "coder-1",
+            None,
+            usage,
+        );
+        crate::agents::token_usage::append_record(tmp.path(), &record).unwrap();
+
+        let agents = AgentPool::new_test(3000);
+        let output = build_pipeline_status(tmp.path(), &agents);
+
+        assert!(
+            output.contains("293 — Register all bot commands — $0.29"),
+            "output must show cost next to story: {output}"
+        );
+    }
+
+    #[test]
+    fn status_no_cost_when_no_usage() {
+        use std::io::Write;
+        use tempfile::TempDir;
+
+        let tmp = TempDir::new().unwrap();
+        let stage_dir = tmp.path().join(".story_kit/work/2_current");
+        std::fs::create_dir_all(&stage_dir).unwrap();
+
+        let story_path = stage_dir.join("293_story_register_all_bot_commands.md");
+        let mut f = std::fs::File::create(&story_path).unwrap();
+        writeln!(f, "---\nname: Register all bot commands\n---\n").unwrap();
+
+        // No token usage written.
+        let agents = AgentPool::new_test(3000);
+        let output = build_pipeline_status(tmp.path(), &agents);
+
+        assert!(
+            !output.contains("$"),
+            "output must not show cost when no usage exists: {output}"
+        );
+    }
+
+    #[test]
+    fn status_aggregates_multiple_records_per_story() {
+        use std::io::Write;
+        use tempfile::TempDir;
+
+        let tmp = TempDir::new().unwrap();
+        let stage_dir = tmp.path().join(".story_kit/work/2_current");
+        std::fs::create_dir_all(&stage_dir).unwrap();
+
+        let story_path = stage_dir.join("293_story_register_all_bot_commands.md");
+        let mut f = std::fs::File::create(&story_path).unwrap();
+        writeln!(f, "---\nname: Register all bot commands\n---\n").unwrap();
+
+        // Write two records for the same story — costs should be summed.
+        for cost in [0.10, 0.19] {
+            let usage = crate::agents::TokenUsage {
+                input_tokens: 50,
+                output_tokens: 100,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0,
+                total_cost_usd: cost,
+            };
+            let record = crate::agents::token_usage::build_record(
+                "293_story_register_all_bot_commands",
+                "coder-1",
+                None,
+                usage,
+            );
+            crate::agents::token_usage::append_record(tmp.path(), &record).unwrap();
+        }
+
+        let agents = AgentPool::new_test(3000);
+        let output = build_pipeline_status(tmp.path(), &agents);
+
+        assert!(
+            output.contains("293 — Register all bot commands — $0.29"),
+            "output must show aggregated cost: {output}"
+        );
+    }
+}