1mod rate_completion_modal;
2
3pub use rate_completion_modal::*;
4
5use anyhow::{anyhow, Context as _, Result};
6use client::Client;
7use collections::{HashMap, HashSet, VecDeque};
8use futures::AsyncReadExt;
9use gpui::{
10 actions, AppContext, Context, EntityId, Global, Model, ModelContext, Subscription, Task,
11};
12use http_client::{HttpClient, Method};
13use language::{
14 language_settings::all_language_settings, Anchor, Buffer, BufferSnapshot, OffsetRangeExt,
15 Point, ToOffset, ToPoint,
16};
17use language_models::LlmApiToken;
18use rpc::{PredictEditsParams, PredictEditsResponse, EXPIRED_LLM_TOKEN_HEADER_NAME};
19use std::{
20 borrow::Cow,
21 cmp,
22 fmt::Write,
23 future::Future,
24 mem,
25 ops::Range,
26 path::Path,
27 sync::Arc,
28 time::{Duration, Instant},
29};
30use telemetry_events::InlineCompletionRating;
31use util::ResultExt;
32use uuid::Uuid;
33
34const CURSOR_MARKER: &'static str = "<|user_cursor_is_here|>";
35const START_OF_FILE_MARKER: &'static str = "<|start_of_file|>";
36const EDITABLE_REGION_START_MARKER: &'static str = "<|editable_region_start|>";
37const EDITABLE_REGION_END_MARKER: &'static str = "<|editable_region_end|>";
38const BUFFER_CHANGE_GROUPING_INTERVAL: Duration = Duration::from_secs(1);
39
40actions!(zeta, [ClearHistory]);
41
42#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
43pub struct InlineCompletionId(Uuid);
44
45impl From<InlineCompletionId> for gpui::ElementId {
46 fn from(value: InlineCompletionId) -> Self {
47 gpui::ElementId::Uuid(value.0)
48 }
49}
50
51impl std::fmt::Display for InlineCompletionId {
52 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
53 write!(f, "{}", self.0)
54 }
55}
56
57impl InlineCompletionId {
58 fn new() -> Self {
59 Self(Uuid::new_v4())
60 }
61}
62
63#[derive(Clone)]
64struct ZetaGlobal(Model<Zeta>);
65
66impl Global for ZetaGlobal {}
67
68#[derive(Clone)]
69pub struct InlineCompletion {
70 id: InlineCompletionId,
71 path: Arc<Path>,
72 excerpt_range: Range<usize>,
73 edits: Arc<[(Range<Anchor>, String)]>,
74 snapshot: BufferSnapshot,
75 input_events: Arc<str>,
76 input_excerpt: Arc<str>,
77 output_excerpt: Arc<str>,
78}
79
80impl InlineCompletion {
81 fn interpolate(&self, new_snapshot: BufferSnapshot) -> Option<Vec<(Range<Anchor>, String)>> {
82 let mut edits = Vec::new();
83
84 let mut user_edits = new_snapshot
85 .edits_since::<usize>(&self.snapshot.version)
86 .peekable();
87 for (model_old_range, model_new_text) in self.edits.iter() {
88 let model_offset_range = model_old_range.to_offset(&self.snapshot);
89 while let Some(next_user_edit) = user_edits.peek() {
90 if next_user_edit.old.end < model_offset_range.start {
91 user_edits.next();
92 } else {
93 break;
94 }
95 }
96
97 if let Some(user_edit) = user_edits.peek() {
98 if user_edit.old.start > model_offset_range.end {
99 edits.push((model_old_range.clone(), model_new_text.clone()));
100 } else if user_edit.old == model_offset_range {
101 let user_new_text = new_snapshot
102 .text_for_range(user_edit.new.clone())
103 .collect::<String>();
104
105 if let Some(model_suffix) = model_new_text.strip_prefix(&user_new_text) {
106 if !model_suffix.is_empty() {
107 edits.push((
108 new_snapshot.anchor_after(user_edit.new.end)
109 ..new_snapshot.anchor_before(user_edit.new.end),
110 model_suffix.into(),
111 ));
112 }
113
114 user_edits.next();
115 } else {
116 return None;
117 }
118 } else {
119 return None;
120 }
121 } else {
122 edits.push((model_old_range.clone(), model_new_text.clone()));
123 }
124 }
125
126 Some(edits)
127 }
128}
129
130impl std::fmt::Debug for InlineCompletion {
131 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
132 f.debug_struct("InlineCompletion")
133 .field("id", &self.id)
134 .field("path", &self.path)
135 .field("edits", &self.edits)
136 .finish_non_exhaustive()
137 }
138}
139
140pub struct Zeta {
141 client: Arc<Client>,
142 events: VecDeque<Event>,
143 registered_buffers: HashMap<gpui::EntityId, RegisteredBuffer>,
144 recent_completions: VecDeque<InlineCompletion>,
145 rated_completions: HashSet<InlineCompletionId>,
146 llm_token: LlmApiToken,
147 _llm_token_subscription: Subscription,
148}
149
150impl Zeta {
151 pub fn global(cx: &mut AppContext) -> Option<Model<Self>> {
152 cx.try_global::<ZetaGlobal>().map(|global| global.0.clone())
153 }
154
155 pub fn register(client: Arc<Client>, cx: &mut AppContext) -> Model<Self> {
156 Self::global(cx).unwrap_or_else(|| {
157 let model = cx.new_model(|cx| Self::new(client, cx));
158 cx.set_global(ZetaGlobal(model.clone()));
159 model
160 })
161 }
162
163 pub fn clear_history(&mut self) {
164 self.events.clear();
165 }
166
167 fn new(client: Arc<Client>, cx: &mut ModelContext<Self>) -> Self {
168 let refresh_llm_token_listener = language_models::RefreshLlmTokenListener::global(cx);
169
170 Self {
171 client,
172 events: VecDeque::new(),
173 recent_completions: VecDeque::new(),
174 rated_completions: HashSet::default(),
175 registered_buffers: HashMap::default(),
176 llm_token: LlmApiToken::default(),
177 _llm_token_subscription: cx.subscribe(
178 &refresh_llm_token_listener,
179 |this, _listener, _event, cx| {
180 let client = this.client.clone();
181 let llm_token = this.llm_token.clone();
182 cx.spawn(|_this, _cx| async move {
183 llm_token.refresh(&client).await?;
184 anyhow::Ok(())
185 })
186 .detach_and_log_err(cx);
187 },
188 ),
189 }
190 }
191
192 fn push_event(&mut self, event: Event) {
193 if let Some(Event::BufferChange {
194 new_snapshot: last_new_snapshot,
195 timestamp: last_timestamp,
196 ..
197 }) = self.events.back_mut()
198 {
199 // Coalesce edits for the same buffer when they happen one after the other.
200 let Event::BufferChange {
201 old_snapshot,
202 new_snapshot,
203 timestamp,
204 } = &event;
205
206 if timestamp.duration_since(*last_timestamp) <= BUFFER_CHANGE_GROUPING_INTERVAL
207 && old_snapshot.remote_id() == last_new_snapshot.remote_id()
208 && old_snapshot.version == last_new_snapshot.version
209 {
210 *last_new_snapshot = new_snapshot.clone();
211 *last_timestamp = *timestamp;
212 return;
213 }
214 }
215
216 self.events.push_back(event);
217 if self.events.len() > 10 {
218 self.events.pop_front();
219 }
220 }
221
222 pub fn register_buffer(&mut self, buffer: &Model<Buffer>, cx: &mut ModelContext<Self>) {
223 let buffer_id = buffer.entity_id();
224 let weak_buffer = buffer.downgrade();
225
226 if let std::collections::hash_map::Entry::Vacant(entry) =
227 self.registered_buffers.entry(buffer_id)
228 {
229 let snapshot = buffer.read(cx).snapshot();
230
231 entry.insert(RegisteredBuffer {
232 snapshot,
233 _subscriptions: [
234 cx.subscribe(buffer, move |this, buffer, event, cx| {
235 this.handle_buffer_event(buffer, event, cx);
236 }),
237 cx.observe_release(buffer, move |this, _buffer, _cx| {
238 this.registered_buffers.remove(&weak_buffer.entity_id());
239 }),
240 ],
241 });
242 };
243 }
244
245 fn handle_buffer_event(
246 &mut self,
247 buffer: Model<Buffer>,
248 event: &language::BufferEvent,
249 cx: &mut ModelContext<Self>,
250 ) {
251 match event {
252 language::BufferEvent::Edited => {
253 self.report_changes_for_buffer(&buffer, cx);
254 }
255 _ => {}
256 }
257 }
258
259 pub fn request_completion_impl<F, R>(
260 &mut self,
261 buffer: &Model<Buffer>,
262 position: language::Anchor,
263 cx: &mut ModelContext<Self>,
264 perform_predict_edits: F,
265 ) -> Task<Result<InlineCompletion>>
266 where
267 F: FnOnce(Arc<Client>, LlmApiToken, PredictEditsParams) -> R + 'static,
268 R: Future<Output = Result<PredictEditsResponse>> + Send + 'static,
269 {
270 let snapshot = self.report_changes_for_buffer(buffer, cx);
271 let point = position.to_point(&snapshot);
272 let offset = point.to_offset(&snapshot);
273 let excerpt_range = excerpt_range_for_position(point, &snapshot);
274 let events = self.events.clone();
275 let path = snapshot
276 .file()
277 .map(|f| f.path().clone())
278 .unwrap_or_else(|| Arc::from(Path::new("untitled")));
279
280 let client = self.client.clone();
281 let llm_token = self.llm_token.clone();
282
283 cx.spawn(|this, mut cx| async move {
284 let start = std::time::Instant::now();
285
286 let mut input_events = String::new();
287 for event in events {
288 if !input_events.is_empty() {
289 input_events.push('\n');
290 input_events.push('\n');
291 }
292 input_events.push_str(&event.to_prompt());
293 }
294 let input_excerpt = prompt_for_excerpt(&snapshot, &excerpt_range, offset);
295
296 log::debug!("Events:\n{}\nExcerpt:\n{}", input_events, input_excerpt);
297
298 let body = PredictEditsParams {
299 input_events: input_events.clone(),
300 input_excerpt: input_excerpt.clone(),
301 };
302
303 let response = perform_predict_edits(client, llm_token, body).await?;
304
305 let output_excerpt = response.output_excerpt;
306 log::debug!("prediction took: {:?}", start.elapsed());
307 log::debug!("completion response: {}", output_excerpt);
308
309 let inline_completion = Self::process_completion_response(
310 output_excerpt,
311 &snapshot,
312 excerpt_range,
313 path,
314 input_events,
315 input_excerpt,
316 )?;
317
318 this.update(&mut cx, |this, cx| {
319 this.recent_completions
320 .push_front(inline_completion.clone());
321 if this.recent_completions.len() > 50 {
322 this.recent_completions.pop_back();
323 }
324 cx.notify();
325 })?;
326
327 Ok(inline_completion)
328 })
329 }
330
331 // Generates several example completions of various states to fill the Zeta completion modal
332 #[cfg(any(test, feature = "test-support"))]
333 pub fn fill_with_fake_completions(&mut self, cx: &mut ModelContext<Self>) -> Task<()> {
334 let test_buffer_text = indoc::indoc! {r#"a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
335 And maybe a short line
336
337 Then a few lines
338
339 and then another
340 "#};
341
342 let buffer = cx.new_model(|cx| Buffer::local(test_buffer_text, cx));
343 let position = buffer.read(cx).anchor_before(Point::new(1, 0));
344
345 let completion_tasks = vec![
346 self.fake_completion(
347 &buffer,
348 position,
349 PredictEditsResponse {
350 output_excerpt: format!("{EDITABLE_REGION_START_MARKER}
351a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
352[here's an edit]
353And maybe a short line
354Then a few lines
355and then another
356{EDITABLE_REGION_END_MARKER}
357 ", ),
358 },
359 cx,
360 ),
361 self.fake_completion(
362 &buffer,
363 position,
364 PredictEditsResponse {
365 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
366a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
367And maybe a short line
368[and another edit]
369Then a few lines
370and then another
371{EDITABLE_REGION_END_MARKER}
372 "#),
373 },
374 cx,
375 ),
376 self.fake_completion(
377 &buffer,
378 position,
379 PredictEditsResponse {
380 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
381a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
382And maybe a short line
383
384Then a few lines
385
386and then another
387{EDITABLE_REGION_END_MARKER}
388 "#),
389 },
390 cx,
391 ),
392 self.fake_completion(
393 &buffer,
394 position,
395 PredictEditsResponse {
396 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
397a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
398And maybe a short line
399
400Then a few lines
401
402and then another
403{EDITABLE_REGION_END_MARKER}
404 "#),
405 },
406 cx,
407 ),
408 self.fake_completion(
409 &buffer,
410 position,
411 PredictEditsResponse {
412 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
413a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
414And maybe a short line
415Then a few lines
416[a third completion]
417and then another
418{EDITABLE_REGION_END_MARKER}
419 "#),
420 },
421 cx,
422 ),
423 self.fake_completion(
424 &buffer,
425 position,
426 PredictEditsResponse {
427 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
428a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
429And maybe a short line
430and then another
431[fourth completion example]
432{EDITABLE_REGION_END_MARKER}
433 "#),
434 },
435 cx,
436 ),
437 self.fake_completion(
438 &buffer,
439 position,
440 PredictEditsResponse {
441 output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
442a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
443And maybe a short line
444Then a few lines
445and then another
446[fifth and final completion]
447{EDITABLE_REGION_END_MARKER}
448 "#),
449 },
450 cx,
451 ),
452 ];
453
454 cx.spawn(|zeta, mut cx| async move {
455 for task in completion_tasks {
456 task.await.unwrap();
457 }
458
459 zeta.update(&mut cx, |zeta, _cx| {
460 zeta.recent_completions.get_mut(2).unwrap().edits = Arc::new([]);
461 zeta.recent_completions.get_mut(3).unwrap().edits = Arc::new([]);
462 })
463 .ok();
464 })
465 }
466
467 #[cfg(any(test, feature = "test-support"))]
468 pub fn fake_completion(
469 &mut self,
470 buffer: &Model<Buffer>,
471 position: language::Anchor,
472 response: PredictEditsResponse,
473 cx: &mut ModelContext<Self>,
474 ) -> Task<Result<InlineCompletion>> {
475 use std::future::ready;
476
477 self.request_completion_impl(buffer, position, cx, |_, _, _| ready(Ok(response)))
478 }
479
480 pub fn request_completion(
481 &mut self,
482 buffer: &Model<Buffer>,
483 position: language::Anchor,
484 cx: &mut ModelContext<Self>,
485 ) -> Task<Result<InlineCompletion>> {
486 self.request_completion_impl(buffer, position, cx, Self::perform_predict_edits)
487 }
488
489 fn perform_predict_edits(
490 client: Arc<Client>,
491 llm_token: LlmApiToken,
492 body: PredictEditsParams,
493 ) -> impl Future<Output = Result<PredictEditsResponse>> {
494 async move {
495 let http_client = client.http_client();
496 let mut token = llm_token.acquire(&client).await?;
497 let mut did_retry = false;
498
499 loop {
500 let request_builder = http_client::Request::builder();
501 let request = request_builder
502 .method(Method::POST)
503 .uri(
504 http_client
505 .build_zed_llm_url("/predict_edits", &[])?
506 .as_ref(),
507 )
508 .header("Content-Type", "application/json")
509 .header("Authorization", format!("Bearer {}", token))
510 .body(serde_json::to_string(&body)?.into())?;
511
512 let mut response = http_client.send(request).await?;
513
514 if response.status().is_success() {
515 let mut body = String::new();
516 response.body_mut().read_to_string(&mut body).await?;
517 return Ok(serde_json::from_str(&body)?);
518 } else if !did_retry
519 && response
520 .headers()
521 .get(EXPIRED_LLM_TOKEN_HEADER_NAME)
522 .is_some()
523 {
524 did_retry = true;
525 token = llm_token.refresh(&client).await?;
526 } else {
527 let mut body = String::new();
528 response.body_mut().read_to_string(&mut body).await?;
529 return Err(anyhow!(
530 "error predicting edits.\nStatus: {:?}\nBody: {}",
531 response.status(),
532 body
533 ));
534 }
535 }
536 }
537 }
538
539 fn process_completion_response(
540 output_excerpt: String,
541 snapshot: &BufferSnapshot,
542 excerpt_range: Range<usize>,
543 path: Arc<Path>,
544 input_events: String,
545 input_excerpt: String,
546 ) -> Result<InlineCompletion> {
547 let content = output_excerpt.replace(CURSOR_MARKER, "");
548
549 let codefence_start = content
550 .find(EDITABLE_REGION_START_MARKER)
551 .context("could not find start marker")?;
552 let content = &content[codefence_start..];
553
554 let newline_ix = content.find('\n').context("could not find newline")?;
555 let content = &content[newline_ix + 1..];
556
557 let codefence_end = content
558 .rfind(&format!("\n{EDITABLE_REGION_END_MARKER}"))
559 .context("could not find end marker")?;
560 let new_text = &content[..codefence_end];
561
562 let old_text = snapshot
563 .text_for_range(excerpt_range.clone())
564 .collect::<String>();
565
566 let edits = Self::compute_edits(old_text, new_text, excerpt_range.start, snapshot);
567
568 Ok(InlineCompletion {
569 id: InlineCompletionId::new(),
570 path,
571 excerpt_range,
572 edits: edits.into(),
573 snapshot: snapshot.clone(),
574 input_events: input_events.into(),
575 input_excerpt: input_excerpt.into(),
576 output_excerpt: output_excerpt.into(),
577 })
578 }
579
580 pub fn compute_edits(
581 old_text: String,
582 new_text: &str,
583 offset: usize,
584 snapshot: &BufferSnapshot,
585 ) -> Vec<(Range<Anchor>, String)> {
586 let diff = similar::TextDiff::from_words(old_text.as_str(), new_text);
587
588 let mut edits: Vec<(Range<usize>, String)> = Vec::new();
589 let mut old_start = offset;
590 for change in diff.iter_all_changes() {
591 let value = change.value();
592 match change.tag() {
593 similar::ChangeTag::Equal => {
594 old_start += value.len();
595 }
596 similar::ChangeTag::Delete => {
597 let old_end = old_start + value.len();
598 if let Some((last_old_range, _)) = edits.last_mut() {
599 if last_old_range.end == old_start {
600 last_old_range.end = old_end;
601 } else {
602 edits.push((old_start..old_end, String::new()));
603 }
604 } else {
605 edits.push((old_start..old_end, String::new()));
606 }
607 old_start = old_end;
608 }
609 similar::ChangeTag::Insert => {
610 if let Some((last_old_range, last_new_text)) = edits.last_mut() {
611 if last_old_range.end == old_start {
612 last_new_text.push_str(value);
613 } else {
614 edits.push((old_start..old_start, value.into()));
615 }
616 } else {
617 edits.push((old_start..old_start, value.into()));
618 }
619 }
620 }
621 }
622
623 edits
624 .into_iter()
625 .map(|(mut old_range, new_text)| {
626 let prefix_len = common_prefix(
627 snapshot.chars_for_range(old_range.clone()),
628 new_text.chars(),
629 );
630 old_range.start += prefix_len;
631 let suffix_len = common_prefix(
632 snapshot.reversed_chars_for_range(old_range.clone()),
633 new_text[prefix_len..].chars().rev(),
634 );
635 old_range.end = old_range.end.saturating_sub(suffix_len);
636
637 let new_text = new_text[prefix_len..new_text.len() - suffix_len].to_string();
638 (
639 snapshot.anchor_after(old_range.start)..snapshot.anchor_before(old_range.end),
640 new_text,
641 )
642 })
643 .collect()
644 }
645
646 pub fn is_completion_rated(&self, completion_id: InlineCompletionId) -> bool {
647 self.rated_completions.contains(&completion_id)
648 }
649
650 pub fn rate_completion(
651 &mut self,
652 completion: &InlineCompletion,
653 rating: InlineCompletionRating,
654 feedback: String,
655 cx: &mut ModelContext<Self>,
656 ) {
657 self.rated_completions.insert(completion.id);
658 self.client
659 .telemetry()
660 .report_inline_completion_rating_event(
661 rating,
662 completion.input_events.clone(),
663 completion.input_excerpt.clone(),
664 completion.output_excerpt.clone(),
665 feedback,
666 );
667 self.client.telemetry().flush_events();
668 cx.notify();
669 }
670
671 pub fn recent_completions(&self) -> impl DoubleEndedIterator<Item = &InlineCompletion> {
672 self.recent_completions.iter()
673 }
674
675 pub fn recent_completions_len(&self) -> usize {
676 self.recent_completions.len()
677 }
678
679 fn report_changes_for_buffer(
680 &mut self,
681 buffer: &Model<Buffer>,
682 cx: &mut ModelContext<Self>,
683 ) -> BufferSnapshot {
684 self.register_buffer(buffer, cx);
685
686 let registered_buffer = self
687 .registered_buffers
688 .get_mut(&buffer.entity_id())
689 .unwrap();
690 let new_snapshot = buffer.read(cx).snapshot();
691
692 if new_snapshot.version != registered_buffer.snapshot.version {
693 let old_snapshot = mem::replace(&mut registered_buffer.snapshot, new_snapshot.clone());
694 self.push_event(Event::BufferChange {
695 old_snapshot,
696 new_snapshot: new_snapshot.clone(),
697 timestamp: Instant::now(),
698 });
699 }
700
701 new_snapshot
702 }
703}
704
705fn common_prefix<T1: Iterator<Item = char>, T2: Iterator<Item = char>>(a: T1, b: T2) -> usize {
706 a.zip(b)
707 .take_while(|(a, b)| a == b)
708 .map(|(a, _)| a.len_utf8())
709 .sum()
710}
711
712fn prompt_for_excerpt(
713 snapshot: &BufferSnapshot,
714 excerpt_range: &Range<usize>,
715 offset: usize,
716) -> String {
717 let mut prompt_excerpt = String::new();
718 writeln!(
719 prompt_excerpt,
720 "```{}",
721 snapshot
722 .file()
723 .map_or(Cow::Borrowed("untitled"), |file| file
724 .path()
725 .to_string_lossy())
726 )
727 .unwrap();
728
729 if excerpt_range.start == 0 {
730 writeln!(prompt_excerpt, "{START_OF_FILE_MARKER}").unwrap();
731 }
732
733 let point_range = excerpt_range.to_point(snapshot);
734 if point_range.start.row > 0 && !snapshot.is_line_blank(point_range.start.row - 1) {
735 let extra_context_line_range = Point::new(point_range.start.row - 1, 0)..point_range.start;
736 for chunk in snapshot.text_for_range(extra_context_line_range) {
737 prompt_excerpt.push_str(chunk);
738 }
739 }
740 writeln!(prompt_excerpt, "{EDITABLE_REGION_START_MARKER}").unwrap();
741 for chunk in snapshot.text_for_range(excerpt_range.start..offset) {
742 prompt_excerpt.push_str(chunk);
743 }
744 prompt_excerpt.push_str(CURSOR_MARKER);
745 for chunk in snapshot.text_for_range(offset..excerpt_range.end) {
746 prompt_excerpt.push_str(chunk);
747 }
748 write!(prompt_excerpt, "\n{EDITABLE_REGION_END_MARKER}").unwrap();
749
750 if point_range.end.row < snapshot.max_point().row
751 && !snapshot.is_line_blank(point_range.end.row + 1)
752 {
753 let extra_context_line_range = point_range.end
754 ..Point::new(
755 point_range.end.row + 1,
756 snapshot.line_len(point_range.end.row + 1),
757 );
758 for chunk in snapshot.text_for_range(extra_context_line_range) {
759 prompt_excerpt.push_str(chunk);
760 }
761 }
762
763 write!(prompt_excerpt, "\n```").unwrap();
764 prompt_excerpt
765}
766
767fn excerpt_range_for_position(point: Point, snapshot: &BufferSnapshot) -> Range<usize> {
768 const CONTEXT_LINES: u32 = 16;
769
770 let mut context_lines_before = CONTEXT_LINES;
771 let mut context_lines_after = CONTEXT_LINES;
772 if point.row < CONTEXT_LINES {
773 context_lines_after += CONTEXT_LINES - point.row;
774 } else if point.row + CONTEXT_LINES > snapshot.max_point().row {
775 context_lines_before += (point.row + CONTEXT_LINES) - snapshot.max_point().row;
776 }
777
778 let excerpt_start_row = point.row.saturating_sub(context_lines_before);
779 let excerpt_start = Point::new(excerpt_start_row, 0);
780 let excerpt_end_row = cmp::min(point.row + context_lines_after, snapshot.max_point().row);
781 let excerpt_end = Point::new(excerpt_end_row, snapshot.line_len(excerpt_end_row));
782 excerpt_start.to_offset(snapshot)..excerpt_end.to_offset(snapshot)
783}
784
785struct RegisteredBuffer {
786 snapshot: BufferSnapshot,
787 _subscriptions: [gpui::Subscription; 2],
788}
789
790#[derive(Clone)]
791enum Event {
792 BufferChange {
793 old_snapshot: BufferSnapshot,
794 new_snapshot: BufferSnapshot,
795 timestamp: Instant,
796 },
797}
798
799impl Event {
800 fn to_prompt(&self) -> String {
801 match self {
802 Event::BufferChange {
803 old_snapshot,
804 new_snapshot,
805 ..
806 } => {
807 let mut prompt = String::new();
808
809 let old_path = old_snapshot
810 .file()
811 .map(|f| f.path().as_ref())
812 .unwrap_or(Path::new("untitled"));
813 let new_path = new_snapshot
814 .file()
815 .map(|f| f.path().as_ref())
816 .unwrap_or(Path::new("untitled"));
817 if old_path != new_path {
818 writeln!(prompt, "User renamed {:?} to {:?}\n", old_path, new_path).unwrap();
819 }
820
821 let diff =
822 similar::TextDiff::from_lines(&old_snapshot.text(), &new_snapshot.text())
823 .unified_diff()
824 .to_string();
825 if !diff.is_empty() {
826 write!(
827 prompt,
828 "User edited {:?}:\n```diff\n{}\n```",
829 new_path, diff
830 )
831 .unwrap();
832 }
833
834 prompt
835 }
836 }
837 }
838}
839
840struct CurrentInlineCompletion {
841 buffer_id: EntityId,
842 completion: InlineCompletion,
843}
844
845pub struct ZetaInlineCompletionProvider {
846 zeta: Model<Zeta>,
847 current_completion: Option<CurrentInlineCompletion>,
848 pending_refresh: Task<()>,
849}
850
851impl ZetaInlineCompletionProvider {
852 pub const DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75);
853
854 pub fn new(zeta: Model<Zeta>) -> Self {
855 Self {
856 zeta,
857 current_completion: None,
858 pending_refresh: Task::ready(()),
859 }
860 }
861}
862
863impl inline_completion::InlineCompletionProvider for ZetaInlineCompletionProvider {
864 fn name() -> &'static str {
865 "Zeta"
866 }
867
868 fn is_enabled(
869 &self,
870 buffer: &Model<Buffer>,
871 cursor_position: language::Anchor,
872 cx: &AppContext,
873 ) -> bool {
874 let buffer = buffer.read(cx);
875 let file = buffer.file();
876 let language = buffer.language_at(cursor_position);
877 let settings = all_language_settings(file, cx);
878 settings.inline_completions_enabled(language.as_ref(), file.map(|f| f.path().as_ref()), cx)
879 }
880
881 fn refresh(
882 &mut self,
883 buffer: Model<Buffer>,
884 position: language::Anchor,
885 debounce: bool,
886 cx: &mut ModelContext<Self>,
887 ) {
888 self.pending_refresh =
889 cx.spawn(|this, mut cx| async move {
890 if debounce {
891 cx.background_executor().timer(Self::DEBOUNCE_TIMEOUT).await;
892 }
893
894 let completion_request = this.update(&mut cx, |this, cx| {
895 this.zeta.update(cx, |zeta, cx| {
896 zeta.request_completion(&buffer, position, cx)
897 })
898 });
899
900 let mut completion = None;
901 if let Ok(completion_request) = completion_request {
902 completion = completion_request.await.log_err().map(|completion| {
903 CurrentInlineCompletion {
904 buffer_id: buffer.entity_id(),
905 completion,
906 }
907 });
908 }
909
910 this.update(&mut cx, |this, cx| {
911 this.current_completion = completion;
912 cx.notify();
913 })
914 .ok();
915 });
916 }
917
918 fn cycle(
919 &mut self,
920 _buffer: Model<Buffer>,
921 _cursor_position: language::Anchor,
922 _direction: inline_completion::Direction,
923 _cx: &mut ModelContext<Self>,
924 ) {
925 // Right now we don't support cycling.
926 }
927
928 fn accept(&mut self, _cx: &mut ModelContext<Self>) {}
929
930 fn discard(&mut self, _cx: &mut ModelContext<Self>) {
931 self.current_completion.take();
932 }
933
934 fn suggest(
935 &mut self,
936 buffer: &Model<Buffer>,
937 cursor_position: language::Anchor,
938 cx: &mut ModelContext<Self>,
939 ) -> Option<inline_completion::InlineCompletion> {
940 let CurrentInlineCompletion {
941 buffer_id,
942 completion,
943 } = self.current_completion.as_mut()?;
944
945 // Invalidate previous completion if it was generated for a different buffer.
946 if *buffer_id != buffer.entity_id() {
947 self.current_completion.take();
948 return None;
949 }
950
951 let buffer = buffer.read(cx);
952 let Some(edits) = completion.interpolate(buffer.snapshot()) else {
953 self.current_completion.take();
954 return None;
955 };
956
957 let cursor_row = cursor_position.to_point(buffer).row;
958 let (closest_edit_ix, (closest_edit_range, _)) =
959 edits.iter().enumerate().min_by_key(|(_, (range, _))| {
960 let distance_from_start = cursor_row.abs_diff(range.start.to_point(buffer).row);
961 let distance_from_end = cursor_row.abs_diff(range.end.to_point(buffer).row);
962 cmp::min(distance_from_start, distance_from_end)
963 })?;
964
965 let mut edit_start_ix = closest_edit_ix;
966 for (range, _) in edits[..edit_start_ix].iter().rev() {
967 let distance_from_closest_edit =
968 closest_edit_range.start.to_point(buffer).row - range.end.to_point(buffer).row;
969 if distance_from_closest_edit <= 1 {
970 edit_start_ix -= 1;
971 } else {
972 break;
973 }
974 }
975
976 let mut edit_end_ix = closest_edit_ix + 1;
977 for (range, _) in &edits[edit_end_ix..] {
978 let distance_from_closest_edit =
979 range.start.to_point(buffer).row - closest_edit_range.end.to_point(buffer).row;
980 if distance_from_closest_edit <= 1 {
981 edit_end_ix += 1;
982 } else {
983 break;
984 }
985 }
986
987 Some(inline_completion::InlineCompletion {
988 edits: edits[edit_start_ix..edit_end_ix].to_vec(),
989 })
990 }
991}
992
993#[cfg(test)]
994mod tests {
995 use client::test::FakeServer;
996 use clock::FakeSystemClock;
997 use gpui::TestAppContext;
998 use http_client::FakeHttpClient;
999 use indoc::indoc;
1000 use language_models::RefreshLlmTokenListener;
1001 use rpc::proto;
1002 use settings::SettingsStore;
1003
1004 use super::*;
1005
1006 #[gpui::test]
1007 fn test_inline_completion_basic_interpolation(cx: &mut AppContext) {
1008 let buffer = cx.new_model(|cx| Buffer::local("Lorem ipsum dolor", cx));
1009 let completion = InlineCompletion {
1010 edits: to_completion_edits(
1011 [(2..5, "REM".to_string()), (9..11, "".to_string())],
1012 &buffer,
1013 cx,
1014 )
1015 .into(),
1016 path: Path::new("").into(),
1017 snapshot: buffer.read(cx).snapshot(),
1018 id: InlineCompletionId::new(),
1019 excerpt_range: 0..0,
1020 input_events: "".into(),
1021 input_excerpt: "".into(),
1022 output_excerpt: "".into(),
1023 };
1024
1025 assert_eq!(
1026 from_completion_edits(
1027 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1028 &buffer,
1029 cx
1030 ),
1031 vec![(2..5, "REM".to_string()), (9..11, "".to_string())]
1032 );
1033
1034 buffer.update(cx, |buffer, cx| buffer.edit([(2..5, "")], None, cx));
1035 assert_eq!(
1036 from_completion_edits(
1037 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1038 &buffer,
1039 cx
1040 ),
1041 vec![(2..2, "REM".to_string()), (6..8, "".to_string())]
1042 );
1043
1044 buffer.update(cx, |buffer, cx| buffer.undo(cx));
1045 assert_eq!(
1046 from_completion_edits(
1047 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1048 &buffer,
1049 cx
1050 ),
1051 vec![(2..5, "REM".to_string()), (9..11, "".to_string())]
1052 );
1053
1054 buffer.update(cx, |buffer, cx| buffer.edit([(2..5, "R")], None, cx));
1055 assert_eq!(
1056 from_completion_edits(
1057 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1058 &buffer,
1059 cx
1060 ),
1061 vec![(3..3, "EM".to_string()), (7..9, "".to_string())]
1062 );
1063
1064 buffer.update(cx, |buffer, cx| buffer.edit([(3..3, "E")], None, cx));
1065 assert_eq!(
1066 from_completion_edits(
1067 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1068 &buffer,
1069 cx
1070 ),
1071 vec![(4..4, "M".to_string()), (8..10, "".to_string())]
1072 );
1073
1074 buffer.update(cx, |buffer, cx| buffer.edit([(4..4, "M")], None, cx));
1075 assert_eq!(
1076 from_completion_edits(
1077 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1078 &buffer,
1079 cx
1080 ),
1081 vec![(9..11, "".to_string())]
1082 );
1083
1084 buffer.update(cx, |buffer, cx| buffer.edit([(4..5, "")], None, cx));
1085 assert_eq!(
1086 from_completion_edits(
1087 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1088 &buffer,
1089 cx
1090 ),
1091 vec![(4..4, "M".to_string()), (8..10, "".to_string())]
1092 );
1093
1094 buffer.update(cx, |buffer, cx| buffer.edit([(8..10, "")], None, cx));
1095 assert_eq!(
1096 from_completion_edits(
1097 &completion.interpolate(buffer.read(cx).snapshot()).unwrap(),
1098 &buffer,
1099 cx
1100 ),
1101 vec![(4..4, "M".to_string())]
1102 );
1103
1104 buffer.update(cx, |buffer, cx| buffer.edit([(4..6, "")], None, cx));
1105 assert_eq!(completion.interpolate(buffer.read(cx).snapshot()), None);
1106 }
1107
1108 #[gpui::test]
1109 async fn test_inline_completion_end_of_buffer(cx: &mut TestAppContext) {
1110 cx.update(|cx| {
1111 let settings_store = SettingsStore::test(cx);
1112 cx.set_global(settings_store);
1113 client::init_settings(cx);
1114 });
1115
1116 let buffer_content = "lorem\n";
1117 let completion_response = indoc! {"
1118 ```animals.js
1119 <|start_of_file|>
1120 <|editable_region_start|>
1121 lorem
1122 ipsum
1123 <|editable_region_end|>
1124 ```"};
1125
1126 let http_client = FakeHttpClient::create(move |_| async move {
1127 Ok(http_client::Response::builder()
1128 .status(200)
1129 .body(
1130 serde_json::to_string(&PredictEditsResponse {
1131 output_excerpt: completion_response.to_string(),
1132 })
1133 .unwrap()
1134 .into(),
1135 )
1136 .unwrap())
1137 });
1138
1139 let client = cx.update(|cx| Client::new(Arc::new(FakeSystemClock::new()), http_client, cx));
1140 cx.update(|cx| {
1141 RefreshLlmTokenListener::register(client.clone(), cx);
1142 });
1143 let server = FakeServer::for_client(42, &client, cx).await;
1144
1145 let zeta = cx.new_model(|cx| Zeta::new(client, cx));
1146 let buffer = cx.new_model(|cx| Buffer::local(buffer_content, cx));
1147 let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
1148 let completion_task =
1149 zeta.update(cx, |zeta, cx| zeta.request_completion(&buffer, cursor, cx));
1150
1151 let token_request = server.receive::<proto::GetLlmToken>().await.unwrap();
1152 server.respond(
1153 token_request.receipt(),
1154 proto::GetLlmTokenResponse { token: "".into() },
1155 );
1156
1157 let completion = completion_task.await.unwrap();
1158 buffer.update(cx, |buffer, cx| {
1159 buffer.edit(completion.edits.iter().cloned(), None, cx)
1160 });
1161 assert_eq!(
1162 buffer.read_with(cx, |buffer, _| buffer.text()),
1163 "lorem\nipsum"
1164 );
1165 }
1166
1167 fn to_completion_edits(
1168 iterator: impl IntoIterator<Item = (Range<usize>, String)>,
1169 buffer: &Model<Buffer>,
1170 cx: &AppContext,
1171 ) -> Vec<(Range<Anchor>, String)> {
1172 let buffer = buffer.read(cx);
1173 iterator
1174 .into_iter()
1175 .map(|(range, text)| {
1176 (
1177 buffer.anchor_after(range.start)..buffer.anchor_before(range.end),
1178 text,
1179 )
1180 })
1181 .collect()
1182 }
1183
1184 fn from_completion_edits(
1185 editor_edits: &[(Range<Anchor>, String)],
1186 buffer: &Model<Buffer>,
1187 cx: &AppContext,
1188 ) -> Vec<(Range<usize>, String)> {
1189 let buffer = buffer.read(cx);
1190 editor_edits
1191 .iter()
1192 .map(|(range, text)| {
1193 (
1194 range.start.to_offset(buffer)..range.end.to_offset(buffer),
1195 text.clone(),
1196 )
1197 })
1198 .collect()
1199 }
1200
1201 #[ctor::ctor]
1202 fn init_logger() {
1203 if std::env::var("RUST_LOG").is_ok() {
1204 env_logger::init();
1205 }
1206 }
1207}