Add experimental LSP-based context retrieval system for edit prediction (#44036)
To do * [x] Default to no context retrieval. Allow opting in to LSP-based retrieval via a setting (for users in `zeta2` feature flag) * [x] Feed this context to models when enabled * [x] Make the zeta2 context view work well with LSP retrieval * [x] Add a UI for the setting (for feature-flagged users) * [x] Ensure Zeta CLI `context` command is usable --- * [ ] Filter out LSP definitions that are too large / entire files (e.g. modules) * [ ] Introduce timeouts * [ ] Test with other LSPs * [ ] Figure out hangs Release Notes: - N/A --------- Co-authored-by: Ben Kunkle <ben@zed.dev> Co-authored-by: Agus Zubiaga <agus@zed.dev>
This commit is contained in:
co-authored by
Ben Kunkle
Agus Zubiaga
parent
cd8679e81a
commit
76167109db
@@ -30,6 +30,7 @@ credentials_provider.workspace = true
|
||||
db.workspace = true
|
||||
edit_prediction.workspace = true
|
||||
edit_prediction_context.workspace = true
|
||||
edit_prediction_context2.workspace = true
|
||||
editor.workspace = true
|
||||
feature_flags.workspace = true
|
||||
fs.workspace = true
|
||||
|
||||
@@ -1,173 +0,0 @@
|
||||
use cloud_llm_client::predict_edits_v3::Excerpt;
|
||||
use edit_prediction_context::Line;
|
||||
use language::{BufferSnapshot, Point};
|
||||
use std::ops::Range;
|
||||
|
||||
pub fn assemble_excerpts(
|
||||
buffer: &BufferSnapshot,
|
||||
merged_line_ranges: impl IntoIterator<Item = Range<Line>>,
|
||||
) -> Vec<Excerpt> {
|
||||
let mut output = Vec::new();
|
||||
|
||||
let outline_items = buffer.outline_items_as_points_containing(0..buffer.len(), false, None);
|
||||
let mut outline_items = outline_items.into_iter().peekable();
|
||||
|
||||
for range in merged_line_ranges {
|
||||
let point_range = Point::new(range.start.0, 0)..Point::new(range.end.0, 0);
|
||||
|
||||
while let Some(outline_item) = outline_items.peek() {
|
||||
if outline_item.range.start >= point_range.start {
|
||||
break;
|
||||
}
|
||||
if outline_item.range.end > point_range.start {
|
||||
let mut point_range = outline_item.source_range_for_text.clone();
|
||||
point_range.start.column = 0;
|
||||
point_range.end.column = buffer.line_len(point_range.end.row);
|
||||
|
||||
output.push(Excerpt {
|
||||
start_line: Line(point_range.start.row),
|
||||
text: buffer
|
||||
.text_for_range(point_range.clone())
|
||||
.collect::<String>()
|
||||
.into(),
|
||||
})
|
||||
}
|
||||
outline_items.next();
|
||||
}
|
||||
|
||||
output.push(Excerpt {
|
||||
start_line: Line(point_range.start.row),
|
||||
text: buffer
|
||||
.text_for_range(point_range.clone())
|
||||
.collect::<String>()
|
||||
.into(),
|
||||
})
|
||||
}
|
||||
|
||||
output
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::Arc;
|
||||
|
||||
use super::*;
|
||||
use cloud_llm_client::predict_edits_v3;
|
||||
use gpui::{TestAppContext, prelude::*};
|
||||
use indoc::indoc;
|
||||
use language::{Buffer, Language, LanguageConfig, LanguageMatcher, OffsetRangeExt};
|
||||
use pretty_assertions::assert_eq;
|
||||
use util::test::marked_text_ranges;
|
||||
|
||||
#[gpui::test]
|
||||
fn test_rust(cx: &mut TestAppContext) {
|
||||
let table = [
|
||||
(
|
||||
indoc! {r#"
|
||||
struct User {
|
||||
first_name: String,
|
||||
« last_name: String,
|
||||
ageˇ: u32,
|
||||
» email: String,
|
||||
create_at: Instant,
|
||||
}
|
||||
|
||||
impl User {
|
||||
pub fn first_name(&self) -> String {
|
||||
self.first_name.clone()
|
||||
}
|
||||
|
||||
pub fn full_name(&self) -> String {
|
||||
« format!("{} {}", self.first_name, self.last_name)
|
||||
» }
|
||||
}
|
||||
"#},
|
||||
indoc! {r#"
|
||||
1|struct User {
|
||||
…
|
||||
3| last_name: String,
|
||||
4| age<|cursor|>: u32,
|
||||
…
|
||||
9|impl User {
|
||||
…
|
||||
14| pub fn full_name(&self) -> String {
|
||||
15| format!("{} {}", self.first_name, self.last_name)
|
||||
…
|
||||
"#},
|
||||
),
|
||||
(
|
||||
indoc! {r#"
|
||||
struct User {
|
||||
first_name: String,
|
||||
« last_name: String,
|
||||
age: u32,
|
||||
}
|
||||
»"#
|
||||
},
|
||||
indoc! {r#"
|
||||
1|struct User {
|
||||
…
|
||||
3| last_name: String,
|
||||
4| age: u32,
|
||||
5|}
|
||||
"#},
|
||||
),
|
||||
];
|
||||
|
||||
for (input, expected_output) in table {
|
||||
let input_without_ranges = input.replace(['«', '»'], "");
|
||||
let input_without_caret = input.replace('ˇ', "");
|
||||
let cursor_offset = input_without_ranges.find('ˇ');
|
||||
let (input, ranges) = marked_text_ranges(&input_without_caret, false);
|
||||
let buffer =
|
||||
cx.new(|cx| Buffer::local(input, cx).with_language(Arc::new(rust_lang()), cx));
|
||||
buffer.read_with(cx, |buffer, _cx| {
|
||||
let insertions = cursor_offset
|
||||
.map(|offset| {
|
||||
let point = buffer.offset_to_point(offset);
|
||||
vec![(
|
||||
predict_edits_v3::Point {
|
||||
line: Line(point.row),
|
||||
column: point.column,
|
||||
},
|
||||
"<|cursor|>",
|
||||
)]
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let ranges: Vec<Range<Line>> = ranges
|
||||
.into_iter()
|
||||
.map(|range| {
|
||||
let point_range = range.to_point(&buffer);
|
||||
Line(point_range.start.row)..Line(point_range.end.row)
|
||||
})
|
||||
.collect();
|
||||
|
||||
let mut output = String::new();
|
||||
cloud_zeta2_prompt::write_excerpts(
|
||||
assemble_excerpts(&buffer.snapshot(), ranges).iter(),
|
||||
&insertions,
|
||||
Line(buffer.max_point().row),
|
||||
true,
|
||||
&mut output,
|
||||
);
|
||||
assert_eq!(output, expected_output);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn rust_lang() -> Language {
|
||||
Language::new(
|
||||
LanguageConfig {
|
||||
name: "Rust".into(),
|
||||
matcher: LanguageMatcher {
|
||||
path_suffixes: vec!["rs".to_string()],
|
||||
..Default::default()
|
||||
},
|
||||
..Default::default()
|
||||
},
|
||||
Some(language::tree_sitter_rust::LANGUAGE.into()),
|
||||
)
|
||||
.with_outline_query(include_str!("../../languages/src/rust/outline.scm"))
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
+106
-258
@@ -1,6 +1,7 @@
|
||||
use anyhow::Result;
|
||||
use cloud_zeta2_prompt::retrieval_prompt::SearchToolQuery;
|
||||
use collections::HashMap;
|
||||
use edit_prediction_context2::{RelatedExcerpt, RelatedFile};
|
||||
use futures::{
|
||||
StreamExt,
|
||||
channel::mpsc::{self, UnboundedSender},
|
||||
@@ -8,7 +9,7 @@ use futures::{
|
||||
use gpui::{AppContext, AsyncApp, Entity};
|
||||
use language::{Anchor, Buffer, BufferSnapshot, OffsetRangeExt, Point, ToOffset, ToPoint};
|
||||
use project::{
|
||||
Project, WorktreeSettings,
|
||||
Project, ProjectPath, WorktreeSettings,
|
||||
search::{SearchQuery, SearchResult},
|
||||
};
|
||||
use smol::channel;
|
||||
@@ -20,14 +21,14 @@ use util::{
|
||||
use workspace::item::Settings as _;
|
||||
|
||||
#[cfg(feature = "eval-support")]
|
||||
type CachedSearchResults = std::collections::BTreeMap<std::path::PathBuf, Vec<Range<usize>>>;
|
||||
type CachedSearchResults = std::collections::BTreeMap<std::path::PathBuf, Vec<Range<(u32, u32)>>>;
|
||||
|
||||
pub async fn run_retrieval_searches(
|
||||
queries: Vec<SearchToolQuery>,
|
||||
project: Entity<Project>,
|
||||
#[cfg(feature = "eval-support")] eval_cache: Option<std::sync::Arc<dyn crate::EvalCache>>,
|
||||
cx: &mut AsyncApp,
|
||||
) -> Result<HashMap<Entity<Buffer>, Vec<Range<Anchor>>>> {
|
||||
) -> Result<Vec<RelatedFile>> {
|
||||
#[cfg(feature = "eval-support")]
|
||||
let cache = if let Some(eval_cache) = eval_cache {
|
||||
use crate::EvalCacheEntryKind;
|
||||
@@ -54,24 +55,44 @@ pub async fn run_retrieval_searches(
|
||||
if let Some(cached_results) = eval_cache.read(key) {
|
||||
let file_results = serde_json::from_str::<CachedSearchResults>(&cached_results)
|
||||
.context("Failed to deserialize cached search results")?;
|
||||
let mut results = HashMap::default();
|
||||
let mut results = Vec::new();
|
||||
|
||||
for (path, ranges) in file_results {
|
||||
let project_path = project.update(cx, |project, cx| {
|
||||
project.find_project_path(path, cx).unwrap()
|
||||
})?;
|
||||
let buffer = project
|
||||
.update(cx, |project, cx| {
|
||||
let project_path = project.find_project_path(path, cx).unwrap();
|
||||
project.open_buffer(project_path, cx)
|
||||
project.open_buffer(project_path.clone(), cx)
|
||||
})?
|
||||
.await?;
|
||||
let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
|
||||
let mut ranges: Vec<_> = ranges
|
||||
.into_iter()
|
||||
.map(|range| {
|
||||
snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end)
|
||||
})
|
||||
.map(
|
||||
|Range {
|
||||
start: (start_row, start_col),
|
||||
end: (end_row, end_col),
|
||||
}| {
|
||||
snapshot.anchor_before(Point::new(start_row, start_col))
|
||||
..snapshot.anchor_after(Point::new(end_row, end_col))
|
||||
},
|
||||
)
|
||||
.collect();
|
||||
merge_anchor_ranges(&mut ranges, &snapshot);
|
||||
results.insert(buffer, ranges);
|
||||
results.push(RelatedFile {
|
||||
path: project_path,
|
||||
buffer: buffer.downgrade(),
|
||||
excerpts: ranges
|
||||
.into_iter()
|
||||
.map(|range| RelatedExcerpt {
|
||||
point_range: range.to_point(&snapshot),
|
||||
text: snapshot.as_rope().slice(range.to_offset(&snapshot)),
|
||||
anchor_range: range,
|
||||
})
|
||||
.collect(),
|
||||
max_row: snapshot.max_point().row,
|
||||
});
|
||||
}
|
||||
|
||||
return Ok(results);
|
||||
@@ -117,14 +138,29 @@ pub async fn run_retrieval_searches(
|
||||
#[cfg(feature = "eval-support")]
|
||||
let cache = cache.clone();
|
||||
cx.background_spawn(async move {
|
||||
let mut results: HashMap<Entity<Buffer>, Vec<Range<Anchor>>> = HashMap::default();
|
||||
let mut results: Vec<RelatedFile> = Vec::default();
|
||||
let mut snapshots = HashMap::default();
|
||||
|
||||
let mut total_bytes = 0;
|
||||
'outer: while let Some((buffer, snapshot, excerpts)) = results_rx.next().await {
|
||||
snapshots.insert(buffer.entity_id(), snapshot);
|
||||
let existing = results.entry(buffer).or_default();
|
||||
existing.reserve(excerpts.len());
|
||||
'outer: while let Some((project_path, buffer, snapshot, excerpts)) = results_rx.next().await
|
||||
{
|
||||
let existing = results
|
||||
.iter_mut()
|
||||
.find(|related_file| related_file.buffer.entity_id() == buffer.entity_id());
|
||||
let existing = match existing {
|
||||
Some(existing) => existing,
|
||||
None => {
|
||||
results.push(RelatedFile {
|
||||
path: project_path,
|
||||
buffer: buffer.downgrade(),
|
||||
excerpts: Vec::new(),
|
||||
max_row: snapshot.max_point().row,
|
||||
});
|
||||
results.last_mut().unwrap()
|
||||
}
|
||||
};
|
||||
// let existing = results.entry(buffer).or_default();
|
||||
existing.excerpts.reserve(excerpts.len());
|
||||
|
||||
for (range, size) in excerpts {
|
||||
// Blunt trimming of the results until we have a proper algorithmic filtering step
|
||||
@@ -133,24 +169,34 @@ pub async fn run_retrieval_searches(
|
||||
break 'outer;
|
||||
}
|
||||
total_bytes += size;
|
||||
existing.push(range);
|
||||
existing.excerpts.push(RelatedExcerpt {
|
||||
point_range: range.to_point(&snapshot),
|
||||
text: snapshot.as_rope().slice(range.to_offset(&snapshot)),
|
||||
anchor_range: range,
|
||||
});
|
||||
}
|
||||
snapshots.insert(buffer.entity_id(), snapshot);
|
||||
}
|
||||
|
||||
#[cfg(feature = "eval-support")]
|
||||
if let Some((cache, queries, key)) = cache {
|
||||
let cached_results: CachedSearchResults = results
|
||||
.iter()
|
||||
.filter_map(|(buffer, ranges)| {
|
||||
let snapshot = snapshots.get(&buffer.entity_id())?;
|
||||
let path = snapshot.file().map(|f| f.path());
|
||||
let mut ranges = ranges
|
||||
.map(|related_file| {
|
||||
let mut ranges = related_file
|
||||
.excerpts
|
||||
.iter()
|
||||
.map(|range| range.to_offset(&snapshot))
|
||||
.map(
|
||||
|RelatedExcerpt {
|
||||
point_range: Range { start, end },
|
||||
..
|
||||
}| {
|
||||
(start.row, start.column)..(end.row, end.column)
|
||||
},
|
||||
)
|
||||
.collect::<Vec<_>>();
|
||||
ranges.sort_unstable_by_key(|range| (range.start, range.end));
|
||||
|
||||
Some((path?.as_std_path().to_path_buf(), ranges))
|
||||
(related_file.path.path.as_std_path().to_path_buf(), ranges)
|
||||
})
|
||||
.collect();
|
||||
cache.write(
|
||||
@@ -160,10 +206,8 @@ pub async fn run_retrieval_searches(
|
||||
);
|
||||
}
|
||||
|
||||
for (buffer, ranges) in results.iter_mut() {
|
||||
if let Some(snapshot) = snapshots.get(&buffer.entity_id()) {
|
||||
merge_anchor_ranges(ranges, snapshot);
|
||||
}
|
||||
for related_file in results.iter_mut() {
|
||||
related_file.merge_excerpts();
|
||||
}
|
||||
|
||||
Ok(results)
|
||||
@@ -171,6 +215,7 @@ pub async fn run_retrieval_searches(
|
||||
.await
|
||||
}
|
||||
|
||||
#[cfg(feature = "eval-support")]
|
||||
pub(crate) fn merge_anchor_ranges(ranges: &mut Vec<Range<Anchor>>, snapshot: &BufferSnapshot) {
|
||||
ranges.sort_unstable_by(|a, b| {
|
||||
a.start
|
||||
@@ -201,6 +246,7 @@ const MAX_RESULTS_LEN: usize = MAX_EXCERPT_LEN * 5;
|
||||
struct SearchJob {
|
||||
buffer: Entity<Buffer>,
|
||||
snapshot: BufferSnapshot,
|
||||
project_path: ProjectPath,
|
||||
ranges: Vec<Range<usize>>,
|
||||
query_ix: usize,
|
||||
jobs_tx: channel::Sender<SearchJob>,
|
||||
@@ -208,7 +254,12 @@ struct SearchJob {
|
||||
|
||||
async fn run_query(
|
||||
input_query: SearchToolQuery,
|
||||
results_tx: UnboundedSender<(Entity<Buffer>, BufferSnapshot, Vec<(Range<Anchor>, usize)>)>,
|
||||
results_tx: UnboundedSender<(
|
||||
ProjectPath,
|
||||
Entity<Buffer>,
|
||||
BufferSnapshot,
|
||||
Vec<(Range<Anchor>, usize)>,
|
||||
)>,
|
||||
path_style: PathStyle,
|
||||
exclude_matcher: PathMatcher,
|
||||
project: &Entity<Project>,
|
||||
@@ -257,12 +308,21 @@ async fn run_query(
|
||||
.read_with(cx, |buffer, _| buffer.parsing_idle())?
|
||||
.await;
|
||||
let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
|
||||
let Some(file) = snapshot.file() else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let project_path = cx.update(|cx| ProjectPath {
|
||||
worktree_id: file.worktree_id(cx),
|
||||
path: file.path().clone(),
|
||||
})?;
|
||||
let expanded_ranges: Vec<_> = ranges
|
||||
.into_iter()
|
||||
.filter_map(|range| expand_to_parent_range(&range, &snapshot))
|
||||
.collect();
|
||||
jobs_tx
|
||||
.send(SearchJob {
|
||||
project_path,
|
||||
buffer,
|
||||
snapshot,
|
||||
ranges: expanded_ranges,
|
||||
@@ -301,6 +361,13 @@ async fn run_query(
|
||||
|
||||
while let Some(SearchResult::Buffer { buffer, ranges }) = results_rx.next().await {
|
||||
let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
|
||||
let Some(file) = snapshot.file() else {
|
||||
continue;
|
||||
};
|
||||
let project_path = cx.update(|cx| ProjectPath {
|
||||
worktree_id: file.worktree_id(cx),
|
||||
path: file.path().clone(),
|
||||
})?;
|
||||
|
||||
let ranges = ranges
|
||||
.into_iter()
|
||||
@@ -314,7 +381,8 @@ async fn run_query(
|
||||
})
|
||||
.collect();
|
||||
|
||||
let send_result = results_tx.unbounded_send((buffer.clone(), snapshot.clone(), ranges));
|
||||
let send_result =
|
||||
results_tx.unbounded_send((project_path, buffer.clone(), snapshot.clone(), ranges));
|
||||
|
||||
if let Err(err) = send_result
|
||||
&& !err.is_disconnected()
|
||||
@@ -330,7 +398,12 @@ async fn run_query(
|
||||
}
|
||||
|
||||
async fn process_nested_search_job(
|
||||
results_tx: &UnboundedSender<(Entity<Buffer>, BufferSnapshot, Vec<(Range<Anchor>, usize)>)>,
|
||||
results_tx: &UnboundedSender<(
|
||||
ProjectPath,
|
||||
Entity<Buffer>,
|
||||
BufferSnapshot,
|
||||
Vec<(Range<Anchor>, usize)>,
|
||||
)>,
|
||||
queries: &Vec<SearchQuery>,
|
||||
content_query: &Option<SearchQuery>,
|
||||
job: SearchJob,
|
||||
@@ -347,6 +420,7 @@ async fn process_nested_search_job(
|
||||
}
|
||||
job.jobs_tx
|
||||
.send(SearchJob {
|
||||
project_path: job.project_path,
|
||||
buffer: job.buffer,
|
||||
snapshot: job.snapshot,
|
||||
ranges: subranges,
|
||||
@@ -382,7 +456,8 @@ async fn process_nested_search_job(
|
||||
})
|
||||
.collect();
|
||||
|
||||
let send_result = results_tx.unbounded_send((job.buffer, job.snapshot, matches));
|
||||
let send_result =
|
||||
results_tx.unbounded_send((job.project_path, job.buffer, job.snapshot, matches));
|
||||
|
||||
if let Err(err) = send_result
|
||||
&& !err.is_disconnected()
|
||||
@@ -413,230 +488,3 @@ fn expand_to_parent_range<T: ToPoint + ToOffset>(
|
||||
let node = snapshot.syntax_ancestor(line_range)?;
|
||||
Some(node.byte_range())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::assemble_excerpts::assemble_excerpts;
|
||||
use cloud_zeta2_prompt::write_codeblock;
|
||||
use edit_prediction_context::Line;
|
||||
use gpui::TestAppContext;
|
||||
use indoc::indoc;
|
||||
use language::{Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};
|
||||
use pretty_assertions::assert_eq;
|
||||
use project::FakeFs;
|
||||
use serde_json::json;
|
||||
use settings::SettingsStore;
|
||||
use std::path::Path;
|
||||
use util::path;
|
||||
|
||||
#[gpui::test]
|
||||
async fn test_retrieval(cx: &mut TestAppContext) {
|
||||
init_test(cx);
|
||||
let fs = FakeFs::new(cx.executor());
|
||||
fs.insert_tree(
|
||||
path!("/root"),
|
||||
json!({
|
||||
"user.rs": indoc!{"
|
||||
pub struct Organization {
|
||||
owner: Arc<User>,
|
||||
}
|
||||
|
||||
pub struct User {
|
||||
first_name: String,
|
||||
last_name: String,
|
||||
}
|
||||
|
||||
impl Organization {
|
||||
pub fn owner(&self) -> Arc<User> {
|
||||
self.owner.clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl User {
|
||||
pub fn new(first_name: String, last_name: String) -> Self {
|
||||
Self {
|
||||
first_name,
|
||||
last_name
|
||||
}
|
||||
}
|
||||
|
||||
pub fn first_name(&self) -> String {
|
||||
self.first_name.clone()
|
||||
}
|
||||
|
||||
pub fn last_name(&self) -> String {
|
||||
self.last_name.clone()
|
||||
}
|
||||
}
|
||||
"},
|
||||
"main.rs": indoc!{r#"
|
||||
fn main() {
|
||||
let user = User::new(FIRST_NAME.clone(), "doe".into());
|
||||
println!("user {:?}", user);
|
||||
}
|
||||
"#},
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
|
||||
let project = Project::test(fs, vec![Path::new(path!("/root"))], cx).await;
|
||||
project.update(cx, |project, _cx| {
|
||||
project.languages().add(rust_lang().into())
|
||||
});
|
||||
|
||||
assert_results(
|
||||
&project,
|
||||
SearchToolQuery {
|
||||
glob: "user.rs".into(),
|
||||
syntax_node: vec!["impl\\s+User".into(), "pub\\s+fn\\s+first_name".into()],
|
||||
content: None,
|
||||
},
|
||||
indoc! {r#"
|
||||
`````root/user.rs
|
||||
…
|
||||
impl User {
|
||||
…
|
||||
pub fn first_name(&self) -> String {
|
||||
self.first_name.clone()
|
||||
}
|
||||
…
|
||||
`````
|
||||
"#},
|
||||
cx,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_results(
|
||||
&project,
|
||||
SearchToolQuery {
|
||||
glob: "user.rs".into(),
|
||||
syntax_node: vec!["impl\\s+User".into()],
|
||||
content: Some("\\.clone".into()),
|
||||
},
|
||||
indoc! {r#"
|
||||
`````root/user.rs
|
||||
…
|
||||
impl User {
|
||||
…
|
||||
pub fn first_name(&self) -> String {
|
||||
self.first_name.clone()
|
||||
…
|
||||
pub fn last_name(&self) -> String {
|
||||
self.last_name.clone()
|
||||
…
|
||||
`````
|
||||
"#},
|
||||
cx,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_results(
|
||||
&project,
|
||||
SearchToolQuery {
|
||||
glob: "*.rs".into(),
|
||||
syntax_node: vec![],
|
||||
content: Some("\\.clone".into()),
|
||||
},
|
||||
indoc! {r#"
|
||||
`````root/main.rs
|
||||
fn main() {
|
||||
let user = User::new(FIRST_NAME.clone(), "doe".into());
|
||||
…
|
||||
`````
|
||||
|
||||
`````root/user.rs
|
||||
…
|
||||
impl Organization {
|
||||
pub fn owner(&self) -> Arc<User> {
|
||||
self.owner.clone()
|
||||
…
|
||||
impl User {
|
||||
…
|
||||
pub fn first_name(&self) -> String {
|
||||
self.first_name.clone()
|
||||
…
|
||||
pub fn last_name(&self) -> String {
|
||||
self.last_name.clone()
|
||||
…
|
||||
`````
|
||||
"#},
|
||||
cx,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn assert_results(
|
||||
project: &Entity<Project>,
|
||||
query: SearchToolQuery,
|
||||
expected_output: &str,
|
||||
cx: &mut TestAppContext,
|
||||
) {
|
||||
let results = run_retrieval_searches(
|
||||
vec![query],
|
||||
project.clone(),
|
||||
#[cfg(feature = "eval-support")]
|
||||
None,
|
||||
&mut cx.to_async(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let mut results = results.into_iter().collect::<Vec<_>>();
|
||||
results.sort_by_key(|results| {
|
||||
results
|
||||
.0
|
||||
.read_with(cx, |buffer, _| buffer.file().unwrap().path().clone())
|
||||
});
|
||||
|
||||
let mut output = String::new();
|
||||
for (buffer, ranges) in results {
|
||||
buffer.read_with(cx, |buffer, cx| {
|
||||
let excerpts = ranges.into_iter().map(|range| {
|
||||
let point_range = range.to_point(buffer);
|
||||
if point_range.end.column > 0 {
|
||||
Line(point_range.start.row)..Line(point_range.end.row + 1)
|
||||
} else {
|
||||
Line(point_range.start.row)..Line(point_range.end.row)
|
||||
}
|
||||
});
|
||||
|
||||
write_codeblock(
|
||||
&buffer.file().unwrap().full_path(cx),
|
||||
assemble_excerpts(&buffer.snapshot(), excerpts).iter(),
|
||||
&[],
|
||||
Line(buffer.max_point().row),
|
||||
false,
|
||||
&mut output,
|
||||
);
|
||||
});
|
||||
}
|
||||
output.pop();
|
||||
|
||||
assert_eq!(output, expected_output);
|
||||
}
|
||||
|
||||
fn rust_lang() -> Language {
|
||||
Language::new(
|
||||
LanguageConfig {
|
||||
name: "Rust".into(),
|
||||
matcher: LanguageMatcher {
|
||||
path_suffixes: vec!["rs".to_string()],
|
||||
..Default::default()
|
||||
},
|
||||
..Default::default()
|
||||
},
|
||||
Some(tree_sitter_rust::LANGUAGE.into()),
|
||||
)
|
||||
.with_outline_query(include_str!("../../languages/src/rust/outline.scm"))
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn init_test(cx: &mut TestAppContext) {
|
||||
cx.update(move |cx| {
|
||||
let settings_store = SettingsStore::test(cx);
|
||||
cx.set_global(settings_store);
|
||||
zlog::init_test();
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
+17
-11
@@ -1,6 +1,7 @@
|
||||
use anyhow::{Context as _, Result};
|
||||
use cloud_llm_client::predict_edits_v3::Event;
|
||||
use credentials_provider::CredentialsProvider;
|
||||
use edit_prediction_context2::RelatedFile;
|
||||
use futures::{AsyncReadExt as _, FutureExt, future::Shared};
|
||||
use gpui::{
|
||||
App, AppContext as _, Entity, Task,
|
||||
@@ -49,6 +50,7 @@ impl SweepAi {
|
||||
position: language::Anchor,
|
||||
events: Vec<Arc<Event>>,
|
||||
recent_paths: &VecDeque<ProjectPath>,
|
||||
related_files: Vec<RelatedFile>,
|
||||
diagnostic_search_range: Range<Point>,
|
||||
cx: &mut App,
|
||||
) -> Task<Result<Option<EditPredictionResult>>> {
|
||||
@@ -120,6 +122,19 @@ impl SweepAi {
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let retrieval_chunks = related_files
|
||||
.iter()
|
||||
.flat_map(|related_file| {
|
||||
related_file.excerpts.iter().map(|excerpt| FileChunk {
|
||||
file_path: related_file.path.path.as_unix_str().to_string(),
|
||||
start_line: excerpt.point_range.start.row as usize,
|
||||
end_line: excerpt.point_range.end.row as usize,
|
||||
content: excerpt.text.to_string(),
|
||||
timestamp: None,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let diagnostic_entries = snapshot.diagnostics_in_range(diagnostic_search_range, false);
|
||||
let mut diagnostic_content = String::new();
|
||||
let mut diagnostic_count = 0;
|
||||
@@ -168,7 +183,7 @@ impl SweepAi {
|
||||
multiple_suggestions: false,
|
||||
branch: None,
|
||||
file_chunks,
|
||||
retrieval_chunks: vec![],
|
||||
retrieval_chunks,
|
||||
recent_user_actions: vec![],
|
||||
use_bytes: true,
|
||||
// TODO
|
||||
@@ -320,7 +335,7 @@ struct AutocompleteRequest {
|
||||
pub cursor_position: usize,
|
||||
pub original_file_contents: String,
|
||||
pub file_chunks: Vec<FileChunk>,
|
||||
pub retrieval_chunks: Vec<RetrievalChunk>,
|
||||
pub retrieval_chunks: Vec<FileChunk>,
|
||||
pub recent_user_actions: Vec<UserAction>,
|
||||
pub multiple_suggestions: bool,
|
||||
pub privacy_mode_enabled: bool,
|
||||
@@ -337,15 +352,6 @@ struct FileChunk {
|
||||
pub timestamp: Option<u64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct RetrievalChunk {
|
||||
pub file_path: String,
|
||||
pub start_line: usize,
|
||||
pub end_line: usize,
|
||||
pub content: String,
|
||||
pub timestamp: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct UserAction {
|
||||
pub action_type: ActionType,
|
||||
|
||||
+406
-578
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user