Method execute_revise

atomic-cli/src/commands/revise.rs:520–660

Execute the revise operation.

(
        &self,
        repo: &Repository,
        sequence: u64,
        entry: &HistoryEntry,
    )

    /// Execute the revise operation.
    fn execute_revise(
        &self,
        repo: &Repository,
        sequence: u64,
        entry: &HistoryEntry,
    ) -> CliResult<Hash> {
        let stack_name = repo.current_view();
        let stack_info = repo
            .get_view_info(stack_name)
            .map_err(CliError::Repository)?;

        // Load the original change to get its message
        let original_change = repo
            .load_change(&entry.hash)
            .map_err(|e| CliError::Internal(anyhow::anyhow!("Failed to load change: {}", e)))?;

        let original_message = original_change.hashed.header.message.clone();

        // Determine how many changes need to be unrecorded
        let changes_to_unrecord = stack_info.change_count - sequence;

        // Collect changes that will need to be re-applied (everything after target)
        let mut pending_changes: Vec<Hash> = Vec::new();

        if changes_to_unrecord > 1 {
            // Get history and collect changes after the target
            let history = repo
                .log(HistoryOptions::default())
                .map_err(CliError::Repository)?;

            // Collect entries after the target sequence, sorted by sequence
            let mut entries_after: Vec<_> = history
                .into_iter()
                .filter(|e| e.sequence > sequence)
                .collect();
            entries_after.sort_by_key(|e| e.sequence);

            // Extract hashes in order (oldest first for re-application)
            pending_changes = entries_after.into_iter().map(|e| e.hash).collect();
        }

        // Step 1: Unrecord changes from top down to (and including) target
        if !pending_changes.is_empty() {
            print_hint(&format!(
                "Temporarily unrecording {} changes after target...",
                pending_changes.len()
            ));
        }

        // Unrecord in reverse order (from newest to target)
        for _ in 0..changes_to_unrecord {
            repo.unrecord_last(UnrecordOptions::default())
                .map_err(|e| CliError::Internal(anyhow::anyhow!("Failed to unrecord: {}", e)))?;
        }

        // Step 2: Get the message for the new change
        let message = self.get_message(&original_message)?;