use std::fmt::{Display, Formatter}; use chrono::{DateTime, Local};use warp_editor::render::model::LineCount;use warp_multi_agent_api::{self as api}; use crate::ai::agent::{CurrentHead, DiffBase};use crate::code::buffer_location::LocalOrRemotePath;use crate::code::editor::EditorReviewComment;use crate::code::editor::line::EditorLineLocation; #[derive(Clone, Debug, Default, PartialEq, Eq)]pub enum CommentOrigin {    /// Comments originally created in the Warp UI.    #[default]    Native,    /// Comments imported from a GitHub pull request.    ImportedFromGitHub(ImportedCommentDetails),} impl CommentOrigin {    pub(crate) fn is_imported_from_github(&self) -> bool {        matches!(self, Self::ImportedFromGitHub(_))    }} /// Imported comment metadata for GitHub-specific fields.#[derive(Clone, Debug, PartialEq, Eq)]pub struct ImportedCommentDetails {    pub author: String,    /// The GitHub comment ID from the API.    pub github_comment_id: String,    /// The GitHub parent comment ID if this was a reply.    /// Should be None for threaded comments after flattening.    pub github_parent_id: Option<String>,    pub html_url: Option<String>,} #[derive(Clone, Debug, PartialEq, Eq, Default)]pub struct LineDiffContent {    pub content: String,    pub lines_added: LineCount,    pub lines_removed: LineCount,} impl LineDiffContent {    /// The text in the diff line, without the `+` or `-` diff prefix or trailing newlines.    ///    /// Uses `strip_prefix` (removes exactly one occurrence) rather than `trim_start_matches`    /// (which removes all leading occurrences) so that content characters are preserved.    pub(crate) fn original_text(&self) -> String {        let s = self.content.trim_end_matches('\n');        s.strip_prefix('+')            .or_else(|| s.strip_prefix('-'))            .unwrap_or(s)            .to_string()    }     /// The source-line text for a comment imported from a provider diff hunk.    ///    /// Unlike [`Self::original_text`], this strips exactly one leading    /// unified-diff marker — `+`, `-`, or the space that context (unchanged)    /// lines carry — recovering the raw file line. It must only be used for    /// imported comments, whose `content` is always a diff line with exactly one    /// such prefix char; native comments store raw text (real leading    /// indentation is significant) and must use [`Self::original_text`] instead.    pub(crate) fn imported_original_text(&self) -> String {        let s = self.content.trim_end_matches('\n');        s.strip_prefix(['+', '-', ' ']).unwrap_or(s).to_string()    }     pub(crate) fn from_content(diff_line: &str) -> Self {        let lines_added = LineCount::from(if diff_line.starts_with('+') { 1 } else { 0 });        let lines_removed = LineCount::from(if diff_line.starts_with('-') { 1 } else { 0 });        Self {            content: diff_line.to_owned(),            lines_added,            lines_removed,        }    }} #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]pub struct CommentId(uuid::Uuid); impl CommentId {    pub(crate) fn new() -> Self {        CommentId(uuid::Uuid::new_v4())    }     pub(crate) fn from_uuid(uuid: uuid::Uuid) -> Self {        Self(uuid)    }} impl Display for CommentId {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        write!(f, "{}", self.0)    }} impl Default for CommentId {    fn default() -> Self {        Self::new()    }} /// Code review comment attached to a local file editor.#[derive(Clone, Debug, PartialEq, Eq)]pub struct AttachedReviewComment {    /// Locally-generated ID.    pub id: CommentId,    pub content: String,    pub target: AttachedReviewCommentTarget,    pub last_update_time: DateTime<Local>,    pub base: Option<DiffBase>,    pub head: Option<CurrentHead>,    pub outdated: bool,    pub origin: CommentOrigin,} impl From<AttachedReviewComment> for api::ReviewComment {    fn from(val: AttachedReviewComment) -> Self {        let comment_target = match val.target {            AttachedReviewCommentTarget::Line {                absolute_file_path,                content,                line,            } => {                // For now, comments are only attached to a single line.                let line_range = line.line_number().map(|lc| {                    let line_number = lc.as_usize() as u32;                    api::FileContentLineRange {                        start: line_number,                        end: line_number + 1,                    }                });                 api::review_comment::CommentTarget::CommentedLine(api::DiffHunk {                    // For the agent/GitHub API we send the path bytes only;                    // the comment's owning batch is already host-scoped.                    file_path: absolute_file_path.display_path(),                    line_range,                    diff_content: content.content,                    lines_added: content.lines_added.as_u32(),                    lines_removed: content.lines_removed.as_u32(),                    current: val.head.to_owned().map(Into::into),                    base: val.base.map(Into::into),                })            }            AttachedReviewCommentTarget::File { absolute_file_path } => {                api::review_comment::CommentTarget::CommentedFile(                    api::review_comment::CommentedFile {                        file_path: absolute_file_path.display_path(),                        current: val.head.to_owned().map(Into::into),                        base: val.base.map(Into::into),                    },                )            }            AttachedReviewCommentTarget::General => {                api::review_comment::CommentTarget::CommentedDiffset(                    api::review_comment::CommentedDiffset {                        current: val.head.to_owned().map(Into::into),                        base: val.base.map(Into::into),                    },                )            }        };         api::ReviewComment {            id: val.id.to_string(),            comment: val.content,            comment_target: Some(comment_target),        }    }} /// Target for an attached review comment. File paths are always absolute when present.#[derive(Clone, Debug, PartialEq, Eq)]pub enum AttachedReviewCommentTarget {    Line {        absolute_file_path: LocalOrRemotePath,        line: EditorLineLocation,        content: LineDiffContent,    },    File {        absolute_file_path: LocalOrRemotePath,    },    General,} impl AttachedReviewCommentTarget {    pub(crate) fn absolute_file_path(&self) -> Option<&LocalOrRemotePath> {        match self {            AttachedReviewCommentTarget::Line {                absolute_file_path, ..            } => Some(absolute_file_path),            AttachedReviewCommentTarget::File { absolute_file_path } => Some(absolute_file_path),            AttachedReviewCommentTarget::General => None,        }    }     pub(crate) fn line_number(&self) -> Option<LineCount> {        match self {            AttachedReviewCommentTarget::Line { line, .. } => line.line_number(),            _ => None,        }    }} impl AttachedReviewComment {    pub(crate) fn from_editor_review_comment(        comment: EditorReviewComment,        absolute_file_path: LocalOrRemotePath,        base: Option<DiffBase>,        head: Option<CurrentHead>,    ) -> AttachedReviewComment {        AttachedReviewComment {            id: comment.id,            content: comment.comment_content,            base,            head,            target: AttachedReviewCommentTarget::Line {                absolute_file_path,                line: comment.line,                content: comment.diff_content,            },            last_update_time: comment.last_update_time,            outdated: false,            origin: CommentOrigin::Native,        }    }     pub fn head(&self) -> Option<&CurrentHead> {        self.head.as_ref()    }     pub fn origin(&self) -> &CommentOrigin {        &self.origin    }} #[cfg(test)]#[path = "comment_tests.rs"]mod tests;