chant/operations/

update.rs

//! Spec update operation.
//!
//! Canonical implementation for updating spec fields with validation.

use anyhow::Result;
use std::path::Path;

use crate::spec::{Spec, SpecStatus, TransitionBuilder};

/// Options for spec update
#[derive(Debug, Clone, Default)]
pub struct UpdateOptions {
    /// New status (validated via state machine)
    pub status: Option<SpecStatus>,
    /// Dependencies to set
    pub depends_on: Option<Vec<String>>,
    /// Labels to set
    pub labels: Option<Vec<String>>,
    /// Target files to set
    pub target_files: Option<Vec<String>>,
    /// Model to set
    pub model: Option<String>,
    /// Output text to append to body
    pub output: Option<String>,
    /// Replace body content instead of appending (default: false)
    pub replace_body: bool,
    /// Force status transition (bypass validation)
    pub force: bool,
}

/// Update spec fields with validation.
///
/// This is the canonical update logic used by both CLI and MCP.
/// Status transitions are validated via the state machine.
pub fn update_spec(spec: &mut Spec, spec_path: &Path, options: UpdateOptions) -> Result<()> {
    let mut updated = false;

    // Update status if provided (use TransitionBuilder with optional force)
    if let Some(new_status) = options.status {
        let mut builder = TransitionBuilder::new(spec);
        if options.force {
            builder = builder.force();
        }
        builder.to(new_status)?;
        updated = true;
    }

    // Update depends_on if provided
    if let Some(depends_on) = options.depends_on {
        spec.frontmatter.depends_on = Some(depends_on);
        updated = true;
    }

    // Update labels if provided
    if let Some(labels) = options.labels {
        spec.frontmatter.labels = Some(labels);
        updated = true;
    }

    // Update target_files if provided
    if let Some(target_files) = options.target_files {
        spec.frontmatter.target_files = Some(target_files);
        updated = true;
    }

    // Update model if provided
    if let Some(model) = options.model {
        spec.frontmatter.model = Some(model);
        updated = true;
    }

    // Append or replace output if provided
    if let Some(output) = options.output {
        if !output.is_empty() {
            if options.replace_body {
                // Replace body content, preserving title heading if not in new output
                let has_title_in_output = output.lines().any(|l| l.trim().starts_with("# "));
                if !has_title_in_output {
                    if let Some(ref title) = spec.title {
                        spec.body = format!("# {}\n\n{}", title, output);
                    } else {
                        spec.body = output.clone();
                    }
                } else {
                    spec.body = output.clone();
                }
                if !spec.body.ends_with('\n') {
                    spec.body.push('\n');
                }
            } else {
                // Append output (backward-compatible default)
                if !spec.body.ends_with('\n') && !spec.body.is_empty() {
                    spec.body.push('\n');
                }
                spec.body.push_str("\n## Output\n\n");
                spec.body.push_str(&output);
                spec.body.push('\n');
            }
            updated = true;
        }
    }

    if !updated {
        anyhow::bail!("No updates specified");
    }

    // Save the spec
    spec.save(spec_path)?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::spec::Spec;
    use std::fs;
    use tempfile::TempDir;

    #[test]
    fn test_replace_body_preserves_title() {
        let temp_dir = TempDir::new().unwrap();
        let spec_path = temp_dir.path().join("test-spec.md");

        // Create a spec with a title (matching what chant_add creates)
        let initial_content = r#"---
type: code
status: pending
---

# Some title
"#;
        fs::write(&spec_path, initial_content).unwrap();

        // Load the spec
        let mut spec = Spec::load(&spec_path).unwrap();
        assert_eq!(spec.title, Some("Some title".to_string()));

        // Update with replace_body but no title in output (exact repro from spec)
        let options = UpdateOptions {
            output: Some(
                "\n\n## Details\n\nBody text\n\n## Acceptance Criteria\n\n- [ ] test".to_string(),
            ),
            replace_body: true,
            ..Default::default()
        };

        update_spec(&mut spec, &spec_path, options).unwrap();

        // Reload the spec from disk
        let reloaded_spec = Spec::load(&spec_path).unwrap();

        // Verify title is preserved
        assert_eq!(
            reloaded_spec.title,
            Some("Some title".to_string()),
            "Title should be preserved after replace_body"
        );
        assert!(
            reloaded_spec.body.contains("# Some title"),
            "Body should contain title heading"
        );
    }

    #[test]
    fn test_replace_body_when_spec_has_no_title_initially() {
        let temp_dir = TempDir::new().unwrap();
        let spec_path = temp_dir.path().join("test-spec-no-title.md");

        // Create a spec WITHOUT a title in the body
        let initial_content = r#"---
type: code
status: pending
---

Some body content without a heading
"#;
        fs::write(&spec_path, initial_content).unwrap();

        // Load the spec
        let mut spec = Spec::load(&spec_path).unwrap();
        assert_eq!(spec.title, None, "Spec should have no title");

        // Update with replace_body
        let options = UpdateOptions {
            output: Some(
                "\n\n## Details\n\nBody text\n\n## Acceptance Criteria\n\n- [ ] test".to_string(),
            ),
            replace_body: true,
            ..Default::default()
        };

        update_spec(&mut spec, &spec_path, options).unwrap();

        // Reload the spec from disk
        let reloaded_spec = Spec::load(&spec_path).unwrap();

        // In this case, there's no title to preserve, so it should still be None
        assert_eq!(reloaded_spec.title, None, "Spec should still have no title");
    }
}