chronicle/annotate/

squash.rs

use std::path::Path;

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use crate::error::chronicle_error::{IoSnafu, JsonSnafu};
use crate::error::Result;
use crate::git::GitOps;
use crate::schema::v1::{
    self, ContextLevel, CrossCuttingConcern, Provenance, ProvenanceOperation, RegionAnnotation,
};
use crate::schema::{self, v3};
type Annotation = v1::Annotation;
use snafu::ResultExt;

/// Expiry time for pending-squash.json files, in seconds.
const PENDING_SQUASH_EXPIRY_SECS: i64 = 60;

/// Written to .git/chronicle/pending-squash.json by prepare-commit-msg.
/// Consumed and deleted by post-commit.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PendingSquash {
    pub source_commits: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_ref: Option<String>,
    pub timestamp: DateTime<Utc>,
}

/// Context for squash synthesis, assembled before calling the agent.
#[derive(Debug, Clone)]
pub struct SquashSynthesisContext {
    /// The squash commit's SHA.
    pub squash_commit: String,
    /// The squash commit's combined diff as text.
    pub diff: String,
    /// Annotations from source commits (those that had annotations).
    pub source_annotations: Vec<Annotation>,
    /// Commit messages from source commits: (sha, message).
    pub source_messages: Vec<(String, String)>,
    /// The squash commit's own commit message.
    pub squash_message: String,
}

/// Context for amend migration, assembled before calling the agent.
#[derive(Debug, Clone)]
pub struct AmendMigrationContext {
    /// The new (post-amend) commit SHA.
    pub new_commit: String,
    /// The new commit's diff (against its parent).
    pub new_diff: String,
    /// The old (pre-amend) annotation.
    pub old_annotation: Annotation,
    /// The new commit message.
    pub new_message: String,
}

fn pending_squash_path(git_dir: &Path) -> std::path::PathBuf {
    git_dir.join("chronicle").join("pending-squash.json")
}

/// Write pending-squash.json to .git/chronicle/.
pub fn write_pending_squash(git_dir: &Path, pending: &PendingSquash) -> Result<()> {
    let path = pending_squash_path(git_dir);
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent).context(IoSnafu)?;
    }
    let json = serde_json::to_string_pretty(pending).context(JsonSnafu)?;
    std::fs::write(&path, json).context(IoSnafu)?;
    Ok(())
}

/// Read pending-squash.json. Returns None if missing, stale, or invalid.
/// Stale or invalid files are deleted with a warning.
pub fn read_pending_squash(git_dir: &Path) -> Result<Option<PendingSquash>> {
    let path = pending_squash_path(git_dir);
    if !path.exists() {
        return Ok(None);
    }

    let content = std::fs::read_to_string(&path).context(IoSnafu)?;
    let pending: PendingSquash = match serde_json::from_str(&content) {
        Ok(p) => p,
        Err(e) => {
            tracing::warn!("Invalid pending-squash.json, deleting: {e}");
            let _ = std::fs::remove_file(&path);
            return Ok(None);
        }
    };

    let age = Utc::now() - pending.timestamp;
    if age.num_seconds() > PENDING_SQUASH_EXPIRY_SECS {
        tracing::warn!(
            "Stale pending-squash.json ({}s old), deleting",
            age.num_seconds()
        );
        std::fs::remove_file(&path).context(IoSnafu)?;
        return Ok(None);
    }

    Ok(Some(pending))
}

/// Delete the pending-squash.json file.
pub fn delete_pending_squash(git_dir: &Path) -> Result<()> {
    let path = pending_squash_path(git_dir);
    if path.exists() {
        std::fs::remove_file(&path).context(IoSnafu)?;
    }
    Ok(())
}

/// Synthesize an annotation from multiple source annotations (squash merge).
///
/// This merges regions, combines cross-cutting concerns, and sets provenance.
/// For MVP, this does not call the LLM — it performs a deterministic merge.
/// A future version will pass SquashSynthesisContext to the writing agent.
pub fn synthesize_squash_annotation(ctx: &SquashSynthesisContext) -> Annotation {
    let mut all_regions: Vec<RegionAnnotation> = Vec::new();
    let mut all_cross_cutting: Vec<CrossCuttingConcern> = Vec::new();
    let mut source_shas: Vec<String> = Vec::new();
    let has_annotations = !ctx.source_annotations.is_empty();

    for ann in &ctx.source_annotations {
        source_shas.push(ann.commit.clone());

        // Merge regions: collect all, deduplicating by (file, ast_anchor.name)
        for region in &ann.regions {
            let already_exists = all_regions
                .iter()
                .any(|r| r.file == region.file && r.ast_anchor.name == region.ast_anchor.name);
            if already_exists {
                // Find existing and append reasoning
                if let Some(existing) = all_regions
                    .iter_mut()
                    .find(|r| r.file == region.file && r.ast_anchor.name == region.ast_anchor.name)
                {
                    // Merge constraints (never drop)
                    for constraint in &region.constraints {
                        if !existing
                            .constraints
                            .iter()
                            .any(|c| c.text == constraint.text)
                        {
                            existing.constraints.push(constraint.clone());
                        }
                    }
                    // Merge semantic dependencies
                    for dep in &region.semantic_dependencies {
                        if !existing
                            .semantic_dependencies
                            .iter()
                            .any(|d| d.file == dep.file && d.anchor == dep.anchor)
                        {
                            existing.semantic_dependencies.push(dep.clone());
                        }
                    }
                    // Consolidate reasoning
                    if let Some(new_reasoning) = &region.reasoning {
                        if let Some(ref mut existing_reasoning) = existing.reasoning {
                            existing_reasoning.push_str("\n\n");
                            existing_reasoning.push_str(new_reasoning);
                        } else {
                            existing.reasoning = Some(new_reasoning.clone());
                        }
                    }
                    // Update line range to encompass both
                    existing.lines.start = existing.lines.start.min(region.lines.start);
                    existing.lines.end = existing.lines.end.max(region.lines.end);
                }
            } else {
                all_regions.push(region.clone());
            }
        }

        // Merge cross-cutting concerns (deduplicate by description)
        for cc in &ann.cross_cutting {
            if !all_cross_cutting
                .iter()
                .any(|c| c.description == cc.description)
            {
                all_cross_cutting.push(cc.clone());
            }
        }
    }

    // Collect source SHAs from source_messages for any that didn't have annotations
    for (sha, _) in &ctx.source_messages {
        if !source_shas.contains(sha) {
            source_shas.push(sha.clone());
        }
    }

    let annotations_count = ctx.source_annotations.len();
    let total_sources = ctx.source_messages.len();
    let all_had_annotations = annotations_count == total_sources && total_sources > 0;

    let synthesis_notes = if has_annotations {
        Some(format!(
            "Synthesized from {} commits ({} of {} had annotations).",
            total_sources, annotations_count, total_sources,
        ))
    } else {
        Some(format!(
            "Synthesized from {} commits (none had annotations).",
            total_sources,
        ))
    };

    Annotation {
        schema: "chronicle/v1".to_string(),
        commit: ctx.squash_commit.clone(),
        timestamp: Utc::now().to_rfc3339(),
        task: None,
        summary: ctx.squash_message.clone(),
        context_level: if has_annotations {
            ContextLevel::Enhanced
        } else {
            ContextLevel::Inferred
        },
        regions: all_regions,
        cross_cutting: all_cross_cutting,
        provenance: Provenance {
            operation: ProvenanceOperation::Squash,
            derived_from: source_shas,
            original_annotations_preserved: all_had_annotations,
            synthesis_notes,
        },
    }
}

/// Migrate an annotation from a pre-amend commit to a post-amend commit.
///
/// If the diff is empty (message-only amend), copies the annotation unchanged
/// except for updating the commit SHA and provenance.
pub fn migrate_amend_annotation(ctx: &AmendMigrationContext) -> Annotation {
    let mut new_annotation = ctx.old_annotation.clone();
    new_annotation.commit = ctx.new_commit.clone();
    new_annotation.timestamp = Utc::now().to_rfc3339();

    let is_message_only = ctx.new_diff.trim().is_empty();

    new_annotation.provenance = Provenance {
        operation: ProvenanceOperation::Amend,
        derived_from: vec![ctx.old_annotation.commit.clone()],
        original_annotations_preserved: true,
        synthesis_notes: if is_message_only {
            Some("Message-only amend; annotation unchanged.".to_string())
        } else {
            Some("Migrated from amend. Regions preserved from original annotation.".to_string())
        },
    };

    // For message-only amends, update the summary to match new message
    if is_message_only {
        new_annotation.summary = ctx.new_message.clone();
    }

    new_annotation
}

/// Collect annotations from source commits using git notes.
pub fn collect_source_annotations(
    git_ops: &dyn GitOps,
    source_shas: &[String],
) -> Vec<(String, Option<Annotation>)> {
    source_shas
        .iter()
        .map(|sha| {
            let annotation = git_ops
                .note_read(sha)
                .ok()
                .flatten()
                .and_then(|json| serde_json::from_str::<Annotation>(&json).ok());
            (sha.clone(), annotation)
        })
        .collect()
}

/// Collect commit messages from source commits.
pub fn collect_source_messages(
    git_ops: &dyn GitOps,
    source_shas: &[String],
) -> Vec<(String, String)> {
    source_shas
        .iter()
        .filter_map(|sha| {
            git_ops
                .commit_info(sha)
                .ok()
                .map(|info| (sha.clone(), info.message))
        })
        .collect()
}

// ===========================================================================
// V3 squash synthesis
// ===========================================================================

/// Context for v3 squash synthesis.
#[derive(Debug, Clone)]
pub struct SquashSynthesisContextV3 {
    /// The squash commit's SHA.
    pub squash_commit: String,
    /// The squash commit's own commit message.
    pub squash_message: String,
    /// V3 annotations from source commits (normalized via parse_annotation).
    pub source_annotations: Vec<v3::Annotation>,
    /// Commit messages from source commits: (sha, message).
    pub source_messages: Vec<(String, String)>,
}

/// Synthesize a v3 annotation from multiple source annotations (squash merge).
///
/// Merges wisdom entries (deduplicated by exact category+content match),
/// sets provenance with all source SHAs.
pub fn synthesize_squash_annotation_v3(ctx: &SquashSynthesisContextV3) -> v3::Annotation {
    let mut all_wisdom: Vec<v3::WisdomEntry> = Vec::new();
    let mut source_shas: Vec<String> = Vec::new();

    for ann in &ctx.source_annotations {
        source_shas.push(ann.commit.clone());

        for entry in &ann.wisdom {
            let already_exists = all_wisdom
                .iter()
                .any(|w| w.category == entry.category && w.content == entry.content);
            if !already_exists {
                all_wisdom.push(entry.clone());
            }
        }
    }

    // Add source SHAs from source_messages for commits that had no annotations
    for (sha, _) in &ctx.source_messages {
        if !source_shas.contains(sha) {
            source_shas.push(sha.clone());
        }
    }

    let annotations_count = ctx.source_annotations.len();
    let total_sources = ctx.source_messages.len();

    // Build provenance notes with synthesis metadata and source summaries
    let mut notes_parts: Vec<String> = Vec::new();
    if !ctx.source_annotations.is_empty() {
        notes_parts.push(format!(
            "Synthesized from {} commits ({} of {} had annotations).",
            total_sources, annotations_count, total_sources,
        ));
    } else {
        notes_parts.push(format!(
            "Synthesized from {} commits (none had annotations).",
            total_sources,
        ));
    }

    // Include source summaries for traceability
    for ann in &ctx.source_annotations {
        let short_sha = if ann.commit.len() > 8 {
            &ann.commit[..8]
        } else {
            &ann.commit
        };
        notes_parts.push(format!("{}: {}", short_sha, ann.summary));
    }

    v3::Annotation {
        schema: "chronicle/v3".to_string(),
        commit: ctx.squash_commit.clone(),
        timestamp: Utc::now().to_rfc3339(),
        summary: ctx.squash_message.clone(),
        wisdom: all_wisdom,
        provenance: v3::Provenance {
            source: v3::ProvenanceSource::Squash,
            author: None,
            derived_from: source_shas,
            notes: Some(notes_parts.join("\n")),
        },
    }
}

/// Collect annotations from source commits, normalizing all versions to v3
/// via `schema::parse_annotation()`.
pub fn collect_source_annotations_v3(
    git_ops: &dyn GitOps,
    source_shas: &[String],
) -> Vec<(String, Option<v3::Annotation>)> {
    source_shas
        .iter()
        .map(|sha| {
            let annotation = git_ops
                .note_read(sha)
                .ok()
                .flatten()
                .and_then(|json| schema::parse_annotation(&json).ok());
            (sha.clone(), annotation)
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::schema::common::{AstAnchor, LineRange};
    use crate::schema::v1::{
        Constraint, ConstraintSource, CrossCuttingConcern, CrossCuttingRegionRef,
        SemanticDependency,
    };

    fn make_test_annotation(commit: &str, file: &str, anchor: &str) -> Annotation {
        Annotation {
            schema: "chronicle/v1".to_string(),
            commit: commit.to_string(),
            timestamp: Utc::now().to_rfc3339(),
            task: None,
            summary: format!("Commit {commit}"),
            context_level: ContextLevel::Inferred,
            regions: vec![RegionAnnotation {
                file: file.to_string(),
                ast_anchor: AstAnchor {
                    unit_type: "function".to_string(),
                    name: anchor.to_string(),
                    signature: None,
                },
                lines: LineRange { start: 1, end: 10 },
                intent: format!("Modified {anchor}"),
                reasoning: Some(format!("Reasoning for {anchor} in {commit}")),
                constraints: vec![Constraint {
                    text: format!("Constraint from {commit}"),
                    source: ConstraintSource::Inferred,
                }],
                semantic_dependencies: vec![SemanticDependency {
                    file: "other.rs".to_string(),
                    anchor: "helper".to_string(),
                    nature: "calls".to_string(),
                }],
                related_annotations: Vec::new(),
                tags: Vec::new(),
                risk_notes: None,
                corrections: vec![],
            }],
            cross_cutting: vec![CrossCuttingConcern {
                description: format!("Cross-cutting from {commit}"),
                regions: vec![CrossCuttingRegionRef {
                    file: file.to_string(),
                    anchor: anchor.to_string(),
                }],
                tags: Vec::new(),
            }],
            provenance: Provenance {
                operation: ProvenanceOperation::Initial,
                derived_from: Vec::new(),
                original_annotations_preserved: false,
                synthesis_notes: None,
            },
        }
    }

    #[test]
    fn test_pending_squash_roundtrip() {
        let dir = tempfile::tempdir().unwrap();
        let git_dir = dir.path();
        std::fs::create_dir_all(git_dir.join("chronicle")).unwrap();

        let pending = PendingSquash {
            source_commits: vec!["abc123".to_string(), "def456".to_string()],
            source_ref: Some("feature-branch".to_string()),
            timestamp: Utc::now(),
        };

        write_pending_squash(git_dir, &pending).unwrap();
        let read_back = read_pending_squash(git_dir).unwrap().unwrap();

        assert_eq!(read_back.source_commits, pending.source_commits);
        assert_eq!(read_back.source_ref, pending.source_ref);
    }

    #[test]
    fn test_pending_squash_missing_file() {
        let dir = tempfile::tempdir().unwrap();
        let result = read_pending_squash(dir.path()).unwrap();
        assert!(result.is_none());
    }

    #[test]
    fn test_pending_squash_stale_file() {
        let dir = tempfile::tempdir().unwrap();
        let git_dir = dir.path();
        std::fs::create_dir_all(git_dir.join("chronicle")).unwrap();

        let pending = PendingSquash {
            source_commits: vec!["abc123".to_string()],
            source_ref: None,
            timestamp: Utc::now() - chrono::Duration::seconds(120),
        };

        write_pending_squash(git_dir, &pending).unwrap();
        let result = read_pending_squash(git_dir).unwrap();
        assert!(result.is_none());
        // File should have been deleted
        assert!(!pending_squash_path(git_dir).exists());
    }

    #[test]
    fn test_pending_squash_invalid_json() {
        let dir = tempfile::tempdir().unwrap();
        let git_dir = dir.path();
        let chronicle_dir = git_dir.join("chronicle");
        std::fs::create_dir_all(&chronicle_dir).unwrap();
        std::fs::write(chronicle_dir.join("pending-squash.json"), "not json").unwrap();

        let result = read_pending_squash(git_dir).unwrap();
        assert!(result.is_none());
        // File should have been deleted
        assert!(!pending_squash_path(git_dir).exists());
    }

    #[test]
    fn test_delete_pending_squash() {
        let dir = tempfile::tempdir().unwrap();
        let git_dir = dir.path();

        let pending = PendingSquash {
            source_commits: vec!["abc123".to_string()],
            source_ref: None,
            timestamp: Utc::now(),
        };

        write_pending_squash(git_dir, &pending).unwrap();
        assert!(pending_squash_path(git_dir).exists());

        delete_pending_squash(git_dir).unwrap();
        assert!(!pending_squash_path(git_dir).exists());
    }

    #[test]
    fn test_delete_pending_squash_missing_file() {
        let dir = tempfile::tempdir().unwrap();
        // Should not error when file doesn't exist
        delete_pending_squash(dir.path()).unwrap();
    }

    #[test]
    fn test_synthesize_squash_distinct_regions() {
        let ann1 = make_test_annotation("abc123", "src/foo.rs", "foo_fn");
        let ann2 = make_test_annotation("def456", "src/bar.rs", "bar_fn");
        let ann3 = make_test_annotation("ghi789", "src/baz.rs", "baz_fn");

        let ctx = SquashSynthesisContext {
            squash_commit: "squash001".to_string(),
            diff: "some diff".to_string(),
            source_annotations: vec![ann1, ann2, ann3],
            source_messages: vec![
                ("abc123".to_string(), "Commit abc".to_string()),
                ("def456".to_string(), "Commit def".to_string()),
                ("ghi789".to_string(), "Commit ghi".to_string()),
            ],
            squash_message: "Squash merge".to_string(),
        };

        let result = synthesize_squash_annotation(&ctx);

        assert_eq!(result.commit, "squash001");
        assert_eq!(result.regions.len(), 3);
        assert_eq!(result.cross_cutting.len(), 3);
        assert_eq!(result.provenance.operation, ProvenanceOperation::Squash);
        assert_eq!(result.provenance.derived_from.len(), 3);
        assert!(result.provenance.original_annotations_preserved);
    }

    #[test]
    fn test_synthesize_squash_overlapping_regions() {
        let ann1 = make_test_annotation("abc123", "src/foo.rs", "connect");
        let mut ann2 = make_test_annotation("def456", "src/foo.rs", "connect");
        // Give ann2 a different constraint
        ann2.regions[0].constraints[0].text = "Constraint from def456".to_string();
        ann2.regions[0].lines = LineRange { start: 5, end: 20 };

        let ctx = SquashSynthesisContext {
            squash_commit: "squash001".to_string(),
            diff: "some diff".to_string(),
            source_annotations: vec![ann1, ann2],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
            ],
            squash_message: "Squash merge".to_string(),
        };

        let result = synthesize_squash_annotation(&ctx);

        // Should have merged into 1 region
        assert_eq!(result.regions.len(), 1);
        // Constraints from both should be preserved
        assert_eq!(result.regions[0].constraints.len(), 2);
        // Line range should encompass both
        assert_eq!(result.regions[0].lines.start, 1);
        assert_eq!(result.regions[0].lines.end, 20);
        // Reasoning should be consolidated
        assert!(result.regions[0]
            .reasoning
            .as_ref()
            .unwrap()
            .contains("abc123"));
        assert!(result.regions[0]
            .reasoning
            .as_ref()
            .unwrap()
            .contains("def456"));
    }

    #[test]
    fn test_synthesize_squash_partial_annotations() {
        let ann1 = make_test_annotation("abc123", "src/foo.rs", "foo_fn");

        let ctx = SquashSynthesisContext {
            squash_commit: "squash001".to_string(),
            diff: "some diff".to_string(),
            source_annotations: vec![ann1],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
                ("ghi789".to_string(), "Third".to_string()),
            ],
            squash_message: "Squash merge".to_string(),
        };

        let result = synthesize_squash_annotation(&ctx);

        assert!(!result.provenance.original_annotations_preserved);
        assert!(result
            .provenance
            .synthesis_notes
            .as_ref()
            .unwrap()
            .contains("1 of 3"));
    }

    #[test]
    fn test_synthesize_squash_no_annotations() {
        let ctx = SquashSynthesisContext {
            squash_commit: "squash001".to_string(),
            diff: "some diff".to_string(),
            source_annotations: vec![],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
            ],
            squash_message: "Squash merge".to_string(),
        };

        let result = synthesize_squash_annotation(&ctx);

        assert_eq!(result.context_level, ContextLevel::Inferred);
        assert!(result.regions.is_empty());
        assert!(!result.provenance.original_annotations_preserved);
    }

    #[test]
    fn test_synthesize_preserves_cross_cutting() {
        let ann1 = make_test_annotation("abc123", "src/foo.rs", "foo_fn");
        let mut ann2 = make_test_annotation("def456", "src/bar.rs", "bar_fn");
        // Add a second cross-cutting concern to ann2
        ann2.cross_cutting.push(CrossCuttingConcern {
            description: "Another concern".to_string(),
            regions: vec![CrossCuttingRegionRef {
                file: "src/bar.rs".to_string(),
                anchor: "bar_fn".to_string(),
            }],
            tags: Vec::new(),
        });

        let ctx = SquashSynthesisContext {
            squash_commit: "squash001".to_string(),
            diff: "some diff".to_string(),
            source_annotations: vec![ann1, ann2],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
            ],
            squash_message: "Squash merge".to_string(),
        };

        let result = synthesize_squash_annotation(&ctx);
        // 1 from ann1, 2 from ann2 = 3 unique cross-cutting concerns
        assert_eq!(result.cross_cutting.len(), 3);
    }

    #[test]
    fn test_migrate_amend_message_only() {
        let old_ann = make_test_annotation("old_sha", "src/foo.rs", "foo_fn");

        let ctx = AmendMigrationContext {
            new_commit: "new_sha".to_string(),
            new_diff: "".to_string(), // empty = message-only
            old_annotation: old_ann,
            new_message: "Updated commit message".to_string(),
        };

        let result = migrate_amend_annotation(&ctx);

        assert_eq!(result.commit, "new_sha");
        assert_eq!(result.provenance.operation, ProvenanceOperation::Amend);
        assert_eq!(result.provenance.derived_from, vec!["old_sha".to_string()]);
        assert!(result.provenance.original_annotations_preserved);
        assert!(result
            .provenance
            .synthesis_notes
            .as_ref()
            .unwrap()
            .contains("Message-only"));
        assert_eq!(result.summary, "Updated commit message");
        // Regions should be preserved
        assert_eq!(result.regions.len(), 1);
    }

    #[test]
    fn test_migrate_amend_with_code_changes() {
        let old_ann = make_test_annotation("old_sha", "src/foo.rs", "foo_fn");

        let ctx = AmendMigrationContext {
            new_commit: "new_sha".to_string(),
            new_diff: "+some new code\n-some old code\n".to_string(),
            old_annotation: old_ann,
            new_message: "Updated commit".to_string(),
        };

        let result = migrate_amend_annotation(&ctx);

        assert_eq!(result.commit, "new_sha");
        assert_eq!(result.provenance.operation, ProvenanceOperation::Amend);
        assert_eq!(result.provenance.derived_from, vec!["old_sha".to_string()]);
        assert!(result
            .provenance
            .synthesis_notes
            .as_ref()
            .unwrap()
            .contains("Migrated from amend"));
        // Regions preserved from original (MVP doesn't re-analyze)
        assert_eq!(result.regions.len(), 1);
    }

    // -----------------------------------------------------------------------
    // V3 squash synthesis tests
    // -----------------------------------------------------------------------

    fn make_v3_annotation(commit: &str, wisdom: Vec<v3::WisdomEntry>) -> v3::Annotation {
        v3::Annotation {
            schema: "chronicle/v3".to_string(),
            commit: commit.to_string(),
            timestamp: Utc::now().to_rfc3339(),
            summary: format!("Commit {commit}"),
            wisdom,
            provenance: v3::Provenance {
                source: v3::ProvenanceSource::Live,
                author: None,
                derived_from: Vec::new(),
                notes: None,
            },
        }
    }

    fn wisdom(category: v3::WisdomCategory, content: &str) -> v3::WisdomEntry {
        v3::WisdomEntry {
            category,
            content: content.to_string(),
            file: None,
            lines: None,
        }
    }

    fn wisdom_with_file(
        category: v3::WisdomCategory,
        content: &str,
        file: &str,
    ) -> v3::WisdomEntry {
        v3::WisdomEntry {
            category,
            content: content.to_string(),
            file: Some(file.to_string()),
            lines: None,
        }
    }

    #[test]
    fn test_synthesize_squash_v3_merges_wisdom() {
        let ann1 = make_v3_annotation(
            "abc123",
            vec![
                wisdom(v3::WisdomCategory::DeadEnd, "Tried approach X"),
                wisdom_with_file(
                    v3::WisdomCategory::Gotcha,
                    "Must validate input",
                    "src/input.rs",
                ),
            ],
        );
        let ann2 = make_v3_annotation(
            "def456",
            vec![
                wisdom(v3::WisdomCategory::Insight, "HashMap is O(1)"),
                wisdom_with_file(
                    v3::WisdomCategory::Gotcha,
                    "Connection can timeout",
                    "src/net.rs",
                ),
            ],
        );

        let ctx = SquashSynthesisContextV3 {
            squash_commit: "squash001".to_string(),
            squash_message: "Squash merge PR #42".to_string(),
            source_annotations: vec![ann1, ann2],
            source_messages: vec![
                ("abc123".to_string(), "First commit".to_string()),
                ("def456".to_string(), "Second commit".to_string()),
            ],
        };

        let result = synthesize_squash_annotation_v3(&ctx);

        assert_eq!(result.schema, "chronicle/v3");
        assert_eq!(result.commit, "squash001");
        assert_eq!(result.summary, "Squash merge PR #42");
        assert_eq!(result.wisdom.len(), 4);
        assert!(result
            .wisdom
            .iter()
            .any(|w| w.category == v3::WisdomCategory::DeadEnd && w.content == "Tried approach X"));
        assert!(result
            .wisdom
            .iter()
            .any(|w| w.category == v3::WisdomCategory::Gotcha
                && w.content == "Must validate input"
                && w.file.as_deref() == Some("src/input.rs")));
    }

    #[test]
    fn test_synthesize_squash_v3_deduplicates_wisdom() {
        // Same (category, content) across two annotations should be deduplicated
        let shared_wisdom = wisdom(v3::WisdomCategory::Gotcha, "Must validate input");
        let ann1 = make_v3_annotation("abc123", vec![shared_wisdom.clone()]);
        let ann2 = make_v3_annotation(
            "def456",
            vec![
                shared_wisdom,
                wisdom(v3::WisdomCategory::Insight, "Unique to ann2"),
            ],
        );

        let ctx = SquashSynthesisContextV3 {
            squash_commit: "squash001".to_string(),
            squash_message: "Squash".to_string(),
            source_annotations: vec![ann1, ann2],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
            ],
        };

        let result = synthesize_squash_annotation_v3(&ctx);

        // Should have 2 entries (1 deduplicated + 1 unique), not 3
        assert_eq!(result.wisdom.len(), 2);
        let gotcha_count = result
            .wisdom
            .iter()
            .filter(|w| {
                w.category == v3::WisdomCategory::Gotcha && w.content == "Must validate input"
            })
            .count();
        assert_eq!(gotcha_count, 1);
    }

    #[test]
    fn test_synthesize_squash_v3_no_annotations() {
        let ctx = SquashSynthesisContextV3 {
            squash_commit: "squash001".to_string(),
            squash_message: "Squash merge".to_string(),
            source_annotations: vec![],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
            ],
        };

        let result = synthesize_squash_annotation_v3(&ctx);

        assert_eq!(result.schema, "chronicle/v3");
        assert!(result.wisdom.is_empty());
        assert_eq!(result.provenance.source, v3::ProvenanceSource::Squash);
        assert_eq!(result.provenance.derived_from.len(), 2);
        assert!(result
            .provenance
            .notes
            .as_ref()
            .unwrap()
            .contains("none had annotations"));
    }

    #[test]
    fn test_synthesize_squash_v3_partial_annotations() {
        let ann1 = make_v3_annotation(
            "abc123",
            vec![wisdom(v3::WisdomCategory::Insight, "Only this one")],
        );

        let ctx = SquashSynthesisContextV3 {
            squash_commit: "squash001".to_string(),
            squash_message: "Squash merge".to_string(),
            source_annotations: vec![ann1],
            source_messages: vec![
                ("abc123".to_string(), "First".to_string()),
                ("def456".to_string(), "Second".to_string()),
                ("ghi789".to_string(), "Third".to_string()),
            ],
        };

        let result = synthesize_squash_annotation_v3(&ctx);

        assert_eq!(result.wisdom.len(), 1);
        assert!(result.provenance.notes.as_ref().unwrap().contains("1 of 3"));
        // All 3 source SHAs should be in derived_from
        assert_eq!(result.provenance.derived_from.len(), 3);
    }

    #[test]
    fn test_synthesize_squash_v3_provenance() {
        let ann1 = make_v3_annotation(
            "abc12345678",
            vec![wisdom(v3::WisdomCategory::DeadEnd, "Dead end")],
        );
        let ann2 = make_v3_annotation(
            "def45678901",
            vec![wisdom(v3::WisdomCategory::Insight, "Insight")],
        );

        let ctx = SquashSynthesisContextV3 {
            squash_commit: "squash001".to_string(),
            squash_message: "Squash merge".to_string(),
            source_annotations: vec![ann1, ann2],
            source_messages: vec![
                ("abc12345678".to_string(), "First".to_string()),
                ("def45678901".to_string(), "Second".to_string()),
            ],
        };

        let result = synthesize_squash_annotation_v3(&ctx);

        assert_eq!(result.provenance.source, v3::ProvenanceSource::Squash);
        assert_eq!(
            result.provenance.derived_from,
            vec!["abc12345678".to_string(), "def45678901".to_string()]
        );
        let notes = result.provenance.notes.unwrap();
        assert!(notes.contains("Synthesized from 2 commits"));
        assert!(notes.contains("2 of 2 had annotations"));
        // Source summaries should be included
        assert!(notes.contains("abc12345: Commit abc12345678"));
        assert!(notes.contains("def45678: Commit def45678901"));
    }

    #[test]
    fn test_collect_source_annotations_v3_handles_all_versions() {
        use crate::error::GitError;
        use crate::git::diff::FileDiff;
        use crate::git::CommitInfo;
        use std::collections::HashMap;

        struct MockGitOpsForNotes {
            notes: HashMap<String, String>,
        }

        impl GitOps for MockGitOpsForNotes {
            fn diff(&self, _: &str) -> std::result::Result<Vec<FileDiff>, GitError> {
                Ok(vec![])
            }
            fn note_read(&self, commit: &str) -> std::result::Result<Option<String>, GitError> {
                Ok(self.notes.get(commit).cloned())
            }
            fn note_write(&self, _: &str, _: &str) -> std::result::Result<(), GitError> {
                Ok(())
            }
            fn note_exists(&self, _: &str) -> std::result::Result<bool, GitError> {
                Ok(false)
            }
            fn file_at_commit(
                &self,
                _: &std::path::Path,
                _: &str,
            ) -> std::result::Result<String, GitError> {
                Ok(String::new())
            }
            fn commit_info(&self, _: &str) -> std::result::Result<CommitInfo, GitError> {
                Ok(CommitInfo {
                    sha: String::new(),
                    message: String::new(),
                    author_name: String::new(),
                    author_email: String::new(),
                    timestamp: String::new(),
                    parent_shas: Vec::new(),
                })
            }
            fn resolve_ref(&self, _: &str) -> std::result::Result<String, GitError> {
                Ok(String::new())
            }
            fn config_get(&self, _: &str) -> std::result::Result<Option<String>, GitError> {
                Ok(None)
            }
            fn config_set(&self, _: &str, _: &str) -> std::result::Result<(), GitError> {
                Ok(())
            }
            fn log_for_file(&self, _: &str) -> std::result::Result<Vec<String>, GitError> {
                Ok(vec![])
            }
            fn list_annotated_commits(&self, _: u32) -> std::result::Result<Vec<String>, GitError> {
                Ok(vec![])
            }
        }

        let v1_json = r#"{
            "schema": "chronicle/v1",
            "commit": "v1sha",
            "timestamp": "2025-01-01T00:00:00Z",
            "summary": "V1 annotation",
            "context_level": "enhanced",
            "regions": [],
            "provenance": {
                "operation": "initial",
                "derived_from": [],
                "original_annotations_preserved": false
            }
        }"#;

        let v3_json = r#"{
            "schema": "chronicle/v3",
            "commit": "v3sha",
            "timestamp": "2025-06-01T00:00:00Z",
            "summary": "V3 annotation",
            "wisdom": [{"category": "gotcha", "content": "Watch out"}],
            "provenance": {"source": "live"}
        }"#;

        let mut notes = HashMap::new();
        notes.insert("v1sha".to_string(), v1_json.to_string());
        notes.insert("v3sha".to_string(), v3_json.to_string());
        // no_ann_sha has no note

        let mock = MockGitOpsForNotes { notes };
        let shas = vec![
            "v1sha".to_string(),
            "v3sha".to_string(),
            "no_ann_sha".to_string(),
        ];

        let results = collect_source_annotations_v3(&mock, &shas);

        assert_eq!(results.len(), 3);

        // v1 annotation should be parsed and migrated to v3
        let (sha, ann) = &results[0];
        assert_eq!(sha, "v1sha");
        let ann = ann.as_ref().unwrap();
        assert_eq!(ann.schema, "chronicle/v3");
        assert_eq!(ann.summary, "V1 annotation");

        // v3 annotation should parse directly
        let (sha, ann) = &results[1];
        assert_eq!(sha, "v3sha");
        let ann = ann.as_ref().unwrap();
        assert_eq!(ann.schema, "chronicle/v3");
        assert_eq!(ann.wisdom.len(), 1);

        // Missing annotation should be None
        let (sha, ann) = &results[2];
        assert_eq!(sha, "no_ann_sha");
        assert!(ann.is_none());
    }
}