use crate::{    AssistantPanel, AssistantPanelEvent, CycleNextInlineAssist, CyclePreviousInlineAssist,};use anyhow::{anyhow, Context as _, Result};use assistant_context_editor::{humanize_token_count, RequestType};use assistant_settings::AssistantSettings;use client::{telemetry::Telemetry, ErrorExt};use collections::{hash_map, HashMap, HashSet, VecDeque};use editor::{    actions::{MoveDown, MoveUp, SelectAll},    display_map::{        BlockContext, BlockPlacement, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,        ToDisplayPoint,    },    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorElement, EditorEvent, EditorMode,    EditorStyle, ExcerptId, ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot,    ToOffset as _, ToPoint,};use feature_flags::{    Assistant2FeatureFlag, FeatureFlagAppExt as _, FeatureFlagViewExt as _, ZedPro,};use fs::Fs;use futures::{    channel::mpsc,    future::{BoxFuture, LocalBoxFuture},    join, SinkExt, Stream, StreamExt,};use gpui::{    anchored, deferred, point, AnyElement, App, ClickEvent, Context, CursorStyle, Entity,    EventEmitter, FocusHandle, Focusable, FontWeight, Global, HighlightStyle, Subscription, Task,    TextStyle, UpdateGlobal, WeakEntity, Window,};use language::{line_diff, Buffer, IndentKind, Point, Selection, TransactionId};use language_model::{    report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,    LanguageModelRequestMessage, LanguageModelTextStream, Role,};use language_model_selector::inline_language_model_selector;use multi_buffer::MultiBufferRow;use parking_lot::Mutex;use project::{CodeAction, ProjectTransaction};use prompt_store::PromptBuilder;use rope::Rope;use settings::{update_settings_file, Settings, SettingsStore};use smol::future::FutureExt;use std::{    cmp,    future::{self, Future},    iter, mem,    ops::{Range, RangeInclusive},    pin::Pin,    rc::Rc,    sync::Arc,    task::{self, Poll},    time::{Duration, Instant},};use streaming_diff::{CharOperation, LineDiff, LineOperation, StreamingDiff};use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};use terminal_view::terminal_panel::TerminalPanel;use text::{OffsetRangeExt, ToPoint as _};use theme::ThemeSettings;use ui::{    prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, Tooltip,};use util::{RangeExt, ResultExt};use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace}; pub fn init(    fs: Arc<dyn Fs>,    prompt_builder: Arc<PromptBuilder>,    telemetry: Arc<Telemetry>,    cx: &mut App,) {    cx.set_global(InlineAssistant::new(fs, prompt_builder, telemetry));    cx.observe_new(|_, window, cx| {        let Some(window) = window else {            return;        };        let workspace = cx.entity().clone();        InlineAssistant::update_global(cx, |inline_assistant, cx| {            inline_assistant.register_workspace(&workspace, window, cx)        });         cx.observe_flag::<Assistant2FeatureFlag, _>(window, {            |is_assistant2_enabled, _workspace, _window, cx| {                InlineAssistant::update_global(cx, |inline_assistant, _cx| {                    inline_assistant.is_assistant2_enabled = is_assistant2_enabled;                });            }        })        .detach();    })    .detach();} const PROMPT_HISTORY_MAX_LEN: usize = 20; pub struct InlineAssistant {    next_assist_id: InlineAssistId,    next_assist_group_id: InlineAssistGroupId,    assists: HashMap<InlineAssistId, InlineAssist>,    assists_by_editor: HashMap<WeakEntity<Editor>, EditorInlineAssists>,    assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,    confirmed_assists: HashMap<InlineAssistId, Entity<CodegenAlternative>>,    prompt_history: VecDeque<String>,    prompt_builder: Arc<PromptBuilder>,    telemetry: Arc<Telemetry>,    fs: Arc<dyn Fs>,    is_assistant2_enabled: bool,} impl Global for InlineAssistant {} impl InlineAssistant {    pub fn new(        fs: Arc<dyn Fs>,        prompt_builder: Arc<PromptBuilder>,        telemetry: Arc<Telemetry>,    ) -> Self {        Self {            next_assist_id: InlineAssistId::default(),            next_assist_group_id: InlineAssistGroupId::default(),            assists: HashMap::default(),            assists_by_editor: HashMap::default(),            assist_groups: HashMap::default(),            confirmed_assists: HashMap::default(),            prompt_history: VecDeque::default(),            prompt_builder,            telemetry,            fs,            is_assistant2_enabled: false,        }    }     pub fn register_workspace(        &mut self,        workspace: &Entity<Workspace>,        window: &mut Window,        cx: &mut App,    ) {        window            .subscribe(workspace, cx, |workspace, event, window, cx| {                Self::update_global(cx, |this, cx| {                    this.handle_workspace_event(workspace, event, window, cx)                });            })            .detach();         let workspace = workspace.downgrade();        cx.observe_global::<SettingsStore>(move |cx| {            let Some(workspace) = workspace.upgrade() else {                return;            };            let Some(terminal_panel) = workspace.read(cx).panel::<TerminalPanel>(cx) else {                return;            };            let enabled = AssistantSettings::get_global(cx).enabled;            terminal_panel.update(cx, |terminal_panel, cx| {                terminal_panel.set_assistant_enabled(enabled, cx)            });        })        .detach();    }     fn handle_workspace_event(        &mut self,        workspace: Entity<Workspace>,        event: &workspace::Event,        window: &mut Window,        cx: &mut App,    ) {        match event {            workspace::Event::UserSavedItem { item, .. } => {                // When the user manually saves an editor, automatically accepts all finished transformations.                if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx)) {                    if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {                        for assist_id in editor_assists.assist_ids.clone() {                            let assist = &self.assists[&assist_id];                            if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {                                self.finish_assist(assist_id, false, window, cx)                            }                        }                    }                }            }            workspace::Event::ItemAdded { item } => {                self.register_workspace_item(&workspace, item.as_ref(), window, cx);            }            _ => (),        }    }     fn register_workspace_item(        &mut self,        workspace: &Entity<Workspace>,        item: &dyn ItemHandle,        window: &mut Window,        cx: &mut App,    ) {        let is_assistant2_enabled = self.is_assistant2_enabled;         if let Some(editor) = item.act_as::<Editor>(cx) {            editor.update(cx, |editor, cx| {                if is_assistant2_enabled {                    editor.remove_code_action_provider(                        ASSISTANT_CODE_ACTION_PROVIDER_ID.into(),                        window,                        cx,                    );                } else {                    editor.add_code_action_provider(                        Rc::new(AssistantCodeActionProvider {                            editor: cx.entity().downgrade(),                            workspace: workspace.downgrade(),                        }),                        window,                        cx,                    );                }            });        }    }     pub fn assist(        &mut self,        editor: &Entity<Editor>,        workspace: Option<WeakEntity<Workspace>>,        assistant_panel: Option<&Entity<AssistantPanel>>,        initial_prompt: Option<String>,        window: &mut Window,        cx: &mut App,    ) {        let (snapshot, initial_selections) = editor.update(cx, |editor, cx| {            (                editor.buffer().read(cx).snapshot(cx),                editor.selections.all::<Point>(cx),            )        });         let mut selections = Vec::<Selection<Point>>::new();        let mut newest_selection = None;        for mut selection in initial_selections {            if selection.end > selection.start {                selection.start.column = 0;                // If the selection ends at the start of the line, we don't want to include it.                if selection.end.column == 0 {                    selection.end.row -= 1;                }                selection.end.column = snapshot.line_len(MultiBufferRow(selection.end.row));            }             if let Some(prev_selection) = selections.last_mut() {                if selection.start <= prev_selection.end {                    prev_selection.end = selection.end;                    continue;                }            }             let latest_selection = newest_selection.get_or_insert_with(|| selection.clone());            if selection.id > latest_selection.id {                *latest_selection = selection.clone();            }            selections.push(selection);        }        let newest_selection = newest_selection.unwrap();         let mut codegen_ranges = Vec::new();        for (buffer, buffer_range, excerpt_id) in            snapshot.ranges_to_buffer_ranges(selections.iter().map(|selection| {                snapshot.anchor_before(selection.start)..snapshot.anchor_after(selection.end)            }))        {            let start = buffer.anchor_before(buffer_range.start);            let end = buffer.anchor_after(buffer_range.end);             codegen_ranges.push(Anchor::range_in_buffer(                excerpt_id,                buffer.remote_id(),                start..end,            ));             if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {                self.telemetry.report_assistant_event(AssistantEvent {                    conversation_id: None,                    kind: AssistantKind::Inline,                    phase: AssistantPhase::Invoked,                    message_id: None,                    model: model.telemetry_id(),                    model_provider: model.provider_id().to_string(),                    response_latency: None,                    error_message: None,                    language_name: buffer.language().map(|language| language.name().to_proto()),                });            }        }         let assist_group_id = self.next_assist_group_id.post_inc();        let prompt_buffer = cx.new(|cx| Buffer::local(initial_prompt.unwrap_or_default(), cx));        let prompt_buffer = cx.new(|cx| MultiBuffer::singleton(prompt_buffer, cx));         let mut assists = Vec::new();        let mut assist_to_focus = None;        for range in codegen_ranges {            let assist_id = self.next_assist_id.post_inc();            let codegen = cx.new(|cx| {                Codegen::new(                    editor.read(cx).buffer().clone(),                    range.clone(),                    None,                    self.telemetry.clone(),                    self.prompt_builder.clone(),                    cx,                )            });             let gutter_dimensions = Arc::new(Mutex::new(GutterDimensions::default()));            let prompt_editor = cx.new(|cx| {                PromptEditor::new(                    assist_id,                    gutter_dimensions.clone(),                    self.prompt_history.clone(),                    prompt_buffer.clone(),                    codegen.clone(),                    editor,                    assistant_panel,                    workspace.clone(),                    self.fs.clone(),                    window,                    cx,                )            });             if assist_to_focus.is_none() {                let focus_assist = if newest_selection.reversed {                    range.start.to_point(&snapshot) == newest_selection.start                } else {                    range.end.to_point(&snapshot) == newest_selection.end                };                if focus_assist {                    assist_to_focus = Some(assist_id);                }            }             let [prompt_block_id, end_block_id] =                self.insert_assist_blocks(editor, &range, &prompt_editor, cx);             assists.push((                assist_id,                range,                prompt_editor,                prompt_block_id,                end_block_id,            ));        }         let editor_assists = self            .assists_by_editor            .entry(editor.downgrade())            .or_insert_with(|| EditorInlineAssists::new(&editor, window, cx));        let mut assist_group = InlineAssistGroup::new();        for (assist_id, range, prompt_editor, prompt_block_id, end_block_id) in assists {            self.assists.insert(                assist_id,                InlineAssist::new(                    assist_id,                    assist_group_id,                    assistant_panel.is_some(),                    editor,                    &prompt_editor,                    prompt_block_id,                    end_block_id,                    range,                    prompt_editor.read(cx).codegen.clone(),                    workspace.clone(),                    window,                    cx,                ),            );            assist_group.assist_ids.push(assist_id);            editor_assists.assist_ids.push(assist_id);        }        self.assist_groups.insert(assist_group_id, assist_group);         if let Some(assist_id) = assist_to_focus {            self.focus_assist(assist_id, window, cx);        }    }     #[allow(clippy::too_many_arguments)]    pub fn suggest_assist(        &mut self,        editor: &Entity<Editor>,        mut range: Range<Anchor>,        initial_prompt: String,        initial_transaction_id: Option<TransactionId>,        focus: bool,        workspace: Option<WeakEntity<Workspace>>,        assistant_panel: Option<&Entity<AssistantPanel>>,        window: &mut Window,        cx: &mut App,    ) -> InlineAssistId {        let assist_group_id = self.next_assist_group_id.post_inc();        let prompt_buffer = cx.new(|cx| Buffer::local(&initial_prompt, cx));        let prompt_buffer = cx.new(|cx| MultiBuffer::singleton(prompt_buffer, cx));         let assist_id = self.next_assist_id.post_inc();         let buffer = editor.read(cx).buffer().clone();        {            let snapshot = buffer.read(cx).read(cx);            range.start = range.start.bias_left(&snapshot);            range.end = range.end.bias_right(&snapshot);        }         let codegen = cx.new(|cx| {            Codegen::new(                editor.read(cx).buffer().clone(),                range.clone(),                initial_transaction_id,                self.telemetry.clone(),                self.prompt_builder.clone(),                cx,            )        });         let gutter_dimensions = Arc::new(Mutex::new(GutterDimensions::default()));        let prompt_editor = cx.new(|cx| {            PromptEditor::new(                assist_id,                gutter_dimensions.clone(),                self.prompt_history.clone(),                prompt_buffer.clone(),                codegen.clone(),                editor,                assistant_panel,                workspace.clone(),                self.fs.clone(),                window,                cx,            )        });         let [prompt_block_id, end_block_id] =            self.insert_assist_blocks(editor, &range, &prompt_editor, cx);         let editor_assists = self            .assists_by_editor            .entry(editor.downgrade())            .or_insert_with(|| EditorInlineAssists::new(&editor, window, cx));         let mut assist_group = InlineAssistGroup::new();        self.assists.insert(            assist_id,            InlineAssist::new(                assist_id,                assist_group_id,                assistant_panel.is_some(),                editor,                &prompt_editor,                prompt_block_id,                end_block_id,                range,                prompt_editor.read(cx).codegen.clone(),                workspace.clone(),                window,                cx,            ),        );        assist_group.assist_ids.push(assist_id);        editor_assists.assist_ids.push(assist_id);        self.assist_groups.insert(assist_group_id, assist_group);         if focus {            self.focus_assist(assist_id, window, cx);        }         assist_id    }     fn insert_assist_blocks(        &self,        editor: &Entity<Editor>,        range: &Range<Anchor>,        prompt_editor: &Entity<PromptEditor>,        cx: &mut App,    ) -> [CustomBlockId; 2] {        let prompt_editor_height = prompt_editor.update(cx, |prompt_editor, cx| {            prompt_editor                .editor                .update(cx, |editor, cx| editor.max_point(cx).row().0 + 1 + 2)        });        let assist_blocks = vec![            BlockProperties {                style: BlockStyle::Sticky,                placement: BlockPlacement::Above(range.start),                height: prompt_editor_height,                render: build_assist_editor_renderer(prompt_editor),                priority: 0,            },            BlockProperties {

Lines 1–500 of 4073. Load more