1use crate::{
   2    humanize_token_count, prompts::generate_content_prompt, AssistantPanel, AssistantPanelEvent,
   3    Hunk, LanguageModelCompletionProvider, ModelSelector, StreamingDiff,
   4};
   5use anyhow::{anyhow, Context as _, Result};
   6use client::telemetry::Telemetry;
   7use collections::{hash_map, HashMap, HashSet, VecDeque};
   8use editor::{
   9    actions::{MoveDown, MoveUp, SelectAll},
  10    display_map::{
  11        BlockContext, BlockDisposition, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,
  12        ToDisplayPoint,
  13    },
  14    Anchor, AnchorRangeExt, Editor, EditorElement, EditorEvent, EditorMode, EditorStyle,
  15    ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
  16};
  17use fs::Fs;
  18use futures::{
  19    channel::mpsc,
  20    future::LocalBoxFuture,
  21    stream::{self, BoxStream},
  22    SinkExt, Stream, StreamExt,
  23};
  24use gpui::{
  25    point, AppContext, EventEmitter, FocusHandle, FocusableView, Global, HighlightStyle, Model,
  26    ModelContext, Subscription, Task, TextStyle, UpdateGlobal, View, ViewContext, WeakView,
  27    WindowContext,
  28};
  29use language::{Buffer, IndentKind, Point, Selection, TransactionId};
  30use language_model::{LanguageModelRequest, LanguageModelRequestMessage, Role};
  31use multi_buffer::MultiBufferRow;
  32use parking_lot::Mutex;
  33use rope::Rope;
  34use settings::Settings;
  35use similar::TextDiff;
  36use smol::future::FutureExt;
  37use std::{
  38    cmp,
  39    future::Future,
  40    mem,
  41    ops::{Range, RangeInclusive},
  42    pin::Pin,
  43    sync::Arc,
  44    task::{self, Poll},
  45    time::{Duration, Instant},
  46};
  47use theme::ThemeSettings;
  48use ui::{prelude::*, IconButtonShape, Tooltip};
  49use util::RangeExt;
  50use workspace::{notifications::NotificationId, Toast, Workspace};
  51
  52pub fn init(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>, cx: &mut AppContext) {
  53    cx.set_global(InlineAssistant::new(fs, telemetry));
  54}
  55
  56const PROMPT_HISTORY_MAX_LEN: usize = 20;
  57
  58pub struct InlineAssistant {
  59    next_assist_id: InlineAssistId,
  60    next_assist_group_id: InlineAssistGroupId,
  61    assists: HashMap<InlineAssistId, InlineAssist>,
  62    assists_by_editor: HashMap<WeakView<Editor>, EditorInlineAssists>,
  63    assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,
  64    prompt_history: VecDeque<String>,
  65    telemetry: Option<Arc<Telemetry>>,
  66    fs: Arc<dyn Fs>,
  67}
  68
  69impl Global for InlineAssistant {}
  70
  71impl InlineAssistant {
  72    pub fn new(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>) -> Self {
  73        Self {
  74            next_assist_id: InlineAssistId::default(),
  75            next_assist_group_id: InlineAssistGroupId::default(),
  76            assists: HashMap::default(),
  77            assists_by_editor: HashMap::default(),
  78            assist_groups: HashMap::default(),
  79            prompt_history: VecDeque::default(),
  80            telemetry: Some(telemetry),
  81            fs,
  82        }
  83    }
  84
  85    pub fn assist(
  86        &mut self,
  87        editor: &View<Editor>,
  88        workspace: Option<WeakView<Workspace>>,
  89        assistant_panel: Option<&View<AssistantPanel>>,
  90        initial_prompt: Option<String>,
  91        cx: &mut WindowContext,
  92    ) {
  93        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
  94
  95        let mut selections = Vec::<Selection<Point>>::new();
  96        let mut newest_selection = None;
  97        for mut selection in editor.read(cx).selections.all::<Point>(cx) {
  98            if selection.end > selection.start {
  99                selection.start.column = 0;
 100                // If the selection ends at the start of the line, we don't want to include it.
 101                if selection.end.column == 0 {
 102                    selection.end.row -= 1;
 103                }
 104                selection.end.column = snapshot.line_len(MultiBufferRow(selection.end.row));
 105            }
 106
 107            if let Some(prev_selection) = selections.last_mut() {
 108                if selection.start <= prev_selection.end {
 109                    prev_selection.end = selection.end;
 110                    continue;
 111                }
 112            }
 113
 114            let latest_selection = newest_selection.get_or_insert_with(|| selection.clone());
 115            if selection.id > latest_selection.id {
 116                *latest_selection = selection.clone();
 117            }
 118            selections.push(selection);
 119        }
 120        let newest_selection = newest_selection.unwrap();
 121
 122        let mut codegen_ranges = Vec::new();
 123        for (excerpt_id, buffer, buffer_range) in
 124            snapshot.excerpts_in_ranges(selections.iter().map(|selection| {
 125                snapshot.anchor_before(selection.start)..snapshot.anchor_after(selection.end)
 126            }))
 127        {
 128            let start = Anchor {
 129                buffer_id: Some(buffer.remote_id()),
 130                excerpt_id,
 131                text_anchor: buffer.anchor_before(buffer_range.start),
 132            };
 133            let end = Anchor {
 134                buffer_id: Some(buffer.remote_id()),
 135                excerpt_id,
 136                text_anchor: buffer.anchor_after(buffer_range.end),
 137            };
 138            codegen_ranges.push(start..end);
 139        }
 140
 141        let assist_group_id = self.next_assist_group_id.post_inc();
 142        let prompt_buffer =
 143            cx.new_model(|cx| Buffer::local(initial_prompt.unwrap_or_default(), cx));
 144        let prompt_buffer = cx.new_model(|cx| MultiBuffer::singleton(prompt_buffer, cx));
 145
 146        let mut assists = Vec::new();
 147        let mut assist_to_focus = None;
 148        for range in codegen_ranges {
 149            let assist_id = self.next_assist_id.post_inc();
 150            let codegen = cx.new_model(|cx| {
 151                Codegen::new(
 152                    editor.read(cx).buffer().clone(),
 153                    range.clone(),
 154                    None,
 155                    self.telemetry.clone(),
 156                    cx,
 157                )
 158            });
 159
 160            let gutter_dimensions = Arc::new(Mutex::new(GutterDimensions::default()));
 161            let prompt_editor = cx.new_view(|cx| {
 162                PromptEditor::new(
 163                    assist_id,
 164                    gutter_dimensions.clone(),
 165                    self.prompt_history.clone(),
 166                    prompt_buffer.clone(),
 167                    codegen.clone(),
 168                    editor,
 169                    assistant_panel,
 170                    workspace.clone(),
 171                    self.fs.clone(),
 172                    cx,
 173                )
 174            });
 175
 176            if assist_to_focus.is_none() {
 177                let focus_assist = if newest_selection.reversed {
 178                    range.start.to_point(&snapshot) == newest_selection.start
 179                } else {
 180                    range.end.to_point(&snapshot) == newest_selection.end
 181                };
 182                if focus_assist {
 183                    assist_to_focus = Some(assist_id);
 184                }
 185            }
 186
 187            let [prompt_block_id, end_block_id] =
 188                self.insert_assist_blocks(editor, &range, &prompt_editor, cx);
 189
 190            assists.push((assist_id, prompt_editor, prompt_block_id, end_block_id));
 191        }
 192
 193        let editor_assists = self
 194            .assists_by_editor
 195            .entry(editor.downgrade())
 196            .or_insert_with(|| EditorInlineAssists::new(&editor, cx));
 197        let mut assist_group = InlineAssistGroup::new();
 198        for (assist_id, prompt_editor, prompt_block_id, end_block_id) in assists {
 199            self.assists.insert(
 200                assist_id,
 201                InlineAssist::new(
 202                    assist_id,
 203                    assist_group_id,
 204                    assistant_panel.is_some(),
 205                    editor,
 206                    &prompt_editor,
 207                    prompt_block_id,
 208                    end_block_id,
 209                    prompt_editor.read(cx).codegen.clone(),
 210                    workspace.clone(),
 211                    cx,
 212                ),
 213            );
 214            assist_group.assist_ids.push(assist_id);
 215            editor_assists.assist_ids.push(assist_id);
 216        }
 217        self.assist_groups.insert(assist_group_id, assist_group);
 218
 219        if let Some(assist_id) = assist_to_focus {
 220            self.focus_assist(assist_id, cx);
 221        }
 222    }
 223
 224    #[allow(clippy::too_many_arguments)]
 225    pub fn suggest_assist(
 226        &mut self,
 227        editor: &View<Editor>,
 228        mut range: Range<Anchor>,
 229        initial_prompt: String,
 230        initial_insertion: Option<String>,
 231        workspace: Option<WeakView<Workspace>>,
 232        assistant_panel: Option<&View<AssistantPanel>>,
 233        cx: &mut WindowContext,
 234    ) -> InlineAssistId {
 235        let assist_group_id = self.next_assist_group_id.post_inc();
 236        let prompt_buffer = cx.new_model(|cx| Buffer::local(&initial_prompt, cx));
 237        let prompt_buffer = cx.new_model(|cx| MultiBuffer::singleton(prompt_buffer, cx));
 238
 239        let assist_id = self.next_assist_id.post_inc();
 240
 241        let buffer = editor.read(cx).buffer().clone();
 242        let prepend_transaction_id = initial_insertion.and_then(|initial_insertion| {
 243            buffer.update(cx, |buffer, cx| {
 244                buffer.start_transaction(cx);
 245                buffer.edit([(range.start..range.start, initial_insertion)], None, cx);
 246                buffer.end_transaction(cx)
 247            })
 248        });
 249
 250        range.start = range.start.bias_left(&buffer.read(cx).read(cx));
 251        range.end = range.end.bias_right(&buffer.read(cx).read(cx));
 252
 253        let codegen = cx.new_model(|cx| {
 254            Codegen::new(
 255                editor.read(cx).buffer().clone(),
 256                range.clone(),
 257                prepend_transaction_id,
 258                self.telemetry.clone(),
 259                cx,
 260            )
 261        });
 262
 263        let gutter_dimensions = Arc::new(Mutex::new(GutterDimensions::default()));
 264        let prompt_editor = cx.new_view(|cx| {
 265            PromptEditor::new(
 266                assist_id,
 267                gutter_dimensions.clone(),
 268                self.prompt_history.clone(),
 269                prompt_buffer.clone(),
 270                codegen.clone(),
 271                editor,
 272                assistant_panel,
 273                workspace.clone(),
 274                self.fs.clone(),
 275                cx,
 276            )
 277        });
 278
 279        let [prompt_block_id, end_block_id] =
 280            self.insert_assist_blocks(editor, &range, &prompt_editor, cx);
 281
 282        let editor_assists = self
 283            .assists_by_editor
 284            .entry(editor.downgrade())
 285            .or_insert_with(|| EditorInlineAssists::new(&editor, cx));
 286
 287        let mut assist_group = InlineAssistGroup::new();
 288        self.assists.insert(
 289            assist_id,
 290            InlineAssist::new(
 291                assist_id,
 292                assist_group_id,
 293                assistant_panel.is_some(),
 294                editor,
 295                &prompt_editor,
 296                prompt_block_id,
 297                end_block_id,
 298                prompt_editor.read(cx).codegen.clone(),
 299                workspace.clone(),
 300                cx,
 301            ),
 302        );
 303        assist_group.assist_ids.push(assist_id);
 304        editor_assists.assist_ids.push(assist_id);
 305        self.assist_groups.insert(assist_group_id, assist_group);
 306        assist_id
 307    }
 308
 309    fn insert_assist_blocks(
 310        &self,
 311        editor: &View<Editor>,
 312        range: &Range<Anchor>,
 313        prompt_editor: &View<PromptEditor>,
 314        cx: &mut WindowContext,
 315    ) -> [CustomBlockId; 2] {
 316        let assist_blocks = vec![
 317            BlockProperties {
 318                style: BlockStyle::Sticky,
 319                position: range.start,
 320                height: prompt_editor.read(cx).height_in_lines,
 321                render: build_assist_editor_renderer(prompt_editor),
 322                disposition: BlockDisposition::Above,
 323            },
 324            BlockProperties {
 325                style: BlockStyle::Sticky,
 326                position: range.end,
 327                height: 1,
 328                render: Box::new(|cx| {
 329                    v_flex()
 330                        .h_full()
 331                        .w_full()
 332                        .border_t_1()
 333                        .border_color(cx.theme().status().info_border)
 334                        .into_any_element()
 335                }),
 336                disposition: BlockDisposition::Below,
 337            },
 338        ];
 339
 340        editor.update(cx, |editor, cx| {
 341            let block_ids = editor.insert_blocks(assist_blocks, None, cx);
 342            [block_ids[0], block_ids[1]]
 343        })
 344    }
 345
 346    fn handle_prompt_editor_focus_in(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
 347        let assist = &self.assists[&assist_id];
 348        let Some(decorations) = assist.decorations.as_ref() else {
 349            return;
 350        };
 351        let assist_group = self.assist_groups.get_mut(&assist.group_id).unwrap();
 352        let editor_assists = self.assists_by_editor.get_mut(&assist.editor).unwrap();
 353
 354        assist_group.active_assist_id = Some(assist_id);
 355        if assist_group.linked {
 356            for assist_id in &assist_group.assist_ids {
 357                if let Some(decorations) = self.assists[assist_id].decorations.as_ref() {
 358                    decorations.prompt_editor.update(cx, |prompt_editor, cx| {
 359                        prompt_editor.set_show_cursor_when_unfocused(true, cx)
 360                    });
 361                }
 362            }
 363        }
 364
 365        assist
 366            .editor
 367            .update(cx, |editor, cx| {
 368                let scroll_top = editor.scroll_position(cx).y;
 369                let scroll_bottom = scroll_top + editor.visible_line_count().unwrap_or(0.);
 370                let prompt_row = editor
 371                    .row_for_block(decorations.prompt_block_id, cx)
 372                    .unwrap()
 373                    .0 as f32;
 374
 375                if (scroll_top..scroll_bottom).contains(&prompt_row) {
 376                    editor_assists.scroll_lock = Some(InlineAssistScrollLock {
 377                        assist_id,
 378                        distance_from_top: prompt_row - scroll_top,
 379                    });
 380                } else {
 381                    editor_assists.scroll_lock = None;
 382                }
 383            })
 384            .ok();
 385    }
 386
 387    fn handle_prompt_editor_focus_out(
 388        &mut self,
 389        assist_id: InlineAssistId,
 390        cx: &mut WindowContext,
 391    ) {
 392        let assist = &self.assists[&assist_id];
 393        let assist_group = self.assist_groups.get_mut(&assist.group_id).unwrap();
 394        if assist_group.active_assist_id == Some(assist_id) {
 395            assist_group.active_assist_id = None;
 396            if assist_group.linked {
 397                for assist_id in &assist_group.assist_ids {
 398                    if let Some(decorations) = self.assists[assist_id].decorations.as_ref() {
 399                        decorations.prompt_editor.update(cx, |prompt_editor, cx| {
 400                            prompt_editor.set_show_cursor_when_unfocused(false, cx)
 401                        });
 402                    }
 403                }
 404            }
 405        }
 406    }
 407
 408    fn handle_prompt_editor_event(
 409        &mut self,
 410        prompt_editor: View<PromptEditor>,
 411        event: &PromptEditorEvent,
 412        cx: &mut WindowContext,
 413    ) {
 414        let assist_id = prompt_editor.read(cx).id;
 415        match event {
 416            PromptEditorEvent::StartRequested => {
 417                self.start_assist(assist_id, cx);
 418            }
 419            PromptEditorEvent::StopRequested => {
 420                self.stop_assist(assist_id, cx);
 421            }
 422            PromptEditorEvent::ConfirmRequested => {
 423                self.finish_assist(assist_id, false, cx);
 424            }
 425            PromptEditorEvent::CancelRequested => {
 426                self.finish_assist(assist_id, true, cx);
 427            }
 428            PromptEditorEvent::DismissRequested => {
 429                self.dismiss_assist(assist_id, cx);
 430            }
 431            PromptEditorEvent::Resized { height_in_lines } => {
 432                self.resize_assist(assist_id, *height_in_lines, cx);
 433            }
 434        }
 435    }
 436
 437    fn handle_editor_newline(&mut self, editor: View<Editor>, cx: &mut WindowContext) {
 438        let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) else {
 439            return;
 440        };
 441
 442        let editor = editor.read(cx);
 443        if editor.selections.count() == 1 {
 444            let selection = editor.selections.newest::<usize>(cx);
 445            let buffer = editor.buffer().read(cx).snapshot(cx);
 446            for assist_id in &editor_assists.assist_ids {
 447                let assist = &self.assists[assist_id];
 448                let assist_range = assist.codegen.read(cx).range.to_offset(&buffer);
 449                if assist_range.contains(&selection.start) && assist_range.contains(&selection.end)
 450                {
 451                    if matches!(assist.codegen.read(cx).status, CodegenStatus::Pending) {
 452                        self.dismiss_assist(*assist_id, cx);
 453                    } else {
 454                        self.finish_assist(*assist_id, false, cx);
 455                    }
 456
 457                    return;
 458                }
 459            }
 460        }
 461
 462        cx.propagate();
 463    }
 464
 465    fn handle_editor_cancel(&mut self, editor: View<Editor>, cx: &mut WindowContext) {
 466        let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) else {
 467            return;
 468        };
 469
 470        let editor = editor.read(cx);
 471        if editor.selections.count() == 1 {
 472            let selection = editor.selections.newest::<usize>(cx);
 473            let buffer = editor.buffer().read(cx).snapshot(cx);
 474            for assist_id in &editor_assists.assist_ids {
 475                let assist = &self.assists[assist_id];
 476                let assist_range = assist.codegen.read(cx).range.to_offset(&buffer);
 477                if assist.decorations.is_some()
 478                    && assist_range.contains(&selection.start)
 479                    && assist_range.contains(&selection.end)
 480                {
 481                    self.focus_assist(*assist_id, cx);
 482                    return;
 483                }
 484            }
 485        }
 486
 487        cx.propagate();
 488    }
 489
 490    fn handle_editor_release(&mut self, editor: WeakView<Editor>, cx: &mut WindowContext) {
 491        if let Some(editor_assists) = self.assists_by_editor.get_mut(&editor) {
 492            for assist_id in editor_assists.assist_ids.clone() {
 493                self.finish_assist(assist_id, true, cx);
 494            }
 495        }
 496    }
 497
 498    fn handle_editor_change(&mut self, editor: View<Editor>, cx: &mut WindowContext) {
 499        let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) else {
 500            return;
 501        };
 502        let Some(scroll_lock) = editor_assists.scroll_lock.as_ref() else {
 503            return;
 504        };
 505        let assist = &self.assists[&scroll_lock.assist_id];
 506        let Some(decorations) = assist.decorations.as_ref() else {
 507            return;
 508        };
 509
 510        editor.update(cx, |editor, cx| {
 511            let scroll_position = editor.scroll_position(cx);
 512            let target_scroll_top = editor
 513                .row_for_block(decorations.prompt_block_id, cx)
 514                .unwrap()
 515                .0 as f32
 516                - scroll_lock.distance_from_top;
 517            if target_scroll_top != scroll_position.y {
 518                editor.set_scroll_position(point(scroll_position.x, target_scroll_top), cx);
 519            }
 520        });
 521    }
 522
 523    fn handle_editor_event(
 524        &mut self,
 525        editor: View<Editor>,
 526        event: &EditorEvent,
 527        cx: &mut WindowContext,
 528    ) {
 529        let Some(editor_assists) = self.assists_by_editor.get_mut(&editor.downgrade()) else {
 530            return;
 531        };
 532
 533        match event {
 534            EditorEvent::Saved => {
 535                for assist_id in editor_assists.assist_ids.clone() {
 536                    let assist = &self.assists[&assist_id];
 537                    if let CodegenStatus::Done = &assist.codegen.read(cx).status {
 538                        self.finish_assist(assist_id, false, cx)
 539                    }
 540                }
 541            }
 542            EditorEvent::Edited { transaction_id } => {
 543                let buffer = editor.read(cx).buffer().read(cx);
 544                let edited_ranges =
 545                    buffer.edited_ranges_for_transaction::<usize>(*transaction_id, cx);
 546                let snapshot = buffer.snapshot(cx);
 547
 548                for assist_id in editor_assists.assist_ids.clone() {
 549                    let assist = &self.assists[&assist_id];
 550                    if matches!(
 551                        assist.codegen.read(cx).status,
 552                        CodegenStatus::Error(_) | CodegenStatus::Done
 553                    ) {
 554                        let assist_range = assist.codegen.read(cx).range.to_offset(&snapshot);
 555                        if edited_ranges
 556                            .iter()
 557                            .any(|range| range.overlaps(&assist_range))
 558                        {
 559                            self.finish_assist(assist_id, false, cx);
 560                        }
 561                    }
 562                }
 563            }
 564            EditorEvent::ScrollPositionChanged { .. } => {
 565                if let Some(scroll_lock) = editor_assists.scroll_lock.as_ref() {
 566                    let assist = &self.assists[&scroll_lock.assist_id];
 567                    if let Some(decorations) = assist.decorations.as_ref() {
 568                        let distance_from_top = editor.update(cx, |editor, cx| {
 569                            let scroll_top = editor.scroll_position(cx).y;
 570                            let prompt_row = editor
 571                                .row_for_block(decorations.prompt_block_id, cx)
 572                                .unwrap()
 573                                .0 as f32;
 574                            prompt_row - scroll_top
 575                        });
 576
 577                        if distance_from_top != scroll_lock.distance_from_top {
 578                            editor_assists.scroll_lock = None;
 579                        }
 580                    }
 581                }
 582            }
 583            EditorEvent::SelectionsChanged { .. } => {
 584                for assist_id in editor_assists.assist_ids.clone() {
 585                    let assist = &self.assists[&assist_id];
 586                    if let Some(decorations) = assist.decorations.as_ref() {
 587                        if decorations.prompt_editor.focus_handle(cx).is_focused(cx) {
 588                            return;
 589                        }
 590                    }
 591                }
 592
 593                editor_assists.scroll_lock = None;
 594            }
 595            _ => {}
 596        }
 597    }
 598
 599    fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
 600        if let Some(assist) = self.assists.get(&assist_id) {
 601            let assist_group_id = assist.group_id;
 602            if self.assist_groups[&assist_group_id].linked {
 603                for assist_id in self.unlink_assist_group(assist_group_id, cx) {
 604                    self.finish_assist(assist_id, undo, cx);
 605                }
 606                return;
 607            }
 608        }
 609
 610        self.dismiss_assist(assist_id, cx);
 611
 612        if let Some(assist) = self.assists.remove(&assist_id) {
 613            if let hash_map::Entry::Occupied(mut entry) = self.assist_groups.entry(assist.group_id)
 614            {
 615                entry.get_mut().assist_ids.retain(|id| *id != assist_id);
 616                if entry.get().assist_ids.is_empty() {
 617                    entry.remove();
 618                }
 619            }
 620
 621            if let hash_map::Entry::Occupied(mut entry) =
 622                self.assists_by_editor.entry(assist.editor.clone())
 623            {
 624                entry.get_mut().assist_ids.retain(|id| *id != assist_id);
 625                if entry.get().assist_ids.is_empty() {
 626                    entry.remove();
 627                    if let Some(editor) = assist.editor.upgrade() {
 628                        self.update_editor_highlights(&editor, cx);
 629                    }
 630                } else {
 631                    entry.get().highlight_updates.send(()).ok();
 632                }
 633            }
 634
 635            if undo {
 636                assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
 637            }
 638        }
 639    }
 640
 641    fn dismiss_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) -> bool {
 642        let Some(assist) = self.assists.get_mut(&assist_id) else {
 643            return false;
 644        };
 645        let Some(editor) = assist.editor.upgrade() else {
 646            return false;
 647        };
 648        let Some(decorations) = assist.decorations.take() else {
 649            return false;
 650        };
 651
 652        editor.update(cx, |editor, cx| {
 653            let mut to_remove = decorations.removed_line_block_ids;
 654            to_remove.insert(decorations.prompt_block_id);
 655            to_remove.insert(decorations.end_block_id);
 656            editor.remove_blocks(to_remove, None, cx);
 657        });
 658
 659        if decorations
 660            .prompt_editor
 661            .focus_handle(cx)
 662            .contains_focused(cx)
 663        {
 664            self.focus_next_assist(assist_id, cx);
 665        }
 666
 667        if let Some(editor_assists) = self.assists_by_editor.get_mut(&editor.downgrade()) {
 668            if editor_assists
 669                .scroll_lock
 670                .as_ref()
 671                .map_or(false, |lock| lock.assist_id == assist_id)
 672            {
 673                editor_assists.scroll_lock = None;
 674            }
 675            editor_assists.highlight_updates.send(()).ok();
 676        }
 677
 678        true
 679    }
 680
 681    fn focus_next_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
 682        let Some(assist) = self.assists.get(&assist_id) else {
 683            return;
 684        };
 685
 686        let assist_group = &self.assist_groups[&assist.group_id];
 687        let assist_ix = assist_group
 688            .assist_ids
 689            .iter()
 690            .position(|id| *id == assist_id)
 691            .unwrap();
 692        let assist_ids = assist_group
 693            .assist_ids
 694            .iter()
 695            .skip(assist_ix + 1)
 696            .chain(assist_group.assist_ids.iter().take(assist_ix));
 697
 698        for assist_id in assist_ids {
 699            let assist = &self.assists[assist_id];
 700            if assist.decorations.is_some() {
 701                self.focus_assist(*assist_id, cx);
 702                return;
 703            }
 704        }
 705
 706        assist.editor.update(cx, |editor, cx| editor.focus(cx)).ok();
 707    }
 708
 709    fn focus_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
 710        let assist = &self.assists[&assist_id];
 711        let Some(editor) = assist.editor.upgrade() else {
 712            return;
 713        };
 714
 715        if let Some(decorations) = assist.decorations.as_ref() {
 716            decorations.prompt_editor.update(cx, |prompt_editor, cx| {
 717                prompt_editor.editor.update(cx, |editor, cx| {
 718                    editor.focus(cx);
 719                    editor.select_all(&SelectAll, cx);
 720                })
 721            });
 722        }
 723
 724        let position = assist.codegen.read(cx).range.start;
 725        editor.update(cx, |editor, cx| {
 726            editor.change_selections(None, cx, |selections| {
 727                selections.select_anchor_ranges([position..position])
 728            });
 729
 730            let mut scroll_target_top;
 731            let mut scroll_target_bottom;
 732            if let Some(decorations) = assist.decorations.as_ref() {
 733                scroll_target_top = editor
 734                    .row_for_block(decorations.prompt_block_id, cx)
 735                    .unwrap()
 736                    .0 as f32;
 737                scroll_target_bottom = editor
 738                    .row_for_block(decorations.end_block_id, cx)
 739                    .unwrap()
 740                    .0 as f32;
 741            } else {
 742                let snapshot = editor.snapshot(cx);
 743                let codegen = assist.codegen.read(cx);
 744                let start_row = codegen
 745                    .range
 746                    .start
 747                    .to_display_point(&snapshot.display_snapshot)
 748                    .row();
 749                scroll_target_top = start_row.0 as f32;
 750                scroll_target_bottom = scroll_target_top + 1.;
 751            }
 752            scroll_target_top -= editor.vertical_scroll_margin() as f32;
 753            scroll_target_bottom += editor.vertical_scroll_margin() as f32;
 754
 755            let height_in_lines = editor.visible_line_count().unwrap_or(0.);
 756            let scroll_top = editor.scroll_position(cx).y;
 757            let scroll_bottom = scroll_top + height_in_lines;
 758
 759            if scroll_target_top < scroll_top {
 760                editor.set_scroll_position(point(0., scroll_target_top), cx);
 761            } else if scroll_target_bottom > scroll_bottom {
 762                if (scroll_target_bottom - scroll_target_top) <= height_in_lines {
 763                    editor
 764                        .set_scroll_position(point(0., scroll_target_bottom - height_in_lines), cx);
 765                } else {
 766                    editor.set_scroll_position(point(0., scroll_target_top), cx);
 767                }
 768            }
 769        });
 770    }
 771
 772    fn resize_assist(
 773        &mut self,
 774        assist_id: InlineAssistId,
 775        height_in_lines: u8,
 776        cx: &mut WindowContext,
 777    ) {
 778        if let Some(assist) = self.assists.get_mut(&assist_id) {
 779            if let Some(editor) = assist.editor.upgrade() {
 780                if let Some(decorations) = assist.decorations.as_ref() {
 781                    let mut new_blocks = HashMap::default();
 782                    new_blocks.insert(
 783                        decorations.prompt_block_id,
 784                        (
 785                            Some(height_in_lines),
 786                            build_assist_editor_renderer(&decorations.prompt_editor),
 787                        ),
 788                    );
 789                    editor.update(cx, |editor, cx| {
 790                        editor
 791                            .display_map
 792                            .update(cx, |map, cx| map.replace_blocks(new_blocks, cx))
 793                    });
 794                }
 795            }
 796        }
 797    }
 798
 799    fn unlink_assist_group(
 800        &mut self,
 801        assist_group_id: InlineAssistGroupId,
 802        cx: &mut WindowContext,
 803    ) -> Vec<InlineAssistId> {
 804        let assist_group = self.assist_groups.get_mut(&assist_group_id).unwrap();
 805        assist_group.linked = false;
 806        for assist_id in &assist_group.assist_ids {
 807            let assist = self.assists.get_mut(assist_id).unwrap();
 808            if let Some(editor_decorations) = assist.decorations.as_ref() {
 809                editor_decorations
 810                    .prompt_editor
 811                    .update(cx, |prompt_editor, cx| prompt_editor.unlink(cx));
 812            }
 813        }
 814        assist_group.assist_ids.clone()
 815    }
 816
 817    pub fn start_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
 818        let assist = if let Some(assist) = self.assists.get_mut(&assist_id) {
 819            assist
 820        } else {
 821            return;
 822        };
 823
 824        let assist_group_id = assist.group_id;
 825        if self.assist_groups[&assist_group_id].linked {
 826            for assist_id in self.unlink_assist_group(assist_group_id, cx) {
 827                self.start_assist(assist_id, cx);
 828            }
 829            return;
 830        }
 831
 832        let Some(user_prompt) = assist
 833            .decorations
 834            .as_ref()
 835            .map(|decorations| decorations.prompt_editor.read(cx).prompt(cx))
 836        else {
 837            return;
 838        };
 839
 840        self.prompt_history.retain(|prompt| *prompt != user_prompt);
 841        self.prompt_history.push_back(user_prompt.clone());
 842        if self.prompt_history.len() > PROMPT_HISTORY_MAX_LEN {
 843            self.prompt_history.pop_front();
 844        }
 845
 846        let codegen = assist.codegen.clone();
 847        let telemetry_id = LanguageModelCompletionProvider::read_global(cx)
 848            .active_model()
 849            .map(|m| m.telemetry_id())
 850            .unwrap_or_default();
 851        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
 852            if user_prompt.trim().to_lowercase() == "delete" {
 853                async { Ok(stream::empty().boxed()) }.boxed_local()
 854            } else {
 855                let request = self.request_for_inline_assist(assist_id, cx);
 856                let mut cx = cx.to_async();
 857                async move {
 858                    let request = request.await?;
 859                    let chunks = cx
 860                        .update(|cx| {
 861                            LanguageModelCompletionProvider::read_global(cx)
 862                                .stream_completion(request, cx)
 863                        })?
 864                        .await?;
 865                    Ok(chunks.boxed())
 866                }
 867                .boxed_local()
 868            };
 869        codegen.update(cx, |codegen, cx| {
 870            codegen.start(telemetry_id, chunks, cx);
 871        });
 872    }
 873
 874    fn request_for_inline_assist(
 875        &self,
 876        assist_id: InlineAssistId,
 877        cx: &mut WindowContext,
 878    ) -> Task<Result<LanguageModelRequest>> {
 879        cx.spawn(|mut cx| async move {
 880            let (user_prompt, context_request, project_name, buffer, range) =
 881                cx.read_global(|this: &InlineAssistant, cx: &WindowContext| {
 882                    let assist = this.assists.get(&assist_id).context("invalid assist")?;
 883                    let decorations = assist.decorations.as_ref().context("invalid assist")?;
 884                    let editor = assist.editor.upgrade().context("invalid assist")?;
 885                    let user_prompt = decorations.prompt_editor.read(cx).prompt(cx);
 886                    let context_request = if assist.include_context {
 887                        assist.workspace.as_ref().and_then(|workspace| {
 888                            let workspace = workspace.upgrade()?.read(cx);
 889                            let assistant_panel = workspace.panel::<AssistantPanel>(cx)?;
 890                            Some(
 891                                assistant_panel
 892                                    .read(cx)
 893                                    .active_context(cx)?
 894                                    .read(cx)
 895                                    .to_completion_request(cx),
 896                            )
 897                        })
 898                    } else {
 899                        None
 900                    };
 901                    let project_name = assist.workspace.as_ref().and_then(|workspace| {
 902                        let workspace = workspace.upgrade()?;
 903                        Some(
 904                            workspace
 905                                .read(cx)
 906                                .project()
 907                                .read(cx)
 908                                .worktree_root_names(cx)
 909                                .collect::<Vec<&str>>()
 910                                .join("/"),
 911                        )
 912                    });
 913                    let buffer = editor.read(cx).buffer().read(cx).snapshot(cx);
 914                    let range = assist.codegen.read(cx).range.clone();
 915                    anyhow::Ok((user_prompt, context_request, project_name, buffer, range))
 916                })??;
 917
 918            let language = buffer.language_at(range.start);
 919            let language_name = if let Some(language) = language.as_ref() {
 920                if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
 921                    None
 922                } else {
 923                    Some(language.name())
 924                }
 925            } else {
 926                None
 927            };
 928
 929            // Higher Temperature increases the randomness of model outputs.
 930            // If Markdown or No Language is Known, increase the randomness for more creative output
 931            // If Code, decrease temperature to get more deterministic outputs
 932            let temperature = if let Some(language) = language_name.clone() {
 933                if language.as_ref() == "Markdown" {
 934                    1.0
 935                } else {
 936                    0.5
 937                }
 938            } else {
 939                1.0
 940            };
 941
 942            let prompt = cx
 943                .background_executor()
 944                .spawn(async move {
 945                    let language_name = language_name.as_deref();
 946                    let start = buffer.point_to_buffer_offset(range.start);
 947                    let end = buffer.point_to_buffer_offset(range.end);
 948                    let (buffer, range) = if let Some((start, end)) = start.zip(end) {
 949                        let (start_buffer, start_buffer_offset) = start;
 950                        let (end_buffer, end_buffer_offset) = end;
 951                        if start_buffer.remote_id() == end_buffer.remote_id() {
 952                            (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
 953                        } else {
 954                            return Err(anyhow!("invalid transformation range"));
 955                        }
 956                    } else {
 957                        return Err(anyhow!("invalid transformation range"));
 958                    };
 959                    generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
 960                })
 961                .await?;
 962
 963            let mut messages = Vec::new();
 964            if let Some(context_request) = context_request {
 965                messages = context_request.messages;
 966            }
 967
 968            messages.push(LanguageModelRequestMessage {
 969                role: Role::User,
 970                content: prompt,
 971            });
 972
 973            Ok(LanguageModelRequest {
 974                messages,
 975                stop: vec!["|END|>".to_string()],
 976                temperature,
 977            })
 978        })
 979    }
 980
 981    pub fn stop_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
 982        let assist = if let Some(assist) = self.assists.get_mut(&assist_id) {
 983            assist
 984        } else {
 985            return;
 986        };
 987
 988        assist.codegen.update(cx, |codegen, cx| codegen.stop(cx));
 989    }
 990
 991    fn update_editor_highlights(&self, editor: &View<Editor>, cx: &mut WindowContext) {
 992        let mut gutter_pending_ranges = Vec::new();
 993        let mut gutter_transformed_ranges = Vec::new();
 994        let mut foreground_ranges = Vec::new();
 995        let mut inserted_row_ranges = Vec::new();
 996        let empty_assist_ids = Vec::new();
 997        let assist_ids = self
 998            .assists_by_editor
 999            .get(&editor.downgrade())
1000            .map_or(&empty_assist_ids, |editor_assists| {
1001                &editor_assists.assist_ids
1002            });
1003
1004        for assist_id in assist_ids {
1005            if let Some(assist) = self.assists.get(assist_id) {
1006                let codegen = assist.codegen.read(cx);
1007                foreground_ranges.extend(codegen.last_equal_ranges().iter().cloned());
1008
1009                if codegen.edit_position != codegen.range.end {
1010                    gutter_pending_ranges.push(codegen.edit_position..codegen.range.end);
1011                }
1012
1013                if codegen.range.start != codegen.edit_position {
1014                    gutter_transformed_ranges.push(codegen.range.start..codegen.edit_position);
1015                }
1016
1017                if assist.decorations.is_some() {
1018                    inserted_row_ranges.extend(codegen.diff.inserted_row_ranges.iter().cloned());
1019                }
1020            }
1021        }
1022
1023        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
1024        merge_ranges(&mut foreground_ranges, &snapshot);
1025        merge_ranges(&mut gutter_pending_ranges, &snapshot);
1026        merge_ranges(&mut gutter_transformed_ranges, &snapshot);
1027        editor.update(cx, |editor, cx| {
1028            enum GutterPendingRange {}
1029            if gutter_pending_ranges.is_empty() {
1030                editor.clear_gutter_highlights::<GutterPendingRange>(cx);
1031            } else {
1032                editor.highlight_gutter::<GutterPendingRange>(
1033                    &gutter_pending_ranges,
1034                    |cx| cx.theme().status().info_background,
1035                    cx,
1036                )
1037            }
1038
1039            enum GutterTransformedRange {}
1040            if gutter_transformed_ranges.is_empty() {
1041                editor.clear_gutter_highlights::<GutterTransformedRange>(cx);
1042            } else {
1043                editor.highlight_gutter::<GutterTransformedRange>(
1044                    &gutter_transformed_ranges,
1045                    |cx| cx.theme().status().info,
1046                    cx,
1047                )
1048            }
1049
1050            if foreground_ranges.is_empty() {
1051                editor.clear_highlights::<InlineAssist>(cx);
1052            } else {
1053                editor.highlight_text::<InlineAssist>(
1054                    foreground_ranges,
1055                    HighlightStyle {
1056                        fade_out: Some(0.6),
1057                        ..Default::default()
1058                    },
1059                    cx,
1060                );
1061            }
1062
1063            editor.clear_row_highlights::<InlineAssist>();
1064            for row_range in inserted_row_ranges {
1065                editor.highlight_rows::<InlineAssist>(
1066                    row_range,
1067                    Some(cx.theme().status().info_background),
1068                    false,
1069                    cx,
1070                );
1071            }
1072        });
1073    }
1074
1075    fn update_editor_blocks(
1076        &mut self,
1077        editor: &View<Editor>,
1078        assist_id: InlineAssistId,
1079        cx: &mut WindowContext,
1080    ) {
1081        let Some(assist) = self.assists.get_mut(&assist_id) else {
1082            return;
1083        };
1084        let Some(decorations) = assist.decorations.as_mut() else {
1085            return;
1086        };
1087
1088        let codegen = assist.codegen.read(cx);
1089        let old_snapshot = codegen.snapshot.clone();
1090        let old_buffer = codegen.old_buffer.clone();
1091        let deleted_row_ranges = codegen.diff.deleted_row_ranges.clone();
1092
1093        editor.update(cx, |editor, cx| {
1094            let old_blocks = mem::take(&mut decorations.removed_line_block_ids);
1095            editor.remove_blocks(old_blocks, None, cx);
1096
1097            let mut new_blocks = Vec::new();
1098            for (new_row, old_row_range) in deleted_row_ranges {
1099                let (_, buffer_start) = old_snapshot
1100                    .point_to_buffer_offset(Point::new(*old_row_range.start(), 0))
1101                    .unwrap();
1102                let (_, buffer_end) = old_snapshot
1103                    .point_to_buffer_offset(Point::new(
1104                        *old_row_range.end(),
1105                        old_snapshot.line_len(MultiBufferRow(*old_row_range.end())),
1106                    ))
1107                    .unwrap();
1108
1109                let deleted_lines_editor = cx.new_view(|cx| {
1110                    let multi_buffer = cx.new_model(|_| {
1111                        MultiBuffer::without_headers(0, language::Capability::ReadOnly)
1112                    });
1113                    multi_buffer.update(cx, |multi_buffer, cx| {
1114                        multi_buffer.push_excerpts(
1115                            old_buffer.clone(),
1116                            Some(ExcerptRange {
1117                                context: buffer_start..buffer_end,
1118                                primary: None,
1119                            }),
1120                            cx,
1121                        );
1122                    });
1123
1124                    enum DeletedLines {}
1125                    let mut editor = Editor::for_multibuffer(multi_buffer, None, true, cx);
1126                    editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx);
1127                    editor.set_show_wrap_guides(false, cx);
1128                    editor.set_show_gutter(false, cx);
1129                    editor.scroll_manager.set_forbid_vertical_scroll(true);
1130                    editor.set_read_only(true);
1131                    editor.highlight_rows::<DeletedLines>(
1132                        Anchor::min()..=Anchor::max(),
1133                        Some(cx.theme().status().deleted_background),
1134                        false,
1135                        cx,
1136                    );
1137                    editor
1138                });
1139
1140                let height = deleted_lines_editor
1141                    .update(cx, |editor, cx| editor.max_point(cx).row().0 as u8 + 1);
1142                new_blocks.push(BlockProperties {
1143                    position: new_row,
1144                    height,
1145                    style: BlockStyle::Flex,
1146                    render: Box::new(move |cx| {
1147                        div()
1148                            .bg(cx.theme().status().deleted_background)
1149                            .size_full()
1150                            .pl(cx.gutter_dimensions.full_width())
1151                            .child(deleted_lines_editor.clone())
1152                            .into_any_element()
1153                    }),
1154                    disposition: BlockDisposition::Above,
1155                });
1156            }
1157
1158            decorations.removed_line_block_ids = editor
1159                .insert_blocks(new_blocks, None, cx)
1160                .into_iter()
1161                .collect();
1162        })
1163    }
1164}
1165
1166struct EditorInlineAssists {
1167    assist_ids: Vec<InlineAssistId>,
1168    scroll_lock: Option<InlineAssistScrollLock>,
1169    highlight_updates: async_watch::Sender<()>,
1170    _update_highlights: Task<Result<()>>,
1171    _subscriptions: Vec<gpui::Subscription>,
1172}
1173
1174struct InlineAssistScrollLock {
1175    assist_id: InlineAssistId,
1176    distance_from_top: f32,
1177}
1178
1179impl EditorInlineAssists {
1180    #[allow(clippy::too_many_arguments)]
1181    fn new(editor: &View<Editor>, cx: &mut WindowContext) -> Self {
1182        let (highlight_updates_tx, mut highlight_updates_rx) = async_watch::channel(());
1183        Self {
1184            assist_ids: Vec::new(),
1185            scroll_lock: None,
1186            highlight_updates: highlight_updates_tx,
1187            _update_highlights: cx.spawn(|mut cx| {
1188                let editor = editor.downgrade();
1189                async move {
1190                    while let Ok(()) = highlight_updates_rx.changed().await {
1191                        let editor = editor.upgrade().context("editor was dropped")?;
1192                        cx.update_global(|assistant: &mut InlineAssistant, cx| {
1193                            assistant.update_editor_highlights(&editor, cx);
1194                        })?;
1195                    }
1196                    Ok(())
1197                }
1198            }),
1199            _subscriptions: vec![
1200                cx.observe_release(editor, {
1201                    let editor = editor.downgrade();
1202                    |_, cx| {
1203                        InlineAssistant::update_global(cx, |this, cx| {
1204                            this.handle_editor_release(editor, cx);
1205                        })
1206                    }
1207                }),
1208                cx.observe(editor, move |editor, cx| {
1209                    InlineAssistant::update_global(cx, |this, cx| {
1210                        this.handle_editor_change(editor, cx)
1211                    })
1212                }),
1213                cx.subscribe(editor, move |editor, event, cx| {
1214                    InlineAssistant::update_global(cx, |this, cx| {
1215                        this.handle_editor_event(editor, event, cx)
1216                    })
1217                }),
1218                editor.update(cx, |editor, cx| {
1219                    let editor_handle = cx.view().downgrade();
1220                    editor.register_action(
1221                        move |_: &editor::actions::Newline, cx: &mut WindowContext| {
1222                            InlineAssistant::update_global(cx, |this, cx| {
1223                                if let Some(editor) = editor_handle.upgrade() {
1224                                    this.handle_editor_newline(editor, cx)
1225                                }
1226                            })
1227                        },
1228                    )
1229                }),
1230                editor.update(cx, |editor, cx| {
1231                    let editor_handle = cx.view().downgrade();
1232                    editor.register_action(
1233                        move |_: &editor::actions::Cancel, cx: &mut WindowContext| {
1234                            InlineAssistant::update_global(cx, |this, cx| {
1235                                if let Some(editor) = editor_handle.upgrade() {
1236                                    this.handle_editor_cancel(editor, cx)
1237                                }
1238                            })
1239                        },
1240                    )
1241                }),
1242            ],
1243        }
1244    }
1245}
1246
1247struct InlineAssistGroup {
1248    assist_ids: Vec<InlineAssistId>,
1249    linked: bool,
1250    active_assist_id: Option<InlineAssistId>,
1251}
1252
1253impl InlineAssistGroup {
1254    fn new() -> Self {
1255        Self {
1256            assist_ids: Vec::new(),
1257            linked: true,
1258            active_assist_id: None,
1259        }
1260    }
1261}
1262
1263fn build_assist_editor_renderer(editor: &View<PromptEditor>) -> RenderBlock {
1264    let editor = editor.clone();
1265    Box::new(move |cx: &mut BlockContext| {
1266        *editor.read(cx).gutter_dimensions.lock() = *cx.gutter_dimensions;
1267        editor.clone().into_any_element()
1268    })
1269}
1270
1271#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
1272pub struct InlineAssistId(usize);
1273
1274impl InlineAssistId {
1275    fn post_inc(&mut self) -> InlineAssistId {
1276        let id = *self;
1277        self.0 += 1;
1278        id
1279    }
1280}
1281
1282#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
1283struct InlineAssistGroupId(usize);
1284
1285impl InlineAssistGroupId {
1286    fn post_inc(&mut self) -> InlineAssistGroupId {
1287        let id = *self;
1288        self.0 += 1;
1289        id
1290    }
1291}
1292
1293enum PromptEditorEvent {
1294    StartRequested,
1295    StopRequested,
1296    ConfirmRequested,
1297    CancelRequested,
1298    DismissRequested,
1299    Resized { height_in_lines: u8 },
1300}
1301
1302struct PromptEditor {
1303    id: InlineAssistId,
1304    fs: Arc<dyn Fs>,
1305    height_in_lines: u8,
1306    editor: View<Editor>,
1307    edited_since_done: bool,
1308    gutter_dimensions: Arc<Mutex<GutterDimensions>>,
1309    prompt_history: VecDeque<String>,
1310    prompt_history_ix: Option<usize>,
1311    pending_prompt: String,
1312    codegen: Model<Codegen>,
1313    _codegen_subscription: Subscription,
1314    editor_subscriptions: Vec<Subscription>,
1315    pending_token_count: Task<Result<()>>,
1316    token_count: Option<usize>,
1317    _token_count_subscriptions: Vec<Subscription>,
1318    workspace: Option<WeakView<Workspace>>,
1319}
1320
1321impl EventEmitter<PromptEditorEvent> for PromptEditor {}
1322
1323impl Render for PromptEditor {
1324    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1325        let gutter_dimensions = *self.gutter_dimensions.lock();
1326        let buttons = match &self.codegen.read(cx).status {
1327            CodegenStatus::Idle => {
1328                vec![
1329                    IconButton::new("cancel", IconName::Close)
1330                        .icon_color(Color::Muted)
1331                        .shape(IconButtonShape::Square)
1332                        .tooltip(|cx| Tooltip::for_action("Cancel Assist", &menu::Cancel, cx))
1333                        .on_click(
1334                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
1335                        ),
1336                    IconButton::new("start", IconName::SparkleAlt)
1337                        .icon_color(Color::Muted)
1338                        .shape(IconButtonShape::Square)
1339                        .tooltip(|cx| Tooltip::for_action("Transform", &menu::Confirm, cx))
1340                        .on_click(
1341                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::StartRequested)),
1342                        ),
1343                ]
1344            }
1345            CodegenStatus::Pending => {
1346                vec![
1347                    IconButton::new("cancel", IconName::Close)
1348                        .icon_color(Color::Muted)
1349                        .shape(IconButtonShape::Square)
1350                        .tooltip(|cx| Tooltip::text("Cancel Assist", cx))
1351                        .on_click(
1352                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
1353                        ),
1354                    IconButton::new("stop", IconName::Stop)
1355                        .icon_color(Color::Error)
1356                        .shape(IconButtonShape::Square)
1357                        .tooltip(|cx| {
1358                            Tooltip::with_meta(
1359                                "Interrupt Transformation",
1360                                Some(&menu::Cancel),
1361                                "Changes won't be discarded",
1362                                cx,
1363                            )
1364                        })
1365                        .on_click(
1366                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::StopRequested)),
1367                        ),
1368                ]
1369            }
1370            CodegenStatus::Error(_) | CodegenStatus::Done => {
1371                vec![
1372                    IconButton::new("cancel", IconName::Close)
1373                        .icon_color(Color::Muted)
1374                        .shape(IconButtonShape::Square)
1375                        .tooltip(|cx| Tooltip::for_action("Cancel Assist", &menu::Cancel, cx))
1376                        .on_click(
1377                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
1378                        ),
1379                    if self.edited_since_done {
1380                        IconButton::new("restart", IconName::RotateCw)
1381                            .icon_color(Color::Info)
1382                            .shape(IconButtonShape::Square)
1383                            .tooltip(|cx| {
1384                                Tooltip::with_meta(
1385                                    "Restart Transformation",
1386                                    Some(&menu::Confirm),
1387                                    "Changes will be discarded",
1388                                    cx,
1389                                )
1390                            })
1391                            .on_click(cx.listener(|_, _, cx| {
1392                                cx.emit(PromptEditorEvent::StartRequested);
1393                            }))
1394                    } else {
1395                        IconButton::new("confirm", IconName::Check)
1396                            .icon_color(Color::Info)
1397                            .shape(IconButtonShape::Square)
1398                            .tooltip(|cx| Tooltip::for_action("Confirm Assist", &menu::Confirm, cx))
1399                            .on_click(cx.listener(|_, _, cx| {
1400                                cx.emit(PromptEditorEvent::ConfirmRequested);
1401                            }))
1402                    },
1403                ]
1404            }
1405        };
1406
1407        h_flex()
1408            .bg(cx.theme().colors().editor_background)
1409            .border_y_1()
1410            .border_color(cx.theme().status().info_border)
1411            .py_1p5()
1412            .h_full()
1413            .w_full()
1414            .on_action(cx.listener(Self::confirm))
1415            .on_action(cx.listener(Self::cancel))
1416            .on_action(cx.listener(Self::move_up))
1417            .on_action(cx.listener(Self::move_down))
1418            .child(
1419                h_flex()
1420                    .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
1421                    .justify_center()
1422                    .gap_2()
1423                    .child(
1424                        ModelSelector::new(
1425                            self.fs.clone(),
1426                            IconButton::new("context", IconName::SlidersAlt)
1427                                .shape(IconButtonShape::Square)
1428                                .icon_size(IconSize::Small)
1429                                .icon_color(Color::Muted)
1430                                .tooltip(move |cx| {
1431                                    Tooltip::with_meta(
1432                                        format!(
1433                                            "Using {}",
1434                                            LanguageModelCompletionProvider::read_global(cx)
1435                                                .active_model()
1436                                                .map(|model| model.name().0)
1437                                                .unwrap_or_else(|| "No model selected".into()),
1438                                        ),
1439                                        None,
1440                                        "Change Model",
1441                                        cx,
1442                                    )
1443                                }),
1444                        )
1445                        .with_info_text(
1446                            "Inline edits use context\n\
1447                            from the currently selected\n\
1448                            assistant panel tab.",
1449                        ),
1450                    )
1451                    .children(
1452                        if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
1453                            let error_message = SharedString::from(error.to_string());
1454                            Some(
1455                                div()
1456                                    .id("error")
1457                                    .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
1458                                    .child(
1459                                        Icon::new(IconName::XCircle)
1460                                            .size(IconSize::Small)
1461                                            .color(Color::Error),
1462                                    ),
1463                            )
1464                        } else {
1465                            None
1466                        },
1467                    ),
1468            )
1469            .child(div().flex_1().child(self.render_prompt_editor(cx)))
1470            .child(
1471                h_flex()
1472                    .gap_2()
1473                    .pr_6()
1474                    .children(self.render_token_count(cx))
1475                    .children(buttons),
1476            )
1477    }
1478}
1479
1480impl FocusableView for PromptEditor {
1481    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
1482        self.editor.focus_handle(cx)
1483    }
1484}
1485
1486impl PromptEditor {
1487    const MAX_LINES: u8 = 8;
1488
1489    #[allow(clippy::too_many_arguments)]
1490    fn new(
1491        id: InlineAssistId,
1492        gutter_dimensions: Arc<Mutex<GutterDimensions>>,
1493        prompt_history: VecDeque<String>,
1494        prompt_buffer: Model<MultiBuffer>,
1495        codegen: Model<Codegen>,
1496        parent_editor: &View<Editor>,
1497        assistant_panel: Option<&View<AssistantPanel>>,
1498        workspace: Option<WeakView<Workspace>>,
1499        fs: Arc<dyn Fs>,
1500        cx: &mut ViewContext<Self>,
1501    ) -> Self {
1502        let prompt_editor = cx.new_view(|cx| {
1503            let mut editor = Editor::new(
1504                EditorMode::AutoHeight {
1505                    max_lines: Self::MAX_LINES as usize,
1506                },
1507                prompt_buffer,
1508                None,
1509                false,
1510                cx,
1511            );
1512            editor.set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx);
1513            // Since the prompt editors for all inline assistants are linked,
1514            // always show the cursor (even when it isn't focused) because
1515            // typing in one will make what you typed appear in all of them.
1516            editor.set_show_cursor_when_unfocused(true, cx);
1517            editor.set_placeholder_text("Add a prompt…", cx);
1518            editor
1519        });
1520
1521        let mut token_count_subscriptions = Vec::new();
1522        token_count_subscriptions
1523            .push(cx.subscribe(parent_editor, Self::handle_parent_editor_event));
1524        if let Some(assistant_panel) = assistant_panel {
1525            token_count_subscriptions
1526                .push(cx.subscribe(assistant_panel, Self::handle_assistant_panel_event));
1527        }
1528
1529        let mut this = Self {
1530            id,
1531            height_in_lines: 1,
1532            editor: prompt_editor,
1533            edited_since_done: false,
1534            gutter_dimensions,
1535            prompt_history,
1536            prompt_history_ix: None,
1537            pending_prompt: String::new(),
1538            _codegen_subscription: cx.observe(&codegen, Self::handle_codegen_changed),
1539            editor_subscriptions: Vec::new(),
1540            codegen,
1541            fs,
1542            pending_token_count: Task::ready(Ok(())),
1543            token_count: None,
1544            _token_count_subscriptions: token_count_subscriptions,
1545            workspace,
1546        };
1547        this.count_lines(cx);
1548        this.count_tokens(cx);
1549        this.subscribe_to_editor(cx);
1550        this
1551    }
1552
1553    fn subscribe_to_editor(&mut self, cx: &mut ViewContext<Self>) {
1554        self.editor_subscriptions.clear();
1555        self.editor_subscriptions
1556            .push(cx.observe(&self.editor, Self::handle_prompt_editor_changed));
1557        self.editor_subscriptions
1558            .push(cx.subscribe(&self.editor, Self::handle_prompt_editor_events));
1559    }
1560
1561    fn set_show_cursor_when_unfocused(
1562        &mut self,
1563        show_cursor_when_unfocused: bool,
1564        cx: &mut ViewContext<Self>,
1565    ) {
1566        self.editor.update(cx, |editor, cx| {
1567            editor.set_show_cursor_when_unfocused(show_cursor_when_unfocused, cx)
1568        });
1569    }
1570
1571    fn unlink(&mut self, cx: &mut ViewContext<Self>) {
1572        let prompt = self.prompt(cx);
1573        let focus = self.editor.focus_handle(cx).contains_focused(cx);
1574        self.editor = cx.new_view(|cx| {
1575            let mut editor = Editor::auto_height(Self::MAX_LINES as usize, cx);
1576            editor.set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx);
1577            editor.set_placeholder_text("Add a prompt…", cx);
1578            editor.set_text(prompt, cx);
1579            if focus {
1580                editor.focus(cx);
1581            }
1582            editor
1583        });
1584        self.subscribe_to_editor(cx);
1585    }
1586
1587    fn prompt(&self, cx: &AppContext) -> String {
1588        self.editor.read(cx).text(cx)
1589    }
1590
1591    fn count_lines(&mut self, cx: &mut ViewContext<Self>) {
1592        let height_in_lines = cmp::max(
1593            2, // Make the editor at least two lines tall, to account for padding and buttons.
1594            cmp::min(
1595                self.editor
1596                    .update(cx, |editor, cx| editor.max_point(cx).row().0 + 1),
1597                Self::MAX_LINES as u32,
1598            ),
1599        ) as u8;
1600
1601        if height_in_lines != self.height_in_lines {
1602            self.height_in_lines = height_in_lines;
1603            cx.emit(PromptEditorEvent::Resized { height_in_lines });
1604        }
1605    }
1606
1607    fn handle_parent_editor_event(
1608        &mut self,
1609        _: View<Editor>,
1610        event: &EditorEvent,
1611        cx: &mut ViewContext<Self>,
1612    ) {
1613        if let EditorEvent::BufferEdited { .. } = event {
1614            self.count_tokens(cx);
1615        }
1616    }
1617
1618    fn handle_assistant_panel_event(
1619        &mut self,
1620        _: View<AssistantPanel>,
1621        event: &AssistantPanelEvent,
1622        cx: &mut ViewContext<Self>,
1623    ) {
1624        let AssistantPanelEvent::ContextEdited { .. } = event;
1625        self.count_tokens(cx);
1626    }
1627
1628    fn count_tokens(&mut self, cx: &mut ViewContext<Self>) {
1629        let assist_id = self.id;
1630        self.pending_token_count = cx.spawn(|this, mut cx| async move {
1631            cx.background_executor().timer(Duration::from_secs(1)).await;
1632            let request = cx
1633                .update_global(|inline_assistant: &mut InlineAssistant, cx| {
1634                    inline_assistant.request_for_inline_assist(assist_id, cx)
1635                })?
1636                .await?;
1637
1638            if let Some(token_count) = cx.update(|cx| {
1639                LanguageModelCompletionProvider::read_global(cx).count_tokens(request, cx)
1640            })? {
1641                let token_count = token_count.await?;
1642
1643                this.update(&mut cx, |this, cx| {
1644                    this.token_count = Some(token_count);
1645                    cx.notify();
1646                })
1647            } else {
1648                Ok(())
1649            }
1650        })
1651    }
1652
1653    fn handle_prompt_editor_changed(&mut self, _: View<Editor>, cx: &mut ViewContext<Self>) {
1654        self.count_lines(cx);
1655    }
1656
1657    fn handle_prompt_editor_events(
1658        &mut self,
1659        _: View<Editor>,
1660        event: &EditorEvent,
1661        cx: &mut ViewContext<Self>,
1662    ) {
1663        match event {
1664            EditorEvent::Edited { .. } => {
1665                let prompt = self.editor.read(cx).text(cx);
1666                if self
1667                    .prompt_history_ix
1668                    .map_or(true, |ix| self.prompt_history[ix] != prompt)
1669                {
1670                    self.prompt_history_ix.take();
1671                    self.pending_prompt = prompt;
1672                }
1673
1674                self.edited_since_done = true;
1675                cx.notify();
1676            }
1677            EditorEvent::BufferEdited => {
1678                self.count_tokens(cx);
1679            }
1680            _ => {}
1681        }
1682    }
1683
1684    fn handle_codegen_changed(&mut self, _: Model<Codegen>, cx: &mut ViewContext<Self>) {
1685        match &self.codegen.read(cx).status {
1686            CodegenStatus::Idle => {
1687                self.editor
1688                    .update(cx, |editor, _| editor.set_read_only(false));
1689            }
1690            CodegenStatus::Pending => {
1691                self.editor
1692                    .update(cx, |editor, _| editor.set_read_only(true));
1693            }
1694            CodegenStatus::Done | CodegenStatus::Error(_) => {
1695                self.edited_since_done = false;
1696                self.editor
1697                    .update(cx, |editor, _| editor.set_read_only(false));
1698            }
1699        }
1700    }
1701
1702    fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
1703        match &self.codegen.read(cx).status {
1704            CodegenStatus::Idle | CodegenStatus::Done | CodegenStatus::Error(_) => {
1705                cx.emit(PromptEditorEvent::CancelRequested);
1706            }
1707            CodegenStatus::Pending => {
1708                cx.emit(PromptEditorEvent::StopRequested);
1709            }
1710        }
1711    }
1712
1713    fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
1714        match &self.codegen.read(cx).status {
1715            CodegenStatus::Idle => {
1716                cx.emit(PromptEditorEvent::StartRequested);
1717            }
1718            CodegenStatus::Pending => {
1719                cx.emit(PromptEditorEvent::DismissRequested);
1720            }
1721            CodegenStatus::Done | CodegenStatus::Error(_) => {
1722                if self.edited_since_done {
1723                    cx.emit(PromptEditorEvent::StartRequested);
1724                } else {
1725                    cx.emit(PromptEditorEvent::ConfirmRequested);
1726                }
1727            }
1728        }
1729    }
1730
1731    fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext<Self>) {
1732        if let Some(ix) = self.prompt_history_ix {
1733            if ix > 0 {
1734                self.prompt_history_ix = Some(ix - 1);
1735                let prompt = self.prompt_history[ix - 1].as_str();
1736                self.editor.update(cx, |editor, cx| {
1737                    editor.set_text(prompt, cx);
1738                    editor.move_to_beginning(&Default::default(), cx);
1739                });
1740            }
1741        } else if !self.prompt_history.is_empty() {
1742            self.prompt_history_ix = Some(self.prompt_history.len() - 1);
1743            let prompt = self.prompt_history[self.prompt_history.len() - 1].as_str();
1744            self.editor.update(cx, |editor, cx| {
1745                editor.set_text(prompt, cx);
1746                editor.move_to_beginning(&Default::default(), cx);
1747            });
1748        }
1749    }
1750
1751    fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
1752        if let Some(ix) = self.prompt_history_ix {
1753            if ix < self.prompt_history.len() - 1 {
1754                self.prompt_history_ix = Some(ix + 1);
1755                let prompt = self.prompt_history[ix + 1].as_str();
1756                self.editor.update(cx, |editor, cx| {
1757                    editor.set_text(prompt, cx);
1758                    editor.move_to_end(&Default::default(), cx)
1759                });
1760            } else {
1761                self.prompt_history_ix = None;
1762                let prompt = self.pending_prompt.as_str();
1763                self.editor.update(cx, |editor, cx| {
1764                    editor.set_text(prompt, cx);
1765                    editor.move_to_end(&Default::default(), cx)
1766                });
1767            }
1768        }
1769    }
1770
1771    fn render_token_count(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
1772        let model = LanguageModelCompletionProvider::read_global(cx).active_model()?;
1773        let token_count = self.token_count?;
1774        let max_token_count = model.max_token_count();
1775
1776        let remaining_tokens = max_token_count as isize - token_count as isize;
1777        let token_count_color = if remaining_tokens <= 0 {
1778            Color::Error
1779        } else if token_count as f32 / max_token_count as f32 >= 0.8 {
1780            Color::Warning
1781        } else {
1782            Color::Muted
1783        };
1784
1785        let mut token_count = h_flex()
1786            .id("token_count")
1787            .gap_0p5()
1788            .child(
1789                Label::new(humanize_token_count(token_count))
1790                    .size(LabelSize::Small)
1791                    .color(token_count_color),
1792            )
1793            .child(Label::new("/").size(LabelSize::Small).color(Color::Muted))
1794            .child(
1795                Label::new(humanize_token_count(max_token_count))
1796                    .size(LabelSize::Small)
1797                    .color(Color::Muted),
1798            );
1799        if let Some(workspace) = self.workspace.clone() {
1800            token_count = token_count
1801                .tooltip(|cx| {
1802                    Tooltip::with_meta(
1803                        "Tokens Used by Inline Assistant",
1804                        None,
1805                        "Click to Open Assistant Panel",
1806                        cx,
1807                    )
1808                })
1809                .cursor_pointer()
1810                .on_mouse_down(gpui::MouseButton::Left, |_, cx| cx.stop_propagation())
1811                .on_click(move |_, cx| {
1812                    cx.stop_propagation();
1813                    workspace
1814                        .update(cx, |workspace, cx| {
1815                            workspace.focus_panel::<AssistantPanel>(cx)
1816                        })
1817                        .ok();
1818                });
1819        } else {
1820            token_count = token_count
1821                .cursor_default()
1822                .tooltip(|cx| Tooltip::text("Tokens Used by Inline Assistant", cx));
1823        }
1824
1825        Some(token_count)
1826    }
1827
1828    fn render_prompt_editor(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1829        let settings = ThemeSettings::get_global(cx);
1830        let text_style = TextStyle {
1831            color: if self.editor.read(cx).read_only(cx) {
1832                cx.theme().colors().text_disabled
1833            } else {
1834                cx.theme().colors().text
1835            },
1836            font_family: settings.ui_font.family.clone(),
1837            font_features: settings.ui_font.features.clone(),
1838            font_fallbacks: settings.ui_font.fallbacks.clone(),
1839            font_size: rems(0.875).into(),
1840            font_weight: settings.ui_font.weight,
1841            line_height: relative(1.3),
1842            ..Default::default()
1843        };
1844        EditorElement::new(
1845            &self.editor,
1846            EditorStyle {
1847                background: cx.theme().colors().editor_background,
1848                local_player: cx.theme().players().local(),
1849                text: text_style,
1850                ..Default::default()
1851            },
1852        )
1853    }
1854}
1855
1856struct InlineAssist {
1857    group_id: InlineAssistGroupId,
1858    editor: WeakView<Editor>,
1859    decorations: Option<InlineAssistDecorations>,
1860    codegen: Model<Codegen>,
1861    _subscriptions: Vec<Subscription>,
1862    workspace: Option<WeakView<Workspace>>,
1863    include_context: bool,
1864}
1865
1866impl InlineAssist {
1867    #[allow(clippy::too_many_arguments)]
1868    fn new(
1869        assist_id: InlineAssistId,
1870        group_id: InlineAssistGroupId,
1871        include_context: bool,
1872        editor: &View<Editor>,
1873        prompt_editor: &View<PromptEditor>,
1874        prompt_block_id: CustomBlockId,
1875        end_block_id: CustomBlockId,
1876        codegen: Model<Codegen>,
1877        workspace: Option<WeakView<Workspace>>,
1878        cx: &mut WindowContext,
1879    ) -> Self {
1880        let prompt_editor_focus_handle = prompt_editor.focus_handle(cx);
1881        InlineAssist {
1882            group_id,
1883            include_context,
1884            editor: editor.downgrade(),
1885            decorations: Some(InlineAssistDecorations {
1886                prompt_block_id,
1887                prompt_editor: prompt_editor.clone(),
1888                removed_line_block_ids: HashSet::default(),
1889                end_block_id,
1890            }),
1891            codegen: codegen.clone(),
1892            workspace: workspace.clone(),
1893            _subscriptions: vec![
1894                cx.on_focus_in(&prompt_editor_focus_handle, move |cx| {
1895                    InlineAssistant::update_global(cx, |this, cx| {
1896                        this.handle_prompt_editor_focus_in(assist_id, cx)
1897                    })
1898                }),
1899                cx.on_focus_out(&prompt_editor_focus_handle, move |_, cx| {
1900                    InlineAssistant::update_global(cx, |this, cx| {
1901                        this.handle_prompt_editor_focus_out(assist_id, cx)
1902                    })
1903                }),
1904                cx.subscribe(prompt_editor, |prompt_editor, event, cx| {
1905                    InlineAssistant::update_global(cx, |this, cx| {
1906                        this.handle_prompt_editor_event(prompt_editor, event, cx)
1907                    })
1908                }),
1909                cx.observe(&codegen, {
1910                    let editor = editor.downgrade();
1911                    move |_, cx| {
1912                        if let Some(editor) = editor.upgrade() {
1913                            InlineAssistant::update_global(cx, |this, cx| {
1914                                if let Some(editor_assists) =
1915                                    this.assists_by_editor.get(&editor.downgrade())
1916                                {
1917                                    editor_assists.highlight_updates.send(()).ok();
1918                                }
1919
1920                                this.update_editor_blocks(&editor, assist_id, cx);
1921                            })
1922                        }
1923                    }
1924                }),
1925                cx.subscribe(&codegen, move |codegen, event, cx| {
1926                    InlineAssistant::update_global(cx, |this, cx| match event {
1927                        CodegenEvent::Undone => this.finish_assist(assist_id, false, cx),
1928                        CodegenEvent::Finished => {
1929                            let assist = if let Some(assist) = this.assists.get(&assist_id) {
1930                                assist
1931                            } else {
1932                                return;
1933                            };
1934
1935                            if let CodegenStatus::Error(error) = &codegen.read(cx).status {
1936                                if assist.decorations.is_none() {
1937                                    if let Some(workspace) = assist
1938                                        .workspace
1939                                        .as_ref()
1940                                        .and_then(|workspace| workspace.upgrade())
1941                                    {
1942                                        let error = format!("Inline assistant error: {}", error);
1943                                        workspace.update(cx, |workspace, cx| {
1944                                            struct InlineAssistantError;
1945
1946                                            let id =
1947                                                NotificationId::identified::<InlineAssistantError>(
1948                                                    assist_id.0,
1949                                                );
1950
1951                                            workspace.show_toast(Toast::new(id, error), cx);
1952                                        })
1953                                    }
1954                                }
1955                            }
1956
1957                            if assist.decorations.is_none() {
1958                                this.finish_assist(assist_id, false, cx);
1959                            }
1960                        }
1961                    })
1962                }),
1963            ],
1964        }
1965    }
1966}
1967
1968struct InlineAssistDecorations {
1969    prompt_block_id: CustomBlockId,
1970    prompt_editor: View<PromptEditor>,
1971    removed_line_block_ids: HashSet<CustomBlockId>,
1972    end_block_id: CustomBlockId,
1973}
1974
1975#[derive(Debug)]
1976pub enum CodegenEvent {
1977    Finished,
1978    Undone,
1979}
1980
1981pub struct Codegen {
1982    buffer: Model<MultiBuffer>,
1983    old_buffer: Model<Buffer>,
1984    snapshot: MultiBufferSnapshot,
1985    range: Range<Anchor>,
1986    edit_position: Anchor,
1987    last_equal_ranges: Vec<Range<Anchor>>,
1988    prepend_transaction_id: Option<TransactionId>,
1989    generation_transaction_id: Option<TransactionId>,
1990    status: CodegenStatus,
1991    generation: Task<()>,
1992    diff: Diff,
1993    telemetry: Option<Arc<Telemetry>>,
1994    _subscription: gpui::Subscription,
1995}
1996
1997enum CodegenStatus {
1998    Idle,
1999    Pending,
2000    Done,
2001    Error(anyhow::Error),
2002}
2003
2004#[derive(Default)]
2005struct Diff {
2006    task: Option<Task<()>>,
2007    should_update: bool,
2008    deleted_row_ranges: Vec<(Anchor, RangeInclusive<u32>)>,
2009    inserted_row_ranges: Vec<RangeInclusive<Anchor>>,
2010}
2011
2012impl EventEmitter<CodegenEvent> for Codegen {}
2013
2014impl Codegen {
2015    pub fn new(
2016        buffer: Model<MultiBuffer>,
2017        range: Range<Anchor>,
2018        prepend_transaction_id: Option<TransactionId>,
2019        telemetry: Option<Arc<Telemetry>>,
2020        cx: &mut ModelContext<Self>,
2021    ) -> Self {
2022        let snapshot = buffer.read(cx).snapshot(cx);
2023
2024        let (old_buffer, _, _) = buffer
2025            .read(cx)
2026            .range_to_buffer_ranges(range.clone(), cx)
2027            .pop()
2028            .unwrap();
2029        let old_buffer = cx.new_model(|cx| {
2030            let old_buffer = old_buffer.read(cx);
2031            let text = old_buffer.as_rope().clone();
2032            let line_ending = old_buffer.line_ending();
2033            let language = old_buffer.language().cloned();
2034            let language_registry = old_buffer.language_registry();
2035
2036            let mut buffer = Buffer::local_normalized(text, line_ending, cx);
2037            buffer.set_language(language, cx);
2038            if let Some(language_registry) = language_registry {
2039                buffer.set_language_registry(language_registry)
2040            }
2041            buffer
2042        });
2043
2044        Self {
2045            buffer: buffer.clone(),
2046            old_buffer,
2047            edit_position: range.start,
2048            range,
2049            snapshot,
2050            last_equal_ranges: Default::default(),
2051            prepend_transaction_id,
2052            generation_transaction_id: None,
2053            status: CodegenStatus::Idle,
2054            generation: Task::ready(()),
2055            diff: Diff::default(),
2056            telemetry,
2057            _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
2058        }
2059    }
2060
2061    fn handle_buffer_event(
2062        &mut self,
2063        _buffer: Model<MultiBuffer>,
2064        event: &multi_buffer::Event,
2065        cx: &mut ModelContext<Self>,
2066    ) {
2067        if let multi_buffer::Event::TransactionUndone { transaction_id } = event {
2068            if self.generation_transaction_id == Some(*transaction_id) {
2069                self.generation_transaction_id = None;
2070                self.generation = Task::ready(());
2071                cx.emit(CodegenEvent::Undone);
2072            } else if self.prepend_transaction_id == Some(*transaction_id) {
2073                self.prepend_transaction_id = None;
2074                self.generation_transaction_id = None;
2075                self.generation = Task::ready(());
2076                cx.emit(CodegenEvent::Undone);
2077            }
2078        }
2079    }
2080
2081    pub fn last_equal_ranges(&self) -> &[Range<Anchor>] {
2082        &self.last_equal_ranges
2083    }
2084
2085    pub fn start(
2086        &mut self,
2087        telemetry_id: String,
2088        stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
2089        cx: &mut ModelContext<Self>,
2090    ) {
2091        let range = self.range.clone();
2092        let snapshot = self.snapshot.clone();
2093        let selected_text = snapshot
2094            .text_for_range(range.start..range.end)
2095            .collect::<Rope>();
2096
2097        let selection_start = range.start.to_point(&snapshot);
2098
2099        // Start with the indentation of the first line in the selection
2100        let mut suggested_line_indent = snapshot
2101            .suggested_indents(selection_start.row..=selection_start.row, cx)
2102            .into_values()
2103            .next()
2104            .unwrap_or_else(|| snapshot.indent_size_for_line(MultiBufferRow(selection_start.row)));
2105
2106        // If the first line in the selection does not have indentation, check the following lines
2107        if suggested_line_indent.len == 0 && suggested_line_indent.kind == IndentKind::Space {
2108            for row in selection_start.row..=range.end.to_point(&snapshot).row {
2109                let line_indent = snapshot.indent_size_for_line(MultiBufferRow(row));
2110                // Prefer tabs if a line in the selection uses tabs as indentation
2111                if line_indent.kind == IndentKind::Tab {
2112                    suggested_line_indent.kind = IndentKind::Tab;
2113                    break;
2114                }
2115            }
2116        }
2117
2118        let telemetry = self.telemetry.clone();
2119        self.edit_position = range.start;
2120        self.diff = Diff::default();
2121        self.status = CodegenStatus::Pending;
2122        if let Some(transaction_id) = self.generation_transaction_id.take() {
2123            self.buffer
2124                .update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
2125        }
2126        self.generation = cx.spawn(|this, mut cx| {
2127            async move {
2128                let chunks = stream.await;
2129                let generate = async {
2130                    let mut edit_start = range.start.to_offset(&snapshot);
2131
2132                    let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
2133                    let diff: Task<anyhow::Result<()>> =
2134                        cx.background_executor().spawn(async move {
2135                            let mut response_latency = None;
2136                            let request_start = Instant::now();
2137                            let diff = async {
2138                                let chunks = StripInvalidSpans::new(chunks?);
2139                                futures::pin_mut!(chunks);
2140                                let mut diff = StreamingDiff::new(selected_text.to_string());
2141
2142                                let mut new_text = String::new();
2143                                let mut base_indent = None;
2144                                let mut line_indent = None;
2145                                let mut first_line = true;
2146
2147                                while let Some(chunk) = chunks.next().await {
2148                                    if response_latency.is_none() {
2149                                        response_latency = Some(request_start.elapsed());
2150                                    }
2151                                    let chunk = chunk?;
2152
2153                                    let mut lines = chunk.split('\n').peekable();
2154                                    while let Some(line) = lines.next() {
2155                                        new_text.push_str(line);
2156                                        if line_indent.is_none() {
2157                                            if let Some(non_whitespace_ch_ix) =
2158                                                new_text.find(|ch: char| !ch.is_whitespace())
2159                                            {
2160                                                line_indent = Some(non_whitespace_ch_ix);
2161                                                base_indent = base_indent.or(line_indent);
2162
2163                                                let line_indent = line_indent.unwrap();
2164                                                let base_indent = base_indent.unwrap();
2165                                                let indent_delta =
2166                                                    line_indent as i32 - base_indent as i32;
2167                                                let mut corrected_indent_len = cmp::max(
2168                                                    0,
2169                                                    suggested_line_indent.len as i32 + indent_delta,
2170                                                )
2171                                                    as usize;
2172                                                if first_line {
2173                                                    corrected_indent_len = corrected_indent_len
2174                                                        .saturating_sub(
2175                                                            selection_start.column as usize,
2176                                                        );
2177                                                }
2178
2179                                                let indent_char = suggested_line_indent.char();
2180                                                let mut indent_buffer = [0; 4];
2181                                                let indent_str =
2182                                                    indent_char.encode_utf8(&mut indent_buffer);
2183                                                new_text.replace_range(
2184                                                    ..line_indent,
2185                                                    &indent_str.repeat(corrected_indent_len),
2186                                                );
2187                                            }
2188                                        }
2189
2190                                        if line_indent.is_some() {
2191                                            hunks_tx.send(diff.push_new(&new_text)).await?;
2192                                            new_text.clear();
2193                                        }
2194
2195                                        if lines.peek().is_some() {
2196                                            hunks_tx.send(diff.push_new("\n")).await?;
2197                                            if line_indent.is_none() {
2198                                                // Don't write out the leading indentation in empty lines on the next line
2199                                                // This is the case where the above if statement didn't clear the buffer
2200                                                new_text.clear();
2201                                            }
2202                                            line_indent = None;
2203                                            first_line = false;
2204                                        }
2205                                    }
2206                                }
2207                                hunks_tx.send(diff.push_new(&new_text)).await?;
2208                                hunks_tx.send(diff.finish()).await?;
2209
2210                                anyhow::Ok(())
2211                            };
2212
2213                            let result = diff.await;
2214
2215                            let error_message =
2216                                result.as_ref().err().map(|error| error.to_string());
2217                            if let Some(telemetry) = telemetry {
2218                                telemetry.report_assistant_event(
2219                                    None,
2220                                    telemetry_events::AssistantKind::Inline,
2221                                    telemetry_id,
2222                                    response_latency,
2223                                    error_message,
2224                                );
2225                            }
2226
2227                            result?;
2228                            Ok(())
2229                        });
2230
2231                    while let Some(hunks) = hunks_rx.next().await {
2232                        this.update(&mut cx, |this, cx| {
2233                            this.last_equal_ranges.clear();
2234
2235                            let transaction = this.buffer.update(cx, |buffer, cx| {
2236                                // Avoid grouping assistant edits with user edits.
2237                                buffer.finalize_last_transaction(cx);
2238
2239                                buffer.start_transaction(cx);
2240                                buffer.edit(
2241                                    hunks.into_iter().filter_map(|hunk| match hunk {
2242                                        Hunk::Insert { text } => {
2243                                            let edit_start = snapshot.anchor_after(edit_start);
2244                                            Some((edit_start..edit_start, text))
2245                                        }
2246                                        Hunk::Remove { len } => {
2247                                            let edit_end = edit_start + len;
2248                                            let edit_range = snapshot.anchor_after(edit_start)
2249                                                ..snapshot.anchor_before(edit_end);
2250                                            edit_start = edit_end;
2251                                            Some((edit_range, String::new()))
2252                                        }
2253                                        Hunk::Keep { len } => {
2254                                            let edit_end = edit_start + len;
2255                                            let edit_range = snapshot.anchor_after(edit_start)
2256                                                ..snapshot.anchor_before(edit_end);
2257                                            edit_start = edit_end;
2258                                            this.last_equal_ranges.push(edit_range);
2259                                            None
2260                                        }
2261                                    }),
2262                                    None,
2263                                    cx,
2264                                );
2265                                this.edit_position = snapshot.anchor_after(edit_start);
2266
2267                                buffer.end_transaction(cx)
2268                            });
2269
2270                            if let Some(transaction) = transaction {
2271                                if let Some(first_transaction) = this.generation_transaction_id {
2272                                    // Group all assistant edits into the first transaction.
2273                                    this.buffer.update(cx, |buffer, cx| {
2274                                        buffer.merge_transactions(
2275                                            transaction,
2276                                            first_transaction,
2277                                            cx,
2278                                        )
2279                                    });
2280                                } else {
2281                                    this.generation_transaction_id = Some(transaction);
2282                                    this.buffer.update(cx, |buffer, cx| {
2283                                        buffer.finalize_last_transaction(cx)
2284                                    });
2285                                }
2286                            }
2287
2288                            this.update_diff(cx);
2289                            cx.notify();
2290                        })?;
2291                    }
2292
2293                    diff.await?;
2294
2295                    anyhow::Ok(())
2296                };
2297
2298                let result = generate.await;
2299                this.update(&mut cx, |this, cx| {
2300                    this.last_equal_ranges.clear();
2301                    if let Err(error) = result {
2302                        this.status = CodegenStatus::Error(error);
2303                    } else {
2304                        this.status = CodegenStatus::Done;
2305                    }
2306                    cx.emit(CodegenEvent::Finished);
2307                    cx.notify();
2308                })
2309                .ok();
2310            }
2311        });
2312        cx.notify();
2313    }
2314
2315    pub fn stop(&mut self, cx: &mut ModelContext<Self>) {
2316        self.last_equal_ranges.clear();
2317        self.status = CodegenStatus::Done;
2318        self.generation = Task::ready(());
2319        cx.emit(CodegenEvent::Finished);
2320        cx.notify();
2321    }
2322
2323    pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
2324        if let Some(transaction_id) = self.prepend_transaction_id.take() {
2325            self.buffer
2326                .update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
2327        }
2328
2329        if let Some(transaction_id) = self.generation_transaction_id.take() {
2330            self.buffer
2331                .update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
2332        }
2333    }
2334
2335    fn update_diff(&mut self, cx: &mut ModelContext<Self>) {
2336        if self.diff.task.is_some() {
2337            self.diff.should_update = true;
2338        } else {
2339            self.diff.should_update = false;
2340
2341            let old_snapshot = self.snapshot.clone();
2342            let old_range = self.range.to_point(&old_snapshot);
2343            let new_snapshot = self.buffer.read(cx).snapshot(cx);
2344            let new_range = self.range.to_point(&new_snapshot);
2345
2346            self.diff.task = Some(cx.spawn(|this, mut cx| async move {
2347                let (deleted_row_ranges, inserted_row_ranges) = cx
2348                    .background_executor()
2349                    .spawn(async move {
2350                        let old_text = old_snapshot
2351                            .text_for_range(
2352                                Point::new(old_range.start.row, 0)
2353                                    ..Point::new(
2354                                        old_range.end.row,
2355                                        old_snapshot.line_len(MultiBufferRow(old_range.end.row)),
2356                                    ),
2357                            )
2358                            .collect::<String>();
2359                        let new_text = new_snapshot
2360                            .text_for_range(
2361                                Point::new(new_range.start.row, 0)
2362                                    ..Point::new(
2363                                        new_range.end.row,
2364                                        new_snapshot.line_len(MultiBufferRow(new_range.end.row)),
2365                                    ),
2366                            )
2367                            .collect::<String>();
2368
2369                        let mut old_row = old_range.start.row;
2370                        let mut new_row = new_range.start.row;
2371                        let diff = TextDiff::from_lines(old_text.as_str(), new_text.as_str());
2372
2373                        let mut deleted_row_ranges: Vec<(Anchor, RangeInclusive<u32>)> = Vec::new();
2374                        let mut inserted_row_ranges = Vec::new();
2375                        for change in diff.iter_all_changes() {
2376                            let line_count = change.value().lines().count() as u32;
2377                            match change.tag() {
2378                                similar::ChangeTag::Equal => {
2379                                    old_row += line_count;
2380                                    new_row += line_count;
2381                                }
2382                                similar::ChangeTag::Delete => {
2383                                    let old_end_row = old_row + line_count - 1;
2384                                    let new_row =
2385                                        new_snapshot.anchor_before(Point::new(new_row, 0));
2386
2387                                    if let Some((_, last_deleted_row_range)) =
2388                                        deleted_row_ranges.last_mut()
2389                                    {
2390                                        if *last_deleted_row_range.end() + 1 == old_row {
2391                                            *last_deleted_row_range =
2392                                                *last_deleted_row_range.start()..=old_end_row;
2393                                        } else {
2394                                            deleted_row_ranges
2395                                                .push((new_row, old_row..=old_end_row));
2396                                        }
2397                                    } else {
2398                                        deleted_row_ranges.push((new_row, old_row..=old_end_row));
2399                                    }
2400
2401                                    old_row += line_count;
2402                                }
2403                                similar::ChangeTag::Insert => {
2404                                    let new_end_row = new_row + line_count - 1;
2405                                    let start = new_snapshot.anchor_before(Point::new(new_row, 0));
2406                                    let end = new_snapshot.anchor_before(Point::new(
2407                                        new_end_row,
2408                                        new_snapshot.line_len(MultiBufferRow(new_end_row)),
2409                                    ));
2410                                    inserted_row_ranges.push(start..=end);
2411                                    new_row += line_count;
2412                                }
2413                            }
2414                        }
2415
2416                        (deleted_row_ranges, inserted_row_ranges)
2417                    })
2418                    .await;
2419
2420                this.update(&mut cx, |this, cx| {
2421                    this.diff.deleted_row_ranges = deleted_row_ranges;
2422                    this.diff.inserted_row_ranges = inserted_row_ranges;
2423                    this.diff.task = None;
2424                    if this.diff.should_update {
2425                        this.update_diff(cx);
2426                    }
2427                    cx.notify();
2428                })
2429                .ok();
2430            }));
2431        }
2432    }
2433}
2434
2435struct StripInvalidSpans<T> {
2436    stream: T,
2437    stream_done: bool,
2438    buffer: String,
2439    first_line: bool,
2440    line_end: bool,
2441    starts_with_code_block: bool,
2442}
2443
2444impl<T> StripInvalidSpans<T>
2445where
2446    T: Stream<Item = Result<String>>,
2447{
2448    fn new(stream: T) -> Self {
2449        Self {
2450            stream,
2451            stream_done: false,
2452            buffer: String::new(),
2453            first_line: true,
2454            line_end: false,
2455            starts_with_code_block: false,
2456        }
2457    }
2458}
2459
2460impl<T> Stream for StripInvalidSpans<T>
2461where
2462    T: Stream<Item = Result<String>>,
2463{
2464    type Item = Result<String>;
2465
2466    fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Option<Self::Item>> {
2467        const CODE_BLOCK_DELIMITER: &str = "```";
2468        const CURSOR_SPAN: &str = "<|CURSOR|>";
2469
2470        let this = unsafe { self.get_unchecked_mut() };
2471        loop {
2472            if !this.stream_done {
2473                let mut stream = unsafe { Pin::new_unchecked(&mut this.stream) };
2474                match stream.as_mut().poll_next(cx) {
2475                    Poll::Ready(Some(Ok(chunk))) => {
2476                        this.buffer.push_str(&chunk);
2477                    }
2478                    Poll::Ready(Some(Err(error))) => return Poll::Ready(Some(Err(error))),
2479                    Poll::Ready(None) => {
2480                        this.stream_done = true;
2481                    }
2482                    Poll::Pending => return Poll::Pending,
2483                }
2484            }
2485
2486            let mut chunk = String::new();
2487            let mut consumed = 0;
2488            if !this.buffer.is_empty() {
2489                let mut lines = this.buffer.split('\n').enumerate().peekable();
2490                while let Some((line_ix, line)) = lines.next() {
2491                    if line_ix > 0 {
2492                        this.first_line = false;
2493                    }
2494
2495                    if this.first_line {
2496                        let trimmed_line = line.trim();
2497                        if lines.peek().is_some() {
2498                            if trimmed_line.starts_with(CODE_BLOCK_DELIMITER) {
2499                                consumed += line.len() + 1;
2500                                this.starts_with_code_block = true;
2501                                continue;
2502                            }
2503                        } else if trimmed_line.is_empty()
2504                            || prefixes(CODE_BLOCK_DELIMITER)
2505                                .any(|prefix| trimmed_line.starts_with(prefix))
2506                        {
2507                            break;
2508                        }
2509                    }
2510
2511                    let line_without_cursor = line.replace(CURSOR_SPAN, "");
2512                    if lines.peek().is_some() {
2513                        if this.line_end {
2514                            chunk.push('\n');
2515                        }
2516
2517                        chunk.push_str(&line_without_cursor);
2518                        this.line_end = true;
2519                        consumed += line.len() + 1;
2520                    } else if this.stream_done {
2521                        if !this.starts_with_code_block
2522                            || !line_without_cursor.trim().ends_with(CODE_BLOCK_DELIMITER)
2523                        {
2524                            if this.line_end {
2525                                chunk.push('\n');
2526                            }
2527
2528                            chunk.push_str(&line);
2529                        }
2530
2531                        consumed += line.len();
2532                    } else {
2533                        let trimmed_line = line.trim();
2534                        if trimmed_line.is_empty()
2535                            || prefixes(CURSOR_SPAN).any(|prefix| trimmed_line.ends_with(prefix))
2536                            || prefixes(CODE_BLOCK_DELIMITER)
2537                                .any(|prefix| trimmed_line.ends_with(prefix))
2538                        {
2539                            break;
2540                        } else {
2541                            if this.line_end {
2542                                chunk.push('\n');
2543                                this.line_end = false;
2544                            }
2545
2546                            chunk.push_str(&line_without_cursor);
2547                            consumed += line.len();
2548                        }
2549                    }
2550                }
2551            }
2552
2553            this.buffer = this.buffer.split_off(consumed);
2554            if !chunk.is_empty() {
2555                return Poll::Ready(Some(Ok(chunk)));
2556            } else if this.stream_done {
2557                return Poll::Ready(None);
2558            }
2559        }
2560    }
2561}
2562
2563fn prefixes(text: &str) -> impl Iterator<Item = &str> {
2564    (0..text.len() - 1).map(|ix| &text[..ix + 1])
2565}
2566
2567fn merge_ranges(ranges: &mut Vec<Range<Anchor>>, buffer: &MultiBufferSnapshot) {
2568    ranges.sort_unstable_by(|a, b| {
2569        a.start
2570            .cmp(&b.start, buffer)
2571            .then_with(|| b.end.cmp(&a.end, buffer))
2572    });
2573
2574    let mut ix = 0;
2575    while ix + 1 < ranges.len() {
2576        let b = ranges[ix + 1].clone();
2577        let a = &mut ranges[ix];
2578        if a.end.cmp(&b.start, buffer).is_gt() {
2579            if a.end.cmp(&b.end, buffer).is_lt() {
2580                a.end = b.end;
2581            }
2582            ranges.remove(ix + 1);
2583        } else {
2584            ix += 1;
2585        }
2586    }
2587}
2588
2589#[cfg(test)]
2590mod tests {
2591    use super::*;
2592    use futures::stream::{self};
2593    use gpui::{Context, TestAppContext};
2594    use indoc::indoc;
2595    use language::{
2596        language_settings, tree_sitter_rust, Buffer, Language, LanguageConfig, LanguageMatcher,
2597        Point,
2598    };
2599    use language_model::LanguageModelRegistry;
2600    use rand::prelude::*;
2601    use serde::Serialize;
2602    use settings::SettingsStore;
2603    use std::{future, sync::Arc};
2604
2605    #[derive(Serialize)]
2606    pub struct DummyCompletionRequest {
2607        pub name: String,
2608    }
2609
2610    #[gpui::test(iterations = 10)]
2611    async fn test_transform_autoindent(cx: &mut TestAppContext, mut rng: StdRng) {
2612        cx.set_global(cx.update(SettingsStore::test));
2613        cx.update(language_model::LanguageModelRegistry::test);
2614        cx.update(completion::LanguageModelCompletionProvider::test);
2615        cx.update(language_settings::init);
2616
2617        let text = indoc! {"
2618            fn main() {
2619                let x = 0;
2620                for _ in 0..10 {
2621                    x += 1;
2622                }
2623            }
2624        "};
2625        let buffer =
2626            cx.new_model(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
2627        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
2628        let range = buffer.read_with(cx, |buffer, cx| {
2629            let snapshot = buffer.snapshot(cx);
2630            snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(4, 5))
2631        });
2632        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, None, cx));
2633
2634        let (chunks_tx, chunks_rx) = mpsc::unbounded();
2635        codegen.update(cx, |codegen, cx| {
2636            codegen.start(
2637                String::new(),
2638                future::ready(Ok(chunks_rx.map(|chunk| Ok(chunk)).boxed())),
2639                cx,
2640            )
2641        });
2642
2643        let mut new_text = concat!(
2644            "       let mut x = 0;\n",
2645            "       while x < 10 {\n",
2646            "           x += 1;\n",
2647            "       }",
2648        );
2649        while !new_text.is_empty() {
2650            let max_len = cmp::min(new_text.len(), 10);
2651            let len = rng.gen_range(1..=max_len);
2652            let (chunk, suffix) = new_text.split_at(len);
2653            chunks_tx.unbounded_send(chunk.to_string()).unwrap();
2654            new_text = suffix;
2655            cx.background_executor.run_until_parked();
2656        }
2657        drop(chunks_tx);
2658        cx.background_executor.run_until_parked();
2659
2660        assert_eq!(
2661            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
2662            indoc! {"
2663                fn main() {
2664                    let mut x = 0;
2665                    while x < 10 {
2666                        x += 1;
2667                    }
2668                }
2669            "}
2670        );
2671    }
2672
2673    #[gpui::test(iterations = 10)]
2674    async fn test_autoindent_when_generating_past_indentation(
2675        cx: &mut TestAppContext,
2676        mut rng: StdRng,
2677    ) {
2678        cx.set_global(cx.update(SettingsStore::test));
2679        cx.update(language_settings::init);
2680
2681        let text = indoc! {"
2682            fn main() {
2683                le
2684            }
2685        "};
2686        let buffer =
2687            cx.new_model(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
2688        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
2689        let range = buffer.read_with(cx, |buffer, cx| {
2690            let snapshot = buffer.snapshot(cx);
2691            snapshot.anchor_before(Point::new(1, 6))..snapshot.anchor_after(Point::new(1, 6))
2692        });
2693        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, None, cx));
2694
2695        let (chunks_tx, chunks_rx) = mpsc::unbounded();
2696        codegen.update(cx, |codegen, cx| {
2697            codegen.start(
2698                String::new(),
2699                future::ready(Ok(chunks_rx.map(|chunk| Ok(chunk)).boxed())),
2700                cx,
2701            )
2702        });
2703
2704        cx.background_executor.run_until_parked();
2705
2706        let mut new_text = concat!(
2707            "t mut x = 0;\n",
2708            "while x < 10 {\n",
2709            "    x += 1;\n",
2710            "}", //
2711        );
2712        while !new_text.is_empty() {
2713            let max_len = cmp::min(new_text.len(), 10);
2714            let len = rng.gen_range(1..=max_len);
2715            let (chunk, suffix) = new_text.split_at(len);
2716            chunks_tx.unbounded_send(chunk.to_string()).unwrap();
2717            new_text = suffix;
2718            cx.background_executor.run_until_parked();
2719        }
2720        drop(chunks_tx);
2721        cx.background_executor.run_until_parked();
2722
2723        assert_eq!(
2724            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
2725            indoc! {"
2726                fn main() {
2727                    let mut x = 0;
2728                    while x < 10 {
2729                        x += 1;
2730                    }
2731                }
2732            "}
2733        );
2734    }
2735
2736    #[gpui::test(iterations = 10)]
2737    async fn test_autoindent_when_generating_before_indentation(
2738        cx: &mut TestAppContext,
2739        mut rng: StdRng,
2740    ) {
2741        cx.update(LanguageModelRegistry::test);
2742        cx.update(completion::LanguageModelCompletionProvider::test);
2743        cx.set_global(cx.update(SettingsStore::test));
2744        cx.update(language_settings::init);
2745
2746        let text = concat!(
2747            "fn main() {\n",
2748            "  \n",
2749            "}\n" //
2750        );
2751        let buffer =
2752            cx.new_model(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
2753        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
2754        let range = buffer.read_with(cx, |buffer, cx| {
2755            let snapshot = buffer.snapshot(cx);
2756            snapshot.anchor_before(Point::new(1, 2))..snapshot.anchor_after(Point::new(1, 2))
2757        });
2758        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, None, cx));
2759
2760        let (chunks_tx, chunks_rx) = mpsc::unbounded();
2761        codegen.update(cx, |codegen, cx| {
2762            codegen.start(
2763                String::new(),
2764                future::ready(Ok(chunks_rx.map(|chunk| Ok(chunk)).boxed())),
2765                cx,
2766            )
2767        });
2768
2769        cx.background_executor.run_until_parked();
2770
2771        let mut new_text = concat!(
2772            "let mut x = 0;\n",
2773            "while x < 10 {\n",
2774            "    x += 1;\n",
2775            "}", //
2776        );
2777        while !new_text.is_empty() {
2778            let max_len = cmp::min(new_text.len(), 10);
2779            let len = rng.gen_range(1..=max_len);
2780            let (chunk, suffix) = new_text.split_at(len);
2781            chunks_tx.unbounded_send(chunk.to_string()).unwrap();
2782            new_text = suffix;
2783            cx.background_executor.run_until_parked();
2784        }
2785        drop(chunks_tx);
2786        cx.background_executor.run_until_parked();
2787
2788        assert_eq!(
2789            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
2790            indoc! {"
2791                fn main() {
2792                    let mut x = 0;
2793                    while x < 10 {
2794                        x += 1;
2795                    }
2796                }
2797            "}
2798        );
2799    }
2800
2801    #[gpui::test(iterations = 10)]
2802    async fn test_autoindent_respects_tabs_in_selection(cx: &mut TestAppContext) {
2803        cx.update(LanguageModelRegistry::test);
2804        cx.update(completion::LanguageModelCompletionProvider::test);
2805        cx.set_global(cx.update(SettingsStore::test));
2806        cx.update(language_settings::init);
2807
2808        let text = indoc! {"
2809            func main() {
2810            \tx := 0
2811            \tfor i := 0; i < 10; i++ {
2812            \t\tx++
2813            \t}
2814            }
2815        "};
2816        let buffer = cx.new_model(|cx| Buffer::local(text, cx));
2817        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
2818        let range = buffer.read_with(cx, |buffer, cx| {
2819            let snapshot = buffer.snapshot(cx);
2820            snapshot.anchor_before(Point::new(0, 0))..snapshot.anchor_after(Point::new(4, 2))
2821        });
2822        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, None, cx));
2823
2824        let (chunks_tx, chunks_rx) = mpsc::unbounded();
2825        codegen.update(cx, |codegen, cx| {
2826            codegen.start(
2827                String::new(),
2828                future::ready(Ok(chunks_rx.map(|chunk| Ok(chunk)).boxed())),
2829                cx,
2830            )
2831        });
2832
2833        let new_text = concat!(
2834            "func main() {\n",
2835            "\tx := 0\n",
2836            "\tfor x < 10 {\n",
2837            "\t\tx++\n",
2838            "\t}", //
2839        );
2840        chunks_tx.unbounded_send(new_text.to_string()).unwrap();
2841        drop(chunks_tx);
2842        cx.background_executor.run_until_parked();
2843
2844        assert_eq!(
2845            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
2846            indoc! {"
2847                func main() {
2848                \tx := 0
2849                \tfor x < 10 {
2850                \t\tx++
2851                \t}
2852                }
2853            "}
2854        );
2855    }
2856
2857    #[gpui::test]
2858    async fn test_strip_invalid_spans_from_codeblock() {
2859        assert_chunks("Lorem ipsum dolor", "Lorem ipsum dolor").await;
2860        assert_chunks("```\nLorem ipsum dolor", "Lorem ipsum dolor").await;
2861        assert_chunks("```\nLorem ipsum dolor\n```", "Lorem ipsum dolor").await;
2862        assert_chunks(
2863            "```html\n```js\nLorem ipsum dolor\n```\n```",
2864            "```js\nLorem ipsum dolor\n```",
2865        )
2866        .await;
2867        assert_chunks("``\nLorem ipsum dolor\n```", "``\nLorem ipsum dolor\n```").await;
2868        assert_chunks("Lorem<|CURSOR|> ipsum", "Lorem ipsum").await;
2869        assert_chunks("Lorem ipsum", "Lorem ipsum").await;
2870        assert_chunks("```\n<|CURSOR|>Lorem ipsum\n```", "Lorem ipsum").await;
2871
2872        async fn assert_chunks(text: &str, expected_text: &str) {
2873            for chunk_size in 1..=text.len() {
2874                let actual_text = StripInvalidSpans::new(chunks(text, chunk_size))
2875                    .map(|chunk| chunk.unwrap())
2876                    .collect::<String>()
2877                    .await;
2878                assert_eq!(
2879                    actual_text, expected_text,
2880                    "failed to strip invalid spans, chunk size: {}",
2881                    chunk_size
2882                );
2883            }
2884        }
2885
2886        fn chunks(text: &str, size: usize) -> impl Stream<Item = Result<String>> {
2887            stream::iter(
2888                text.chars()
2889                    .collect::<Vec<_>>()
2890                    .chunks(size)
2891                    .map(|chunk| Ok(chunk.iter().collect::<String>()))
2892                    .collect::<Vec<_>>(),
2893            )
2894        }
2895    }
2896
2897    fn rust_lang() -> Language {
2898        Language::new(
2899            LanguageConfig {
2900                name: "Rust".into(),
2901                matcher: LanguageMatcher {
2902                    path_suffixes: vec!["rs".to_string()],
2903                    ..Default::default()
2904                },
2905                ..Default::default()
2906            },
2907            Some(tree_sitter_rust::language()),
2908        )
2909        .with_indents_query(
2910            r#"
2911            (call_expression) @indent
2912            (field_expression) @indent
2913            (_ "(" ")" @end) @indent
2914            (_ "{" "}" @end) @indent
2915            "#,
2916        )
2917        .unwrap()
2918    }
2919}