1840 lines · 67.6 KB · Rust
RawDownload
use anyhow::{Context as _, Result};use buffer_diff::BufferDiff;use collections::BTreeMap;use futures::{StreamExt, channel::mpsc};use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};use language::{Anchor, Buffer, BufferEvent, DiskState, Point, ToPoint};use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};use std::{cmp, ops::Range, sync::Arc};use text::{Edit, Patch, Rope};use util::RangeExt; /// Tracks actions performed by tools in a threadpub struct ActionLog {    /// Buffers that we want to notify the model about when they change.    tracked_buffers: BTreeMap<Entity<Buffer>, TrackedBuffer>,    /// Has the model edited a file since it last checked diagnostics?    edited_since_project_diagnostics_check: bool,    /// The project this action log is associated with    project: Entity<Project>,} impl ActionLog {    /// Creates a new, empty action log associated with the given project.    pub fn new(project: Entity<Project>) -> Self {        Self {            tracked_buffers: BTreeMap::default(),            edited_since_project_diagnostics_check: false,            project,        }    }     pub fn project(&self) -> &Entity<Project> {        &self.project    }     /// Notifies a diagnostics check    pub fn checked_project_diagnostics(&mut self) {        self.edited_since_project_diagnostics_check = false;    }     /// Returns true if any files have been edited since the last project diagnostics check    pub fn has_edited_files_since_project_diagnostics_check(&self) -> bool {        self.edited_since_project_diagnostics_check    }     fn track_buffer_internal(        &mut self,        buffer: Entity<Buffer>,        is_created: bool,        cx: &mut Context<Self>,    ) -> &mut TrackedBuffer {        let status = if is_created {            if let Some(tracked) = self.tracked_buffers.remove(&buffer) {                match tracked.status {                    TrackedBufferStatus::Created {                        existing_file_content,                    } => TrackedBufferStatus::Created {                        existing_file_content,                    },                    TrackedBufferStatus::Modified | TrackedBufferStatus::Deleted => {                        TrackedBufferStatus::Created {                            existing_file_content: Some(tracked.diff_base),                        }                    }                }            } else if buffer                .read(cx)                .file()                .map_or(false, |file| file.disk_state().exists())            {                TrackedBufferStatus::Created {                    existing_file_content: Some(buffer.read(cx).as_rope().clone()),                }            } else {                TrackedBufferStatus::Created {                    existing_file_content: None,                }            }        } else {            TrackedBufferStatus::Modified        };         let tracked_buffer = self            .tracked_buffers            .entry(buffer.clone())            .or_insert_with(|| {                let open_lsp_handle = self.project.update(cx, |project, cx| {                    project.register_buffer_with_language_servers(&buffer, cx)                });                 let text_snapshot = buffer.read(cx).text_snapshot();                let diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));                let (diff_update_tx, diff_update_rx) = mpsc::unbounded();                let diff_base;                let unreviewed_changes;                if is_created {                    diff_base = Rope::default();                    unreviewed_changes = Patch::new(vec![Edit {                        old: 0..1,                        new: 0..text_snapshot.max_point().row + 1,                    }])                } else {                    diff_base = buffer.read(cx).as_rope().clone();                    unreviewed_changes = Patch::default();                }                TrackedBuffer {                    buffer: buffer.clone(),                    diff_base,                    unreviewed_changes,                    snapshot: text_snapshot.clone(),                    status,                    version: buffer.read(cx).version(),                    diff,                    diff_update: diff_update_tx,                    _open_lsp_handle: open_lsp_handle,                    _maintain_diff: cx.spawn({                        let buffer = buffer.clone();                        async move |this, cx| {                            Self::maintain_diff(this, buffer, diff_update_rx, cx)                                .await                                .ok();                        }                    }),                    _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),                }            });        tracked_buffer.version = buffer.read(cx).version();        tracked_buffer    }     fn handle_buffer_event(        &mut self,        buffer: Entity<Buffer>,        event: &BufferEvent,        cx: &mut Context<Self>,    ) {        match event {            BufferEvent::Edited { .. } => self.handle_buffer_edited(buffer, cx),            BufferEvent::FileHandleChanged => {                self.handle_buffer_file_changed(buffer, cx);            }            _ => {}        };    }     fn handle_buffer_edited(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {            return;        };        tracked_buffer.schedule_diff_update(ChangeAuthor::User, cx);    }     fn handle_buffer_file_changed(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {            return;        };         match tracked_buffer.status {            TrackedBufferStatus::Created { .. } | TrackedBufferStatus::Modified => {                if buffer                    .read(cx)                    .file()                    .map_or(false, |file| file.disk_state() == DiskState::Deleted)                {                    // If the buffer had been edited by a tool, but it got                    // deleted externally, we want to stop tracking it.                    self.tracked_buffers.remove(&buffer);                }                cx.notify();            }            TrackedBufferStatus::Deleted => {                if buffer                    .read(cx)                    .file()                    .map_or(false, |file| file.disk_state() != DiskState::Deleted)                {                    // If the buffer had been deleted by a tool, but it got                    // resurrected externally, we want to clear the changes we                    // were tracking and reset the buffer's state.                    self.tracked_buffers.remove(&buffer);                    self.track_buffer_internal(buffer, false, cx);                }                cx.notify();            }        }    }     async fn maintain_diff(        this: WeakEntity<Self>,        buffer: Entity<Buffer>,        mut diff_update: mpsc::UnboundedReceiver<(ChangeAuthor, text::BufferSnapshot)>,        cx: &mut AsyncApp,    ) -> Result<()> {        while let Some((author, buffer_snapshot)) = diff_update.next().await {            let (rebase, diff, language, language_registry) =                this.read_with(cx, |this, cx| {                    let tracked_buffer = this                        .tracked_buffers                        .get(&buffer)                        .context("buffer not tracked")?;                     let rebase = cx.background_spawn({                        let mut base_text = tracked_buffer.diff_base.clone();                        let old_snapshot = tracked_buffer.snapshot.clone();                        let new_snapshot = buffer_snapshot.clone();                        let unreviewed_changes = tracked_buffer.unreviewed_changes.clone();                        async move {                            let edits = diff_snapshots(&old_snapshot, &new_snapshot);                            if let ChangeAuthor::User = author {                                apply_non_conflicting_edits(                                    &unreviewed_changes,                                    edits,                                    &mut base_text,                                    new_snapshot.as_rope(),                                );                            }                            (Arc::new(base_text.to_string()), base_text)                        }                    });                     anyhow::Ok((                        rebase,                        tracked_buffer.diff.clone(),                        tracked_buffer.buffer.read(cx).language().cloned(),                        tracked_buffer.buffer.read(cx).language_registry(),                    ))                })??;             let (new_base_text, new_diff_base) = rebase.await;            let diff_snapshot = BufferDiff::update_diff(                diff.clone(),                buffer_snapshot.clone(),                Some(new_base_text),                true,                false,                language,                language_registry,                cx,            )            .await;             let mut unreviewed_changes = Patch::default();            if let Ok(diff_snapshot) = diff_snapshot {                unreviewed_changes = cx                    .background_spawn({                        let diff_snapshot = diff_snapshot.clone();                        let buffer_snapshot = buffer_snapshot.clone();                        let new_diff_base = new_diff_base.clone();                        async move {                            let mut unreviewed_changes = Patch::default();                            for hunk in diff_snapshot.hunks_intersecting_range(                                Anchor::MIN..Anchor::MAX,                                &buffer_snapshot,                            ) {                                let old_range = new_diff_base                                    .offset_to_point(hunk.diff_base_byte_range.start)                                    ..new_diff_base.offset_to_point(hunk.diff_base_byte_range.end);                                let new_range = hunk.range.start..hunk.range.end;                                unreviewed_changes.push(point_to_row_edit(                                    Edit {                                        old: old_range,                                        new: new_range,                                    },                                    &new_diff_base,                                    &buffer_snapshot.as_rope(),                                ));                            }                            unreviewed_changes                        }                    })                    .await;                 diff.update(cx, |diff, cx| {                    diff.set_snapshot(diff_snapshot, &buffer_snapshot, cx)                })?;            }            this.update(cx, |this, cx| {                let tracked_buffer = this                    .tracked_buffers                    .get_mut(&buffer)                    .context("buffer not tracked")?;                tracked_buffer.diff_base = new_diff_base;                tracked_buffer.snapshot = buffer_snapshot;                tracked_buffer.unreviewed_changes = unreviewed_changes;                cx.notify();                anyhow::Ok(())            })??;        }         Ok(())    }     /// Track a buffer as read, so we can notify the model about user edits.    pub fn buffer_read(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        self.track_buffer_internal(buffer, false, cx);    }     /// Mark a buffer as edited, so we can refresh it in the context    pub fn buffer_created(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        self.edited_since_project_diagnostics_check = true;        self.track_buffer_internal(buffer.clone(), true, cx);    }     /// Mark a buffer as edited, so we can refresh it in the context    pub fn buffer_edited(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        self.edited_since_project_diagnostics_check = true;         let tracked_buffer = self.track_buffer_internal(buffer.clone(), false, cx);        if let TrackedBufferStatus::Deleted = tracked_buffer.status {            tracked_buffer.status = TrackedBufferStatus::Modified;        }        tracked_buffer.schedule_diff_update(ChangeAuthor::Agent, cx);    }     pub fn will_delete_buffer(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {        let tracked_buffer = self.track_buffer_internal(buffer.clone(), false, cx);        match tracked_buffer.status {            TrackedBufferStatus::Created { .. } => {                self.tracked_buffers.remove(&buffer);                cx.notify();            }            TrackedBufferStatus::Modified => {                buffer.update(cx, |buffer, cx| buffer.set_text("", cx));                tracked_buffer.status = TrackedBufferStatus::Deleted;                tracked_buffer.schedule_diff_update(ChangeAuthor::Agent, cx);            }            TrackedBufferStatus::Deleted => {}        }        cx.notify();    }     pub fn keep_edits_in_range(        &mut self,        buffer: Entity<Buffer>,        buffer_range: Range<impl language::ToPoint>,        cx: &mut Context<Self>,    ) {        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {            return;        };         match tracked_buffer.status {            TrackedBufferStatus::Deleted => {                self.tracked_buffers.remove(&buffer);                cx.notify();            }            _ => {                let buffer = buffer.read(cx);                let buffer_range =                    buffer_range.start.to_point(buffer)..buffer_range.end.to_point(buffer);                let mut delta = 0i32;                 tracked_buffer.unreviewed_changes.retain_mut(|edit| {                    edit.old.start = (edit.old.start as i32 + delta) as u32;                    edit.old.end = (edit.old.end as i32 + delta) as u32;                     if buffer_range.end.row < edit.new.start                        || buffer_range.start.row > edit.new.end                    {                        true                    } else {                        let old_range = tracked_buffer                            .diff_base                            .point_to_offset(Point::new(edit.old.start, 0))                            ..tracked_buffer.diff_base.point_to_offset(cmp::min(                                Point::new(edit.old.end, 0),                                tracked_buffer.diff_base.max_point(),                            ));                        let new_range = tracked_buffer                            .snapshot                            .point_to_offset(Point::new(edit.new.start, 0))                            ..tracked_buffer.snapshot.point_to_offset(cmp::min(                                Point::new(edit.new.end, 0),                                tracked_buffer.snapshot.max_point(),                            ));                        tracked_buffer.diff_base.replace(                            old_range,                            &tracked_buffer                                .snapshot                                .text_for_range(new_range)                                .collect::<String>(),                        );                        delta += edit.new_len() as i32 - edit.old_len() as i32;                        false                    }                });                tracked_buffer.schedule_diff_update(ChangeAuthor::User, cx);            }        }    }     pub fn reject_edits_in_ranges(        &mut self,        buffer: Entity<Buffer>,        buffer_ranges: Vec<Range<impl language::ToPoint>>,        cx: &mut Context<Self>,    ) -> Task<Result<()>> {        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {            return Task::ready(Ok(()));        };         match &tracked_buffer.status {            TrackedBufferStatus::Created {                existing_file_content,            } => {                let task = if let Some(existing_file_content) = existing_file_content {                    buffer.update(cx, |buffer, cx| {                        buffer.start_transaction();                        buffer.set_text("", cx);                        for chunk in existing_file_content.chunks() {                            buffer.append(chunk, cx);                        }                        buffer.end_transaction(cx);                    });                    self.project                        .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))                } else {                    // For a file created by AI with no pre-existing content,                    // only delete the file if we're certain it contains only AI content                    // with no edits from the user.                     let initial_version = tracked_buffer.version.clone();                    let current_version = buffer.read(cx).version();                     let current_content = buffer.read(cx).text();                    let tracked_content = tracked_buffer.snapshot.text();                     let is_ai_only_content =                        initial_version == current_version && current_content == tracked_content;                     if is_ai_only_content {                        buffer                            .read(cx)                            .entry_id(cx)                            .and_then(|entry_id| {                                self.project.update(cx, |project, cx| {                                    project.delete_entry(entry_id, false, cx)                                })                            })                            .unwrap_or(Task::ready(Ok(())))                    } else {                        // Not sure how to disentangle edits made by the user                        // from edits made by the AI at this point.                        // For now, preserve both to avoid data loss.                        //                        // TODO: Better solution (disable "Reject" after user makes some                        // edit or find a way to differentiate between AI and user edits)                        Task::ready(Ok(()))                    }                };                 self.tracked_buffers.remove(&buffer);                cx.notify();                task            }            TrackedBufferStatus::Deleted => {                buffer.update(cx, |buffer, cx| {                    buffer.set_text(tracked_buffer.diff_base.to_string(), cx)                });                let save = self                    .project                    .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx));                 // Clear all tracked changes for this buffer and start over as if we just read it.                self.tracked_buffers.remove(&buffer);                self.buffer_read(buffer.clone(), cx);                cx.notify();                save            }            TrackedBufferStatus::Modified => {                buffer.update(cx, |buffer, cx| {                    let mut buffer_row_ranges = buffer_ranges                        .into_iter()                        .map(|range| {                            range.start.to_point(buffer).row..range.end.to_point(buffer).row                        })                        .peekable();                     let mut edits_to_revert = Vec::new();                    for edit in tracked_buffer.unreviewed_changes.edits() {                        let new_range = tracked_buffer                            .snapshot                            .anchor_before(Point::new(edit.new.start, 0))                            ..tracked_buffer.snapshot.anchor_after(cmp::min(                                Point::new(edit.new.end, 0),                                tracked_buffer.snapshot.max_point(),                            ));                        let new_row_range = new_range.start.to_point(buffer).row                            ..new_range.end.to_point(buffer).row;                         let mut revert = false;                        while let Some(buffer_row_range) = buffer_row_ranges.peek() {                            if buffer_row_range.end < new_row_range.start {                                buffer_row_ranges.next();                            } else if buffer_row_range.start > new_row_range.end {                                break;                            } else {                                revert = true;                                break;                            }

Lines 1–500 of 1840.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t