diff --git a/.github/ISSUE_TEMPLATE/10_bug_report.yml b/.github/ISSUE_TEMPLATE/10_bug_report.yml
index 711ad6de245d2a194984bc493217c9fbf859aa27..cae10f02ec3b1bcb024f0d1f1bce0691a39054b4 100644
--- a/.github/ISSUE_TEMPLATE/10_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/10_bug_report.yml
@@ -75,6 +75,22 @@ body:
validations:
required: false
+ - type: textarea
+ attributes:
+ label: Relevant Keymap
+ description: |
+ Open the command palette in Zed, then type “zed: open keymap file” and copy/paste the file's contents.
+ value: |
+ keymap.json
+
+
+ ```json
+
+ ```
+
+ [\"'`])?",
- "# `path` is the shortest sequence of any non-space character",
- "(?(?[^ ]+?",
- " # which may end with a line and optionally a column,",
- " (?:+[0-9]+(:[0-9]+)?|:?\\([0-9]+([,:][0-9]+)?\\))?",
- "))",
- "# which must be followed by a matching quote",
- "(?()\\k)",
- "# and optionally a single closing symbol",
- "[)}\\]>]?",
- "# if line/column matched, may be followed by a description",
- "(?():[^ 0-9][^ ]*)?",
- "# which may be followed by trailing punctuation",
- "[.,:)}\\]>]*",
- "# and always includes trailing whitespace or end of line",
- "([ ]+|$)"
- ]
+ "(?",
+ " (",
+ " # multi-char path: first char (not opening delimiter or space)",
+ " [^({\\[<\"'`\\ ]",
+ " # middle chars: non-space, and colon/paren only if not followed by digit/paren",
+ " ([^\\ :(]|[:(][^0-9()])*",
+ " # last char: not closing delimiter or colon",
+ " [^()}\\]>\"'`.,;:\\ ]",
+ " |",
+ " # single-char path: not delimiter, punctuation, or space",
+ " [^(){}\\[\\]<>\"'`.,;:\\ ]",
+ " )",
+ " # optional line/column suffix (included in path for PathWithPosition::parse_str)",
+ " (:+[0-9]+(:[0-9]+)?|:?\\([0-9]+([,:]?[0-9]+)?\\))?",
+ ")",
+ ],
],
// Timeout for hover and Cmd-click path hyperlink discovery in milliseconds. Specifying a
// timeout of `0` will disable path hyperlinking in terminal.
- "path_hyperlink_timeout_ms": 1
+ "path_hyperlink_timeout_ms": 1,
},
"code_actions_on_format": {},
// Settings related to running tasks.
@@ -1685,7 +1681,7 @@
// * Zed task from history (e.g. one-off task was spawned before)
//
// Default: true
- "prefer_lsp": true
+ "prefer_lsp": true,
},
// An object whose keys are language names, and whose values
// are arrays of filenames or extensions of files that should
@@ -1702,7 +1698,7 @@
"file_types": {
"JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json", "**/Zed/**/*.json", "**/.vscode/**/*.json", "tsconfig*.json"],
"Markdown": [".rules", ".cursorrules", ".windsurfrules", ".clinerules"],
- "Shell Script": [".env.*"]
+ "Shell Script": [".env.*"],
},
// Settings for which version of Node.js and NPM to use when installing
// language servers and Copilot.
@@ -1718,7 +1714,7 @@
// `path`, but not `npm_path`, Zed will assume that `npm` is located at
// `${path}/../npm`.
"path": null,
- "npm_path": null
+ "npm_path": null,
},
// The extensions that Zed should automatically install on startup.
//
@@ -1730,7 +1726,7 @@
"anthropic": true,
"google-ai": true,
"openai": true,
- "openrouter": true
+ "openrouter": true,
},
// The capabilities granted to extensions.
//
@@ -1738,7 +1734,7 @@
"granted_extension_capabilities": [
{ "kind": "process:exec", "command": "*", "args": ["**"] },
{ "kind": "download_file", "host": "*", "path": ["**"] },
- { "kind": "npm:install", "package": "*" }
+ { "kind": "npm:install", "package": "*" },
],
// Controls how completions are processed for this language.
"completions": {
@@ -1789,7 +1785,7 @@
// 4. "replace_suffix"
// Behaves like `"replace"` if the text after the cursor is a suffix of the completion, and like
// `"insert"` otherwise.
- "lsp_insert_mode": "replace_suffix"
+ "lsp_insert_mode": "replace_suffix",
},
// Different settings for specific languages.
"languages": {
@@ -1797,116 +1793,116 @@
"language_servers": ["astro-language-server", "..."],
"prettier": {
"allowed": true,
- "plugins": ["prettier-plugin-astro"]
- }
+ "plugins": ["prettier-plugin-astro"],
+ },
},
"Blade": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"C": {
"format_on_save": "off",
"use_on_type_format": false,
"prettier": {
- "allowed": false
- }
+ "allowed": false,
+ },
},
"C++": {
"format_on_save": "off",
"use_on_type_format": false,
"prettier": {
- "allowed": false
- }
+ "allowed": false,
+ },
},
"CSharp": {
- "language_servers": ["roslyn", "!omnisharp", "..."]
+ "language_servers": ["roslyn", "!omnisharp", "..."],
},
"CSS": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"Dart": {
- "tab_size": 2
+ "tab_size": 2,
},
"Diff": {
"show_edit_predictions": false,
"remove_trailing_whitespace_on_save": false,
- "ensure_final_newline_on_save": false
+ "ensure_final_newline_on_save": false,
},
"Elixir": {
- "language_servers": ["elixir-ls", "!expert", "!next-ls", "!lexical", "..."]
+ "language_servers": ["elixir-ls", "!expert", "!next-ls", "!lexical", "..."],
},
"Elm": {
- "tab_size": 4
+ "tab_size": 4,
},
"Erlang": {
- "language_servers": ["erlang-ls", "!elp", "..."]
+ "language_servers": ["erlang-ls", "!elp", "..."],
},
"Git Commit": {
"allow_rewrap": "anywhere",
"soft_wrap": "editor_width",
- "preferred_line_length": 72
+ "preferred_line_length": 72,
},
"Go": {
"hard_tabs": true,
"code_actions_on_format": {
- "source.organizeImports": true
+ "source.organizeImports": true,
},
- "debuggers": ["Delve"]
+ "debuggers": ["Delve"],
},
"GraphQL": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"HEEX": {
- "language_servers": ["elixir-ls", "!expert", "!next-ls", "!lexical", "..."]
+ "language_servers": ["elixir-ls", "!expert", "!next-ls", "!lexical", "..."],
},
"HTML": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"HTML+ERB": {
- "language_servers": ["herb", "!ruby-lsp", "..."]
+ "language_servers": ["herb", "!ruby-lsp", "..."],
},
"Java": {
"prettier": {
"allowed": true,
- "plugins": ["prettier-plugin-java"]
- }
+ "plugins": ["prettier-plugin-java"],
+ },
},
"JavaScript": {
"language_servers": ["!typescript-language-server", "vtsls", "..."],
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"JSON": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"JSONC": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"JS+ERB": {
- "language_servers": ["!ruby-lsp", "..."]
+ "language_servers": ["!ruby-lsp", "..."],
},
"Kotlin": {
- "language_servers": ["!kotlin-language-server", "kotlin-lsp", "..."]
+ "language_servers": ["!kotlin-language-server", "kotlin-lsp", "..."],
},
"LaTeX": {
"formatter": "language_server",
"language_servers": ["texlab", "..."],
"prettier": {
"allowed": true,
- "plugins": ["prettier-plugin-latex"]
- }
+ "plugins": ["prettier-plugin-latex"],
+ },
},
"Markdown": {
"format_on_save": "off",
@@ -1914,136 +1910,142 @@
"remove_trailing_whitespace_on_save": false,
"allow_rewrap": "anywhere",
"soft_wrap": "editor_width",
+ "completions": {
+ "words": "disabled",
+ },
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"PHP": {
"language_servers": ["phpactor", "!intelephense", "!phptools", "..."],
"prettier": {
"allowed": true,
"plugins": ["@prettier/plugin-php"],
- "parser": "php"
- }
+ "parser": "php",
+ },
},
"Plain Text": {
"allow_rewrap": "anywhere",
- "soft_wrap": "editor_width"
+ "soft_wrap": "editor_width",
+ "completions": {
+ "words": "disabled",
+ },
},
"Python": {
"code_actions_on_format": {
- "source.organizeImports.ruff": true
+ "source.organizeImports.ruff": true,
},
"formatter": {
"language_server": {
- "name": "ruff"
- }
+ "name": "ruff",
+ },
},
"debuggers": ["Debugpy"],
- "language_servers": ["basedpyright", "ruff", "!ty", "!pyrefly", "!pyright", "!pylsp", "..."]
+ "language_servers": ["basedpyright", "ruff", "!ty", "!pyrefly", "!pyright", "!pylsp", "..."],
},
"Ruby": {
- "language_servers": ["solargraph", "!ruby-lsp", "!rubocop", "!sorbet", "!steep", "..."]
+ "language_servers": ["solargraph", "!ruby-lsp", "!rubocop", "!sorbet", "!steep", "..."],
},
"Rust": {
- "debuggers": ["CodeLLDB"]
+ "debuggers": ["CodeLLDB"],
},
"SCSS": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"Starlark": {
- "language_servers": ["starpls", "!buck2-lsp", "..."]
+ "language_servers": ["starpls", "!buck2-lsp", "..."],
},
"Svelte": {
"language_servers": ["svelte-language-server", "..."],
"prettier": {
"allowed": true,
- "plugins": ["prettier-plugin-svelte"]
- }
+ "plugins": ["prettier-plugin-svelte"],
+ },
},
"TSX": {
"language_servers": ["!typescript-language-server", "vtsls", "..."],
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"Twig": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"TypeScript": {
"language_servers": ["!typescript-language-server", "vtsls", "..."],
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"SystemVerilog": {
"format_on_save": "off",
"language_servers": ["!slang", "..."],
- "use_on_type_format": false
+ "use_on_type_format": false,
},
"Vue.js": {
"language_servers": ["vue-language-server", "vtsls", "..."],
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"XML": {
"prettier": {
"allowed": true,
- "plugins": ["@prettier/plugin-xml"]
- }
+ "plugins": ["@prettier/plugin-xml"],
+ },
},
"YAML": {
"prettier": {
- "allowed": true
- }
+ "allowed": true,
+ },
},
"YAML+ERB": {
- "language_servers": ["!ruby-lsp", "..."]
+ "language_servers": ["!ruby-lsp", "..."],
},
"Zig": {
- "language_servers": ["zls", "..."]
- }
+ "language_servers": ["zls", "..."],
+ },
},
// Different settings for specific language models.
"language_models": {
"anthropic": {
- "api_url": "https://api.anthropic.com"
+ "api_url": "https://api.anthropic.com",
},
"bedrock": {},
"google": {
- "api_url": "https://generativelanguage.googleapis.com"
+ "api_url": "https://generativelanguage.googleapis.com",
},
"ollama": {
- "api_url": "http://localhost:11434"
+ "api_url": "http://localhost:11434",
},
"openai": {
- "api_url": "https://api.openai.com/v1"
+ "api_url": "https://api.openai.com/v1",
},
"openai_compatible": {},
"open_router": {
- "api_url": "https://openrouter.ai/api/v1"
+ "api_url": "https://openrouter.ai/api/v1",
},
"lmstudio": {
- "api_url": "http://localhost:1234/api/v0"
+ "api_url": "http://localhost:1234/api/v0",
},
"deepseek": {
- "api_url": "https://api.deepseek.com/v1"
+ "api_url": "https://api.deepseek.com/v1",
},
"mistral": {
- "api_url": "https://api.mistral.ai/v1"
+ "api_url": "https://api.mistral.ai/v1",
},
"vercel": {
- "api_url": "https://api.v0.dev/v1"
+ "api_url": "https://api.v0.dev/v1",
},
"x_ai": {
- "api_url": "https://api.x.ai/v1"
+ "api_url": "https://api.x.ai/v1",
},
- "zed.dev": {}
+ "zed.dev": {},
},
"session": {
// Whether or not to restore unsaved buffers on restart.
@@ -2052,7 +2054,7 @@
// dirty files when closing the application.
//
// Default: true
- "restore_unsaved_buffers": true
+ "restore_unsaved_buffers": true,
},
// Zed's Prettier integration settings.
// Allows to enable/disable formatting with Prettier
@@ -2070,11 +2072,11 @@
// "singleQuote": true
// Forces Prettier integration to use a specific parser name when formatting files with the language
// when set to a non-empty string.
- "parser": ""
+ "parser": "",
},
// Settings for auto-closing of JSX tags.
"jsx_tag_auto_close": {
- "enabled": true
+ "enabled": true,
},
// LSP Specific settings.
"lsp": {
@@ -2095,19 +2097,19 @@
// Specify the DAP name as a key here.
"CodeLLDB": {
"env": {
- "RUST_LOG": "info"
- }
- }
+ "RUST_LOG": "info",
+ },
+ },
},
// Common language server settings.
"global_lsp_settings": {
// Whether to show the LSP servers button in the status bar.
- "button": true
+ "button": true,
},
// Jupyter settings
"jupyter": {
"enabled": true,
- "kernel_selections": {}
+ "kernel_selections": {},
// Specify the language name as the key and the kernel name as the value.
// "kernel_selections": {
// "python": "conda-base"
@@ -2121,7 +2123,7 @@
"max_columns": 128,
// Maximum number of lines to keep in REPL's scrollback buffer.
// Clamped with [4, 256] range.
- "max_lines": 32
+ "max_lines": 32,
},
// Vim settings
"vim": {
@@ -2135,7 +2137,7 @@
// Specify the mode as the key and the shape as the value.
// The mode can be one of the following: "normal", "replace", "insert", "visual".
// The shape can be one of the following: "block", "bar", "underline", "hollow".
- "cursor_shape": {}
+ "cursor_shape": {},
},
// The server to connect to. If the environment variable
// ZED_SERVER_URL is set, it will override this setting.
@@ -2168,9 +2170,9 @@
"windows": {
"languages": {
"PHP": {
- "language_servers": ["intelephense", "!phpactor", "!phptools", "..."]
- }
- }
+ "language_servers": ["intelephense", "!phpactor", "!phptools", "..."],
+ },
+ },
},
// Whether to show full labels in line indicator or short ones
//
@@ -2229,7 +2231,7 @@
"dock": "bottom",
"log_dap_communications": true,
"format_dap_log_messages": true,
- "button": true
+ "button": true,
},
// Configures any number of settings profiles that are temporarily applied on
// top of your existing user settings when selected from
@@ -2256,5 +2258,5 @@
// Useful for filtering out noisy logs or enabling more verbose logging.
//
// Example: {"log": {"client": "warn"}}
- "log": {}
+ "log": {},
}
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index 9d4973c94dc952eb421a93b14137458c4040810d..41aff48a2092645764d598684d13c1ce61704c44 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -11,8 +11,6 @@ use project::agent_server_store::AgentServerCommand;
use serde::Deserialize;
use settings::Settings as _;
use task::ShellBuilder;
-#[cfg(windows)]
-use task::ShellKind;
use util::ResultExt as _;
use std::path::PathBuf;
@@ -92,23 +90,8 @@ impl AcpConnection {
) -> Result {
let shell = cx.update(|cx| TerminalSettings::get(None, cx).shell.clone())?;
let builder = ShellBuilder::new(&shell, cfg!(windows));
- #[cfg(windows)]
- let kind = builder.kind();
- let (cmd, args) = builder.build(Some(command.path.display().to_string()), &command.args);
-
- let mut child = util::command::new_smol_command(cmd);
- #[cfg(windows)]
- if kind == ShellKind::Cmd {
- use smol::process::windows::CommandExt;
- for arg in args {
- child.raw_arg(arg);
- }
- } else {
- child.args(args);
- }
- #[cfg(not(windows))]
- child.args(args);
-
+ let mut child =
+ builder.build_command(Some(command.path.display().to_string()), &command.args);
child
.envs(command.env.iter().flatten())
.stdin(std::process::Stdio::piped())
diff --git a/crates/context_server/src/transport/stdio_transport.rs b/crates/context_server/src/transport/stdio_transport.rs
index 035a1ccb9d413d0bfab2e5c06b87ff293360f8f0..031f348294c04381f1e259b20c7cc818844953b4 100644
--- a/crates/context_server/src/transport/stdio_transport.rs
+++ b/crates/context_server/src/transport/stdio_transport.rs
@@ -33,12 +33,10 @@ impl StdioTransport {
) -> Result {
let shell = cx.update(|cx| TerminalSettings::get(None, cx).shell.clone())?;
let builder = ShellBuilder::new(&shell, cfg!(windows));
- let (command, args) =
- builder.build(Some(binary.executable.display().to_string()), &binary.args);
+ let mut command =
+ builder.build_command(Some(binary.executable.display().to_string()), &binary.args);
- let mut command = util::command::new_smol_command(command);
command
- .args(args)
.envs(binary.env.unwrap_or_default())
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index 58babbd251416118947362fae0a47a80cc277695..76edf4f9b438aca1c47393c9c14c6321d0013eb8 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -1045,54 +1045,47 @@ async fn heuristic_syntactic_expand(
let node_range = node_start..node_end;
let row_count = node_end.row - node_start.row + 1;
let mut ancestor_range = None;
- let reached_outline_node = cx.background_executor().scoped({
- let node_range = node_range.clone();
- let outline_range = outline_range.clone();
- let ancestor_range = &mut ancestor_range;
- |scope| {
- scope.spawn(async move {
- // Stop if we've exceeded the row count or reached an outline node. Then, find the interval
- // of node children which contains the query range. For example, this allows just returning
- // the header of a declaration rather than the entire declaration.
- if row_count > max_row_count || outline_range == Some(node_range.clone()) {
- let mut cursor = node.walk();
- let mut included_child_start = None;
- let mut included_child_end = None;
- let mut previous_end = node_start;
- if cursor.goto_first_child() {
- loop {
- let child_node = cursor.node();
- let child_range =
- previous_end..Point::from_ts_point(child_node.end_position());
- if included_child_start.is_none()
- && child_range.contains(&input_range.start)
- {
- included_child_start = Some(child_range.start);
- }
- if child_range.contains(&input_range.end) {
- included_child_end = Some(child_range.end);
- }
- previous_end = child_range.end;
- if !cursor.goto_next_sibling() {
- break;
- }
+ cx.background_executor()
+ .await_on_background(async {
+ // Stop if we've exceeded the row count or reached an outline node. Then, find the interval
+ // of node children which contains the query range. For example, this allows just returning
+ // the header of a declaration rather than the entire declaration.
+ if row_count > max_row_count || outline_range == Some(node_range.clone()) {
+ let mut cursor = node.walk();
+ let mut included_child_start = None;
+ let mut included_child_end = None;
+ let mut previous_end = node_start;
+ if cursor.goto_first_child() {
+ loop {
+ let child_node = cursor.node();
+ let child_range =
+ previous_end..Point::from_ts_point(child_node.end_position());
+ if included_child_start.is_none()
+ && child_range.contains(&input_range.start)
+ {
+ included_child_start = Some(child_range.start);
}
- }
- let end = included_child_end.unwrap_or(node_range.end);
- if let Some(start) = included_child_start {
- let row_count = end.row - start.row;
- if row_count < max_row_count {
- *ancestor_range =
- Some(Some(RangeInclusive::new(start.row, end.row)));
- return;
+ if child_range.contains(&input_range.end) {
+ included_child_end = Some(child_range.end);
+ }
+ previous_end = child_range.end;
+ if !cursor.goto_next_sibling() {
+ break;
}
}
- *ancestor_range = Some(None);
}
- })
- }
- });
- reached_outline_node.await;
+ let end = included_child_end.unwrap_or(node_range.end);
+ if let Some(start) = included_child_start {
+ let row_count = end.row - start.row;
+ if row_count < max_row_count {
+ ancestor_range = Some(Some(RangeInclusive::new(start.row, end.row)));
+ return;
+ }
+ }
+ ancestor_range = Some(None);
+ }
+ })
+ .await;
if let Some(node) = ancestor_range {
return node;
}
diff --git a/crates/edit_prediction/Cargo.toml b/crates/edit_prediction/Cargo.toml
index c9237232e5e0bb6167fbeee8732d46ee584b080b..53ddb99bd3f458a540c6593a2b1d6b1b547e463b 100644
--- a/crates/edit_prediction/Cargo.toml
+++ b/crates/edit_prediction/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
path = "src/edit_prediction.rs"
[features]
-eval-support = []
+cli-support = []
[dependencies]
ai_onboarding.workspace = true
diff --git a/crates/edit_prediction/src/edit_prediction.rs b/crates/edit_prediction/src/edit_prediction.rs
index b0d4a5f4d69c357fb0a153bee267a64dc0c465dd..6a7c6232d08b15fccacdd80a446432e453a80e20 100644
--- a/crates/edit_prediction/src/edit_prediction.rs
+++ b/crates/edit_prediction/src/edit_prediction.rs
@@ -55,7 +55,7 @@ pub mod open_ai_response;
mod prediction;
pub mod sweep_ai;
-#[cfg(any(test, feature = "test-support", feature = "eval-support"))]
+#[cfg(any(test, feature = "test-support", feature = "cli-support"))]
pub mod udiff;
mod zed_edit_prediction_delegate;
@@ -158,7 +158,7 @@ pub struct EditPredictionStore {
use_context: bool,
options: ZetaOptions,
update_required: bool,
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
eval_cache: Option>,
edit_prediction_model: EditPredictionModel,
pub sweep_ai: SweepAi,
@@ -283,6 +283,18 @@ impl ProjectState {
})
.detach()
}
+
+ fn active_buffer(
+ &self,
+ project: &Entity,
+ cx: &App,
+ ) -> Option<(Entity, Option)> {
+ let project = project.read(cx);
+ let active_path = project.path_for_entry(project.active_entry()?, cx)?;
+ let active_buffer = project.buffer_store().read(cx).get_by_path(&active_path)?;
+ let registered_buffer = self.registered_buffers.get(&active_buffer.entity_id())?;
+ Some((active_buffer, registered_buffer.last_position))
+ }
}
#[derive(Debug, Clone)]
@@ -373,6 +385,7 @@ impl std::ops::Deref for BufferEditPrediction<'_> {
struct RegisteredBuffer {
snapshot: BufferSnapshot,
+ last_position: Option,
_subscriptions: [gpui::Subscription; 2],
}
@@ -492,7 +505,7 @@ impl EditPredictionStore {
},
),
update_required: false,
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
eval_cache: None,
edit_prediction_model: EditPredictionModel::Zeta2,
sweep_ai: SweepAi::new(cx),
@@ -541,7 +554,7 @@ impl EditPredictionStore {
.is_some()
}
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
pub fn with_eval_cache(&mut self, cache: Arc) {
self.eval_cache = Some(cache);
}
@@ -564,6 +577,12 @@ impl EditPredictionStore {
}
}
+ pub fn clear_history_for_project(&mut self, project: &Entity) {
+ if let Some(project_state) = self.projects.get_mut(&project.entity_id()) {
+ project_state.events.clear();
+ }
+ }
+
pub fn edit_history_for_project(
&self,
project: &Entity,
@@ -795,6 +814,7 @@ impl EditPredictionStore {
let project_entity_id = project.entity_id();
entry.insert(RegisteredBuffer {
snapshot,
+ last_position: None,
_subscriptions: [
cx.subscribe(buffer, {
let project = project.downgrade();
@@ -882,13 +902,21 @@ impl EditPredictionStore {
});
}
- fn current_prediction_for_buffer(
- &self,
+ fn prediction_at(
+ &mut self,
buffer: &Entity,
+ position: Option,
project: &Entity,
cx: &App,
) -> Option> {
- let project_state = self.projects.get(&project.entity_id())?;
+ let project_state = self.projects.get_mut(&project.entity_id())?;
+ if let Some(position) = position
+ && let Some(buffer) = project_state
+ .registered_buffers
+ .get_mut(&buffer.entity_id())
+ {
+ buffer.last_position = Some(position);
+ }
let CurrentEditPrediction {
requested_by,
@@ -1131,12 +1159,21 @@ impl EditPredictionStore {
};
self.queue_prediction_refresh(project.clone(), project.entity_id(), cx, move |this, cx| {
- let Some(open_buffer_task) = project
- .update(cx, |project, cx| {
- project
- .active_entry()
- .and_then(|entry| project.path_for_entry(entry, cx))
- .map(|path| project.open_buffer(path, cx))
+ let Some((active_buffer, snapshot, cursor_point)) = this
+ .read_with(cx, |this, cx| {
+ let project_state = this.projects.get(&project.entity_id())?;
+ let (buffer, position) = project_state.active_buffer(&project, cx)?;
+ let snapshot = buffer.read(cx).snapshot();
+
+ if !Self::predictions_enabled_at(&snapshot, position, cx) {
+ return None;
+ }
+
+ let cursor_point = position
+ .map(|pos| pos.to_point(&snapshot))
+ .unwrap_or_default();
+
+ Some((buffer, snapshot, cursor_point))
})
.log_err()
.flatten()
@@ -1145,14 +1182,11 @@ impl EditPredictionStore {
};
cx.spawn(async move |cx| {
- let active_buffer = open_buffer_task.await?;
- let snapshot = active_buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
-
let Some((jump_buffer, jump_position)) = Self::next_diagnostic_location(
active_buffer,
&snapshot,
Default::default(),
- Default::default(),
+ cursor_point,
&project,
cx,
)
@@ -1197,6 +1231,37 @@ impl EditPredictionStore {
});
}
+ fn predictions_enabled_at(
+ snapshot: &BufferSnapshot,
+ position: Option,
+ cx: &App,
+ ) -> bool {
+ let file = snapshot.file();
+ let all_settings = all_language_settings(file, cx);
+ if !all_settings.show_edit_predictions(snapshot.language(), cx)
+ || file.is_some_and(|file| !all_settings.edit_predictions_enabled_for_file(file, cx))
+ {
+ return false;
+ }
+
+ if let Some(last_position) = position {
+ let settings = snapshot.settings_at(last_position, cx);
+
+ if !settings.edit_predictions_disabled_in.is_empty()
+ && let Some(scope) = snapshot.language_scope_at(last_position)
+ && let Some(scope_name) = scope.override_name()
+ && settings
+ .edit_predictions_disabled_in
+ .iter()
+ .any(|s| s == scope_name)
+ {
+ return false;
+ }
+ }
+
+ true
+ }
+
#[cfg(not(test))]
pub const THROTTLE_TIMEOUT: Duration = Duration::from_millis(300);
#[cfg(test)]
@@ -1531,8 +1596,8 @@ impl EditPredictionStore {
client: Arc,
llm_token: LlmApiToken,
app_version: Version,
- #[cfg(feature = "eval-support")] eval_cache: Option>,
- #[cfg(feature = "eval-support")] eval_cache_kind: EvalCacheEntryKind,
+ #[cfg(feature = "cli-support")] eval_cache: Option>,
+ #[cfg(feature = "cli-support")] eval_cache_kind: EvalCacheEntryKind,
) -> Result<(open_ai::Response, Option)> {
let url = if let Some(predict_edits_url) = PREDICT_EDITS_URL.as_ref() {
http_client::Url::parse(&predict_edits_url)?
@@ -1542,7 +1607,7 @@ impl EditPredictionStore {
.build_zed_llm_url("/predict_edits/raw", &[])?
};
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
let cache_key = if let Some(cache) = eval_cache {
use collections::FxHasher;
use std::hash::{Hash, Hasher};
@@ -1576,7 +1641,7 @@ impl EditPredictionStore {
)
.await?;
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
if let Some((cache, request, key)) = cache_key {
cache.write(key, &request, &serde_json::to_string_pretty(&response)?);
}
@@ -1708,7 +1773,7 @@ impl EditPredictionStore {
}
}
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
pub fn set_context_for_buffer(
&mut self,
project: &Entity,
@@ -1833,10 +1898,10 @@ pub struct ZedUpdateRequiredError {
minimum_version: Version,
}
-#[cfg(feature = "eval-support")]
+#[cfg(feature = "cli-support")]
pub type EvalCacheKey = (EvalCacheEntryKind, u64);
-#[cfg(feature = "eval-support")]
+#[cfg(feature = "cli-support")]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum EvalCacheEntryKind {
Context,
@@ -1844,7 +1909,7 @@ pub enum EvalCacheEntryKind {
Prediction,
}
-#[cfg(feature = "eval-support")]
+#[cfg(feature = "cli-support")]
impl std::fmt::Display for EvalCacheEntryKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
@@ -1855,7 +1920,7 @@ impl std::fmt::Display for EvalCacheEntryKind {
}
}
-#[cfg(feature = "eval-support")]
+#[cfg(feature = "cli-support")]
pub trait EvalCache: Send + Sync {
fn read(&self, key: EvalCacheKey) -> Option;
fn write(&self, key: EvalCacheKey, input: &str, value: &str);
diff --git a/crates/edit_prediction/src/edit_prediction_tests.rs b/crates/edit_prediction/src/edit_prediction_tests.rs
index f6465b14cbd1b3357349071bc5eda399253b5328..9e4baa78ef4564ce4348ef1b51085ba0a6abdffc 100644
--- a/crates/edit_prediction/src/edit_prediction_tests.rs
+++ b/crates/edit_prediction/src/edit_prediction_tests.rs
@@ -45,10 +45,6 @@ async fn test_current_state(cx: &mut TestAppContext) {
.await;
let project = Project::test(fs, vec![path!("/root").as_ref()], cx).await;
- ep_store.update(cx, |ep_store, cx| {
- ep_store.register_project(&project, cx);
- });
-
let buffer1 = project
.update(cx, |project, cx| {
let path = project.find_project_path(path!("/root/1.txt"), cx).unwrap();
@@ -60,6 +56,11 @@ async fn test_current_state(cx: &mut TestAppContext) {
let snapshot1 = buffer1.read_with(cx, |buffer, _cx| buffer.snapshot());
let position = snapshot1.anchor_before(language::Point::new(1, 3));
+ ep_store.update(cx, |ep_store, cx| {
+ ep_store.register_project(&project, cx);
+ ep_store.register_buffer(&buffer1, &project, cx);
+ });
+
// Prediction for current file
ep_store.update(cx, |ep_store, cx| {
@@ -84,9 +85,9 @@ async fn test_current_state(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
let prediction = ep_store
- .current_prediction_for_buffer(&buffer1, &project, cx)
+ .prediction_at(&buffer1, None, &project, cx)
.unwrap();
assert_matches!(prediction, BufferEditPrediction::Local { .. });
});
@@ -140,9 +141,9 @@ async fn test_current_state(cx: &mut TestAppContext) {
.unwrap();
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
let prediction = ep_store
- .current_prediction_for_buffer(&buffer1, &project, cx)
+ .prediction_at(&buffer1, None, &project, cx)
.unwrap();
assert_matches!(
prediction,
@@ -158,9 +159,9 @@ async fn test_current_state(cx: &mut TestAppContext) {
.await
.unwrap();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
let prediction = ep_store
- .current_prediction_for_buffer(&buffer2, &project, cx)
+ .prediction_at(&buffer2, None, &project, cx)
.unwrap();
assert_matches!(prediction, BufferEditPrediction::Local { .. });
});
@@ -344,10 +345,10 @@ async fn test_empty_prediction(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
assert!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.is_none()
);
});
@@ -404,10 +405,10 @@ async fn test_interpolated_empty(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
assert!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.is_none()
);
});
@@ -469,10 +470,10 @@ async fn test_replace_current(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -492,11 +493,11 @@ async fn test_replace_current(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// second replaces first
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -551,10 +552,10 @@ async fn test_current_preferred(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -586,11 +587,11 @@ async fn test_current_preferred(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// first is preferred over second
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -657,11 +658,11 @@ async fn test_cancel_earlier_pending_requests(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// current prediction is second
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -675,11 +676,11 @@ async fn test_cancel_earlier_pending_requests(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// current prediction is still second, since first was cancelled
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -768,11 +769,11 @@ async fn test_cancel_second_on_third_request(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// current prediction is first
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -786,11 +787,11 @@ async fn test_cancel_second_on_third_request(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// current prediction is still first, since second was cancelled
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
@@ -804,11 +805,11 @@ async fn test_cancel_second_on_third_request(cx: &mut TestAppContext) {
cx.run_until_parked();
- ep_store.read_with(cx, |ep_store, cx| {
+ ep_store.update(cx, |ep_store, cx| {
// third completes and replaces first
assert_eq!(
ep_store
- .current_prediction_for_buffer(&buffer, &project, cx)
+ .prediction_at(&buffer, None, &project, cx)
.unwrap()
.id
.0,
diff --git a/crates/edit_prediction/src/license_detection.rs b/crates/edit_prediction/src/license_detection.rs
index d4d4825615f19e5e5654f7bd78439d9eaa39e4c1..3ad34e7e6df6233cd4ff7462681d7b3588d36534 100644
--- a/crates/edit_prediction/src/license_detection.rs
+++ b/crates/edit_prediction/src/license_detection.rs
@@ -735,6 +735,7 @@ mod tests {
true,
fs.clone(),
Default::default(),
+ true,
&mut cx.to_async(),
)
.await
@@ -758,6 +759,7 @@ mod tests {
true,
fs.clone(),
Default::default(),
+ true,
&mut cx.to_async(),
)
.await
@@ -816,6 +818,7 @@ mod tests {
true,
fs.clone(),
Default::default(),
+ true,
&mut cx.to_async(),
)
.await
diff --git a/crates/edit_prediction/src/udiff.rs b/crates/edit_prediction/src/udiff.rs
index b9cf564c16d68a98baa1986333f2bfd767c6a24b..78fec03dd78301d56ac6e3f914ba60432e41637d 100644
--- a/crates/edit_prediction/src/udiff.rs
+++ b/crates/edit_prediction/src/udiff.rs
@@ -15,7 +15,9 @@ use collections::HashMap;
use gpui::AsyncApp;
use gpui::Entity;
use language::{Anchor, Buffer, OffsetRangeExt as _, TextBufferSnapshot};
-use project::Project;
+use project::{Project, ProjectPath};
+use util::paths::PathStyle;
+use util::rel_path::RelPath;
#[derive(Clone, Debug)]
pub struct OpenedBuffers(#[allow(unused)] HashMap>);
@@ -28,18 +30,27 @@ pub async fn apply_diff(
) -> Result {
let mut included_files = HashMap::default();
+ let worktree_id = project.read_with(cx, |project, cx| {
+ anyhow::Ok(
+ project
+ .visible_worktrees(cx)
+ .next()
+ .context("no worktrees")?
+ .read(cx)
+ .id(),
+ )
+ })??;
+
for line in diff_str.lines() {
let diff_line = DiffLine::parse(line);
if let DiffLine::OldPath { path } = diff_line {
let buffer = project
.update(cx, |project, cx| {
- let project_path =
- project
- .find_project_path(path.as_ref(), cx)
- .with_context(|| {
- format!("Failed to find worktree for new path: {}", path)
- })?;
+ let project_path = ProjectPath {
+ worktree_id,
+ path: RelPath::new(Path::new(path.as_ref()), PathStyle::Posix)?.into_arc(),
+ };
anyhow::Ok(project.open_buffer(project_path, cx))
})??
.await?;
@@ -127,7 +138,7 @@ pub fn apply_diff_to_string(diff_str: &str, text: &str) -> Result {
DiffEvent::Hunk { hunk, .. } => {
let hunk_offset = text
.find(&hunk.context)
- .ok_or_else(|| anyhow!("couldn't result hunk {:?}", hunk.context))?;
+ .ok_or_else(|| anyhow!("couldn't resolve hunk {:?}", hunk.context))?;
for edit in hunk.edits.iter().rev() {
let range = (hunk_offset + edit.range.start)..(hunk_offset + edit.range.end);
text.replace_range(range, &edit.text);
@@ -726,38 +737,38 @@ mod tests {
let project = Project::test(fs, [path!("/root").as_ref()], cx).await;
let diff = indoc! {r#"
- --- a/root/file1
- +++ b/root/file1
+ --- a/file1
+ +++ b/file1
one
two
-three
+3
four
five
- --- a/root/file1
- +++ b/root/file1
+ --- a/file1
+ +++ b/file1
3
-four
-five
+4
+5
- --- a/root/file1
- +++ b/root/file1
+ --- a/file1
+ +++ b/file1
-one
-two
3
4
- --- a/root/file2
- +++ b/root/file2
+ --- a/file2
+ +++ b/file2
+5
six
- --- a/root/file2
- +++ b/root/file2
+ --- a/file2
+ +++ b/file2
seven
+7.5
eight
- --- a/root/file2
- +++ b/root/file2
+ --- a/file2
+ +++ b/file2
ten
+11
"#};
@@ -826,8 +837,8 @@ mod tests {
let project = Project::test(fs, [path!("/root").as_ref()], cx).await;
let diff = indoc! {r#"
- --- a/root/file1
- +++ b/root/file1
+ --- a/file1
+ +++ b/file1
one
two
-three
diff --git a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs
index 91371d539beca012e2ded4e9ec8702c8db39bd8a..6dcf7092240de64381ded611b47c2dd5940d6770 100644
--- a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs
+++ b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs
@@ -125,14 +125,15 @@ impl EditPredictionDelegate for ZedEditPredictionDelegate {
return;
}
- if let Some(current) = store.current_prediction_for_buffer(&buffer, &self.project, cx)
- && let BufferEditPrediction::Local { prediction } = current
- && prediction.interpolate(buffer.read(cx)).is_some()
- {
- return;
- }
-
self.store.update(cx, |store, cx| {
+ if let Some(current) =
+ store.prediction_at(&buffer, Some(cursor_position), &self.project, cx)
+ && let BufferEditPrediction::Local { prediction } = current
+ && prediction.interpolate(buffer.read(cx)).is_some()
+ {
+ return;
+ }
+
store.refresh_context(&self.project, &buffer, cursor_position, cx);
store.refresh_prediction_from_buffer(self.project.clone(), buffer, cursor_position, cx)
});
@@ -171,69 +172,68 @@ impl EditPredictionDelegate for ZedEditPredictionDelegate {
cursor_position: language::Anchor,
cx: &mut Context,
) -> Option {
- let prediction =
- self.store
- .read(cx)
- .current_prediction_for_buffer(buffer, &self.project, cx)?;
-
- let prediction = match prediction {
- BufferEditPrediction::Local { prediction } => prediction,
- BufferEditPrediction::Jump { prediction } => {
- return Some(edit_prediction_types::EditPrediction::Jump {
- id: Some(prediction.id.to_string().into()),
- snapshot: prediction.snapshot.clone(),
- target: prediction.edits.first().unwrap().0.start,
- });
- }
- };
+ self.store.update(cx, |store, cx| {
+ let prediction =
+ store.prediction_at(buffer, Some(cursor_position), &self.project, cx)?;
+
+ let prediction = match prediction {
+ BufferEditPrediction::Local { prediction } => prediction,
+ BufferEditPrediction::Jump { prediction } => {
+ return Some(edit_prediction_types::EditPrediction::Jump {
+ id: Some(prediction.id.to_string().into()),
+ snapshot: prediction.snapshot.clone(),
+ target: prediction.edits.first().unwrap().0.start,
+ });
+ }
+ };
- let buffer = buffer.read(cx);
- let snapshot = buffer.snapshot();
+ let buffer = buffer.read(cx);
+ let snapshot = buffer.snapshot();
- let Some(edits) = prediction.interpolate(&snapshot) else {
- self.store.update(cx, |store, _cx| {
+ let Some(edits) = prediction.interpolate(&snapshot) else {
store.reject_current_prediction(
EditPredictionRejectReason::InterpolatedEmpty,
&self.project,
);
- });
- return None;
- };
-
- let cursor_row = cursor_position.to_point(&snapshot).row;
- let (closest_edit_ix, (closest_edit_range, _)) =
- edits.iter().enumerate().min_by_key(|(_, (range, _))| {
- let distance_from_start = cursor_row.abs_diff(range.start.to_point(&snapshot).row);
- let distance_from_end = cursor_row.abs_diff(range.end.to_point(&snapshot).row);
- cmp::min(distance_from_start, distance_from_end)
- })?;
-
- let mut edit_start_ix = closest_edit_ix;
- for (range, _) in edits[..edit_start_ix].iter().rev() {
- let distance_from_closest_edit = closest_edit_range.start.to_point(&snapshot).row
- - range.end.to_point(&snapshot).row;
- if distance_from_closest_edit <= 1 {
- edit_start_ix -= 1;
- } else {
- break;
+ return None;
+ };
+
+ let cursor_row = cursor_position.to_point(&snapshot).row;
+ let (closest_edit_ix, (closest_edit_range, _)) =
+ edits.iter().enumerate().min_by_key(|(_, (range, _))| {
+ let distance_from_start =
+ cursor_row.abs_diff(range.start.to_point(&snapshot).row);
+ let distance_from_end = cursor_row.abs_diff(range.end.to_point(&snapshot).row);
+ cmp::min(distance_from_start, distance_from_end)
+ })?;
+
+ let mut edit_start_ix = closest_edit_ix;
+ for (range, _) in edits[..edit_start_ix].iter().rev() {
+ let distance_from_closest_edit = closest_edit_range.start.to_point(&snapshot).row
+ - range.end.to_point(&snapshot).row;
+ if distance_from_closest_edit <= 1 {
+ edit_start_ix -= 1;
+ } else {
+ break;
+ }
}
- }
- let mut edit_end_ix = closest_edit_ix + 1;
- for (range, _) in &edits[edit_end_ix..] {
- let distance_from_closest_edit =
- range.start.to_point(buffer).row - closest_edit_range.end.to_point(&snapshot).row;
- if distance_from_closest_edit <= 1 {
- edit_end_ix += 1;
- } else {
- break;
+ let mut edit_end_ix = closest_edit_ix + 1;
+ for (range, _) in &edits[edit_end_ix..] {
+ let distance_from_closest_edit = range.start.to_point(buffer).row
+ - closest_edit_range.end.to_point(&snapshot).row;
+ if distance_from_closest_edit <= 1 {
+ edit_end_ix += 1;
+ } else {
+ break;
+ }
}
- }
- Some(edit_prediction_types::EditPrediction::Local {
- id: Some(prediction.id.to_string().into()),
- edits: edits[edit_start_ix..edit_end_ix].to_vec(),
- edit_preview: Some(prediction.edit_preview.clone()),
+ Some(edit_prediction_types::EditPrediction::Local {
+ id: Some(prediction.id.to_string().into()),
+ edits: edits[edit_start_ix..edit_end_ix].to_vec(),
+ edit_preview: Some(prediction.edit_preview.clone()),
+ })
})
}
}
diff --git a/crates/edit_prediction/src/zeta2.rs b/crates/edit_prediction/src/zeta2.rs
index 034954f5760939fc31b3e5e1e8a09737c5b2e568..8586e6caaea1fdc9c865ddba8894f680d766b4a9 100644
--- a/crates/edit_prediction/src/zeta2.rs
+++ b/crates/edit_prediction/src/zeta2.rs
@@ -1,4 +1,4 @@
-#[cfg(feature = "eval-support")]
+#[cfg(feature = "cli-support")]
use crate::EvalCacheEntryKind;
use crate::open_ai_response::text_from_response;
use crate::prediction::EditPredictionResult;
@@ -44,7 +44,7 @@ pub fn request_prediction_with_zeta2(
let llm_token = store.llm_token.clone();
let app_version = AppVersion::global(cx);
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
let eval_cache = store.eval_cache.clone();
let request_task = cx.background_spawn({
@@ -95,9 +95,9 @@ pub fn request_prediction_with_zeta2(
client,
llm_token,
app_version,
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
eval_cache,
- #[cfg(feature = "eval-support")]
+ #[cfg(feature = "cli-support")]
EvalCacheEntryKind::Prediction,
)
.await;
@@ -226,3 +226,15 @@ pub fn zeta2_prompt_input(
};
(editable_offset_range, prompt_input)
}
+
+#[cfg(feature = "cli-support")]
+pub fn zeta2_output_for_patch(input: &zeta_prompt::ZetaPromptInput, patch: &str) -> String {
+ eprintln!("{}", patch);
+ eprintln!("---------------------");
+ eprintln!("{}", input.cursor_excerpt);
+ crate::udiff::apply_diff_to_string(
+ patch,
+ &input.cursor_excerpt[input.editable_range_in_excerpt.clone()],
+ )
+ .unwrap()
+}
diff --git a/crates/edit_prediction_cli/Cargo.toml b/crates/edit_prediction_cli/Cargo.toml
index 0e7fff8d70156c58147069f8da64035d6a80adc8..811808c72304f4c11a9858e61395e46024b83f1e 100644
--- a/crates/edit_prediction_cli/Cargo.toml
+++ b/crates/edit_prediction_cli/Cargo.toml
@@ -34,6 +34,7 @@ language_extension.workspace = true
language_model.workspace = true
language_models.workspace = true
languages = { workspace = true, features = ["load-grammars"] }
+libc.workspace = true
log.workspace = true
node_runtime.workspace = true
paths.workspace = true
@@ -52,10 +53,9 @@ sqlez_macros.workspace = true
terminal_view.workspace = true
util.workspace = true
watch.workspace = true
-edit_prediction = { workspace = true, features = ["eval-support"] }
+edit_prediction = { workspace = true, features = ["cli-support"] }
wasmtime.workspace = true
zeta_prompt.workspace = true
-zlog.workspace = true
# Wasmtime is included as a dependency in order to enable the same
# features that are enabled in Zed.
diff --git a/crates/edit_prediction_cli/src/distill.rs b/crates/edit_prediction_cli/src/distill.rs
new file mode 100644
index 0000000000000000000000000000000000000000..495b3cd88cbd05ad1917517580b913aacf4fb107
--- /dev/null
+++ b/crates/edit_prediction_cli/src/distill.rs
@@ -0,0 +1,14 @@
+use std::mem;
+
+use crate::example::Example;
+
+pub async fn run_distill(example: &mut Example) {
+ let [prediction]: [_; 1] = mem::take(&mut example.predictions)
+ .try_into()
+ .expect("Run predict first with a single repetition");
+
+ example.expected_patch = prediction.actual_patch;
+ example.prompt = None;
+ example.predictions = Vec::new();
+ example.score = Vec::new();
+}
diff --git a/crates/edit_prediction_cli/src/example.rs b/crates/edit_prediction_cli/src/example.rs
index a13b339ae69b9584f3b47186d8b6c36f458a2b76..9499aae0c1ebce7eeca3ef05fedbcf09c960e131 100644
--- a/crates/edit_prediction_cli/src/example.rs
+++ b/crates/edit_prediction_cli/src/example.rs
@@ -1,9 +1,6 @@
-use crate::{
- PredictionProvider, PromptFormat,
- metrics::ClassificationMetrics,
- paths::{REPOS_DIR, WORKTREES_DIR},
-};
+use crate::{PredictionProvider, PromptFormat, metrics::ClassificationMetrics};
use anyhow::{Context as _, Result};
+use collections::HashMap;
use edit_prediction::udiff::OpenedBuffers;
use gpui::Entity;
use http_client::Url;
@@ -25,6 +22,7 @@ pub struct Example {
pub name: String,
pub repository_url: String,
pub revision: String,
+ #[serde(default)]
pub uncommitted_diff: String,
pub cursor_path: Arc,
pub cursor_position: String,
@@ -101,7 +99,7 @@ pub struct ExampleScore {
}
impl Example {
- fn repo_name(&self) -> Result<(Cow<'_, str>, Cow<'_, str>)> {
+ pub fn repo_name(&self) -> Result<(Cow<'_, str>, Cow<'_, str>)> {
// git@github.com:owner/repo.git
if self.repository_url.contains('@') {
let (owner, repo) = self
@@ -133,17 +131,6 @@ impl Example {
Ok((owner.into(), repo.into()))
}
}
-
- pub fn worktree_path(&self) -> PathBuf {
- WORKTREES_DIR
- .join(&self.name)
- .join(self.repo_name().unwrap().1.as_ref())
- }
-
- pub fn repo_path(&self) -> PathBuf {
- let (repo_owner, repo_name) = self.repo_name().expect("failed to get repo name");
- REPOS_DIR.join(repo_owner.as_ref()).join(repo_name.as_ref())
- }
}
pub fn read_examples(inputs: &[PathBuf]) -> Vec {
@@ -195,9 +182,9 @@ pub fn read_examples(inputs: &[PathBuf]) -> Vec {
.enumerate()
.map(|(line_ix, line)| {
let mut example =
- serde_json::from_str::(line).unwrap_or_else(|_| {
+ serde_json::from_str::(line).unwrap_or_else(|error| {
panic!(
- "Failed to parse example on {}:{}",
+ "Failed to parse example on {}:{}\n{error}",
path.display(),
line_ix + 1
)
@@ -217,6 +204,8 @@ pub fn read_examples(inputs: &[PathBuf]) -> Vec {
}
}
}
+
+ sort_examples_by_repo_and_rev(&mut examples);
examples
}
@@ -234,6 +223,25 @@ pub fn write_examples(examples: &[Example], output_path: Option<&PathBuf>) {
}
}
+pub fn sort_examples_by_repo_and_rev(examples: &mut [Example]) {
+ examples.sort_by(|a, b| {
+ a.repository_url
+ .cmp(&b.repository_url)
+ .then(b.revision.cmp(&a.revision))
+ });
+}
+
+pub fn group_examples_by_repo(examples: &mut [Example]) -> Vec> {
+ let mut examples_by_repo = HashMap::default();
+ for example in examples.iter_mut() {
+ examples_by_repo
+ .entry(example.repository_url.clone())
+ .or_insert_with(Vec::new)
+ .push(example);
+ }
+ examples_by_repo.into_values().collect()
+}
+
fn parse_markdown_example(id: String, input: &str) -> Result {
use pulldown_cmark::{CodeBlockKind, CowStr, Event, HeadingLevel, Parser, Tag, TagEnd};
@@ -264,12 +272,12 @@ fn parse_markdown_example(id: String, input: &str) -> Result {
state: None,
};
- let mut name = String::new();
let mut text = String::new();
let mut block_info: CowStr = "".into();
#[derive(PartialEq)]
enum Section {
+ Start,
UncommittedDiff,
EditHistory,
CursorPosition,
@@ -278,14 +286,16 @@ fn parse_markdown_example(id: String, input: &str) -> Result {
Other,
}
- let mut current_section = Section::Other;
+ let mut current_section = Section::Start;
for event in parser {
match event {
Event::Text(line) => {
text.push_str(&line);
- if let Some((field, value)) = line.split_once('=') {
+ if let Section::Start = current_section
+ && let Some((field, value)) = line.split_once('=')
+ {
match field.trim() {
REPOSITORY_URL_FIELD => {
example.repository_url = value.trim().to_string();
@@ -297,14 +307,6 @@ fn parse_markdown_example(id: String, input: &str) -> Result {
}
}
}
- Event::End(TagEnd::Heading(HeadingLevel::H1)) => {
- if !name.is_empty() {
- anyhow::bail!(
- "Found multiple H1 headings. There should only be one with the name of the example."
- );
- }
- name = mem::take(&mut text);
- }
Event::End(TagEnd::Heading(HeadingLevel::H2)) => {
let title = mem::take(&mut text);
current_section = if title.eq_ignore_ascii_case(UNCOMMITTED_DIFF_HEADING) {
@@ -363,7 +365,7 @@ fn parse_markdown_example(id: String, input: &str) -> Result {
Section::ExpectedPatch => {
example.expected_patch = mem::take(&mut text);
}
- Section::Other => {}
+ Section::Start | Section::Other => {}
}
}
_ => {}
diff --git a/crates/edit_prediction_cli/src/format_prompt.rs b/crates/edit_prediction_cli/src/format_prompt.rs
index 53ef6ebfde77dcecba9926062cdfd75c1ee3521c..017e11a54c77e06bde7b74ed3f924692e33cd480 100644
--- a/crates/edit_prediction_cli/src/format_prompt.rs
+++ b/crates/edit_prediction_cli/src/format_prompt.rs
@@ -2,9 +2,14 @@ use crate::{
PromptFormat,
example::{Example, ExamplePrompt},
headless::EpAppState,
+ load_project::run_load_project,
+ progress::{Progress, Step},
retrieve_context::run_context_retrieval,
};
-use edit_prediction::{EditPredictionStore, zeta2::zeta2_prompt_input};
+use edit_prediction::{
+ EditPredictionStore,
+ zeta2::{zeta2_output_for_patch, zeta2_prompt_input},
+};
use gpui::AsyncApp;
use std::sync::Arc;
use zeta_prompt::format_zeta_prompt;
@@ -15,11 +20,22 @@ pub async fn run_format_prompt(
app_state: Arc,
mut cx: AsyncApp,
) {
- run_context_retrieval(example, app_state, cx.clone()).await;
-
- let prompt = match prompt_format {
- PromptFormat::Teacher => TeacherPrompt::format(example),
+ run_context_retrieval(example, app_state.clone(), cx.clone()).await;
+
+ let _step_progress = Progress::global().start(Step::FormatPrompt, &example.name);
+
+ match prompt_format {
+ PromptFormat::Teacher => {
+ let prompt = TeacherPrompt::format_prompt(example);
+ example.prompt = Some(ExamplePrompt {
+ input: prompt,
+ expected_output: example.expected_patch.clone(), // TODO
+ format: prompt_format,
+ });
+ }
PromptFormat::Zeta2 => {
+ run_load_project(example, app_state, cx.clone()).await;
+
let ep_store = cx
.update(|cx| EditPredictionStore::try_global(cx).unwrap())
.unwrap();
@@ -41,30 +57,28 @@ pub async fn run_format_prompt(
)
})
.unwrap();
- format_zeta_prompt(&input)
+ let prompt = format_zeta_prompt(&input);
+ let expected_output = zeta2_output_for_patch(&input, &example.expected_patch.clone());
+ example.prompt = Some(ExamplePrompt {
+ input: prompt,
+ expected_output,
+ format: prompt_format,
+ });
}
};
-
- example.prompt = Some(ExamplePrompt {
- input: prompt,
- expected_output: example.expected_patch.clone(), // TODO
- format: prompt_format,
- });
}
-pub trait PromptFormatter {
- fn format(example: &Example) -> String;
-}
+pub struct TeacherPrompt;
-pub trait PromptParser {
- /// Return unified diff patch of prediction given raw LLM response
- fn parse(example: &Example, response: &str) -> String;
-}
+impl TeacherPrompt {
+ const PROMPT: &str = include_str!("teacher.prompt.md");
+ pub(crate) const EDITABLE_REGION_START: &str = "<|editable_region_start|>\n";
+ pub(crate) const EDITABLE_REGION_END: &str = "<|editable_region_end|>";
-pub struct TeacherPrompt;
+ /// Truncate edit history to this number of last lines
+ const MAX_HISTORY_LINES: usize = 128;
-impl PromptFormatter for TeacherPrompt {
- fn format(example: &Example) -> String {
+ pub fn format_prompt(example: &Example) -> String {
let edit_history = Self::format_edit_history(&example.edit_history);
let context = Self::format_context(example);
let editable_region = Self::format_editable_region(example);
@@ -76,15 +90,46 @@ impl PromptFormatter for TeacherPrompt {
prompt
}
-}
-impl TeacherPrompt {
- const PROMPT: &str = include_str!("teacher.prompt.md");
- pub(crate) const EDITABLE_REGION_START: &str = "<|editable_region_start|>\n";
- pub(crate) const EDITABLE_REGION_END: &str = "<|editable_region_end|>";
+ pub fn parse(example: &Example, response: &str) -> String {
+ // Ideally, we should always be able to find cursor position in the retrieved context.
+ // In reality, sometimes we don't find it for these reasons:
+ // 1. `example.cursor_position` contains _more_ context than included in the retrieved context
+ // (can be fixed by getting cursor coordinates at the load_example stage)
+ // 2. Context retriever just didn't include cursor line.
+ //
+ // In that case, fallback to using `cursor_position` as excerpt.
+ let cursor_file = &example
+ .buffer
+ .as_ref()
+ .expect("`buffer` should be filled in in the context collection step")
+ .content;
- /// Truncate edit history to this number of last lines
- const MAX_HISTORY_LINES: usize = 128;
+ // Extract updated (new) editable region from the model response
+ let new_editable_region = extract_last_codeblock(response);
+
+ // Reconstruct old editable region we sent to the model
+ let old_editable_region = Self::format_editable_region(example);
+ let old_editable_region = Self::extract_editable_region(&old_editable_region);
+ if !cursor_file.contains(&old_editable_region) {
+ panic!("Something's wrong: editable_region is not found in the cursor file")
+ }
+
+ // Apply editable region to a larger context and compute diff.
+ // This is needed to get a better context lines around the editable region
+ let edited_file = cursor_file.replace(&old_editable_region, &new_editable_region);
+ let diff = language::unified_diff(&cursor_file, &edited_file);
+
+ let diff = indoc::formatdoc! {"
+ --- a/{path}
+ +++ b/{path}
+ {diff}",
+ path = example.cursor_path.to_string_lossy(),
+ diff = diff,
+ };
+
+ diff
+ }
fn format_edit_history(edit_history: &str) -> String {
// Strip comments ("garbage lines") from edit history
@@ -157,49 +202,6 @@ impl TeacherPrompt {
}
}
-impl PromptParser for TeacherPrompt {
- fn parse(example: &Example, response: &str) -> String {
- // Ideally, we should always be able to find cursor position in the retrieved context.
- // In reality, sometimes we don't find it for these reasons:
- // 1. `example.cursor_position` contains _more_ context than included in the retrieved context
- // (can be fixed by getting cursor coordinates at the load_example stage)
- // 2. Context retriever just didn't include cursor line.
- //
- // In that case, fallback to using `cursor_position` as excerpt.
- let cursor_file = &example
- .buffer
- .as_ref()
- .expect("`buffer` should be filled in in the context collection step")
- .content;
-
- // Extract updated (new) editable region from the model response
- let new_editable_region = extract_last_codeblock(response);
-
- // Reconstruct old editable region we sent to the model
- let old_editable_region = Self::format_editable_region(example);
- let old_editable_region = Self::extract_editable_region(&old_editable_region);
- if !cursor_file.contains(&old_editable_region) {
- panic!("Something's wrong: editable_region is not found in the cursor file")
- }
-
- // Apply editable region to a larger context and compute diff.
- // This is needed to get a better context lines around the editable region
- let edited_file = cursor_file.replace(&old_editable_region, &new_editable_region);
- let diff = language::unified_diff(&cursor_file, &edited_file);
-
- let diff = indoc::formatdoc! {"
- --- a/{path}
- +++ b/{path}
- {diff}
- ",
- path = example.cursor_path.to_string_lossy(),
- diff = diff,
- };
-
- diff
- }
-}
-
fn extract_last_codeblock(text: &str) -> String {
let mut last_block = None;
let mut search_start = 0;
@@ -221,7 +223,7 @@ fn extract_last_codeblock(text: &str) -> String {
}
if let Some(end_pos) = text[backtick_end..].find(&closing_backticks) {
- let code_block = &text[backtick_end + 1..backtick_end + end_pos - 1];
+ let code_block = &text[backtick_end + 1..backtick_end + end_pos];
last_block = Some(code_block.to_string());
search_start = backtick_end + end_pos + backtick_count;
} else {
@@ -250,7 +252,7 @@ mod tests {
`````
"};
let last_block = extract_last_codeblock(text);
- assert_eq!(last_block, "last block");
+ assert_eq!(last_block, "last block\n");
}
#[test]
diff --git a/crates/edit_prediction_cli/src/headless.rs b/crates/edit_prediction_cli/src/headless.rs
index fd20774168ea3c07f4efffdefe23f1b4ff5f5ef4..2deb96fdbf19a94c5649d87a7bf2f5fea0b601c2 100644
--- a/crates/edit_prediction_cli/src/headless.rs
+++ b/crates/edit_prediction_cli/src/headless.rs
@@ -1,4 +1,5 @@
use client::{Client, ProxySettings, UserStore};
+use collections::HashMap;
use extension::ExtensionHostProxy;
use fs::RealFs;
use gpui::http_client::read_proxy_from_env;
@@ -7,12 +8,13 @@ use gpui_tokio::Tokio;
use language::LanguageRegistry;
use language_extension::LspAccess;
use node_runtime::{NodeBinaryOptions, NodeRuntime};
+use project::Project;
use project::project_settings::ProjectSettings;
use release_channel::{AppCommitSha, AppVersion};
use reqwest_client::ReqwestClient;
use settings::{Settings, SettingsStore};
use std::path::PathBuf;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
use util::ResultExt as _;
/// Headless subset of `workspace::AppState`.
@@ -22,9 +24,22 @@ pub struct EpAppState {
pub user_store: Entity,
pub fs: Arc,
pub node_runtime: NodeRuntime,
+ pub project_cache: ProjectCache,
+}
+
+#[derive(Default)]
+pub struct ProjectCache(Mutex>>);
+
+impl ProjectCache {
+ pub fn insert(&self, repository_url: String, project: Entity) {
+ self.0.lock().unwrap().insert(repository_url, project);
+ }
+
+ pub fn get(&self, repository_url: &String) -> Option> {
+ self.0.lock().unwrap().get(repository_url).cloned()
+ }
}
-// TODO: dedupe with crates/eval/src/eval.rs
pub fn init(cx: &mut App) -> EpAppState {
let app_commit_sha = option_env!("ZED_COMMIT_SHA").map(|s| AppCommitSha::new(s.to_owned()));
@@ -112,11 +127,14 @@ pub fn init(cx: &mut App) -> EpAppState {
prompt_store::init(cx);
terminal_view::init(cx);
+ let project_cache = ProjectCache::default();
+
EpAppState {
languages,
client,
user_store,
fs,
node_runtime,
+ project_cache,
}
}
diff --git a/crates/edit_prediction_cli/src/load_project.rs b/crates/edit_prediction_cli/src/load_project.rs
index 842b63a43335454655ed41ef4d852167e8faf72a..4d98ae9f3b85f4e6253d9ead4d846ed3d9deee89 100644
--- a/crates/edit_prediction_cli/src/load_project.rs
+++ b/crates/edit_prediction_cli/src/load_project.rs
@@ -1,6 +1,8 @@
use crate::{
example::{Example, ExampleBuffer, ExampleState},
headless::EpAppState,
+ paths::{REPOS_DIR, WORKTREES_DIR},
+ progress::{InfoStyle, Progress, Step, StepProgress},
};
use anyhow::{Result, anyhow};
use collections::HashMap;
@@ -11,7 +13,7 @@ use futures::{
lock::{Mutex, OwnedMutexGuard},
};
use gpui::{AsyncApp, Entity};
-use language::{Anchor, Buffer, ToOffset, ToPoint};
+use language::{Anchor, Buffer, LanguageNotFound, ToOffset, ToPoint};
use project::buffer_store::BufferStoreEvent;
use project::{Project, ProjectPath};
use std::{
@@ -28,42 +30,37 @@ pub async fn run_load_project(example: &mut Example, app_state: Arc,
return;
}
- let project = setup_project(example, &app_state, &mut cx).await;
- let buffer_store = project
- .read_with(&cx, |project, _| project.buffer_store().clone())
- .unwrap();
+ let progress = Progress::global().start(Step::LoadProject, &example.name);
- let ep_store = cx
- .update(|cx| EditPredictionStore::try_global(cx).unwrap())
- .unwrap();
-
- cx.subscribe(&buffer_store, {
- let project = project.clone();
- move |_, event, cx| match event {
- BufferStoreEvent::BufferAdded(buffer) => {
- ep_store.update(cx, |store, cx| store.register_buffer(&buffer, &project, cx));
- }
- _ => {}
- }
- })
- .unwrap()
- .detach();
+ let project = setup_project(example, &app_state, &progress, &mut cx).await;
let _open_buffers = apply_edit_history(example, &project, &mut cx)
.await
.unwrap();
+
let (buffer, cursor_position) = cursor_position(example, &project, &mut cx).await;
- example.buffer = buffer
+ let (example_buffer, language_name) = buffer
.read_with(&cx, |buffer, _cx| {
let cursor_point = cursor_position.to_point(&buffer);
- Some(ExampleBuffer {
- content: buffer.text(),
- cursor_row: cursor_point.row,
- cursor_column: cursor_point.column,
- cursor_offset: cursor_position.to_offset(&buffer),
- })
+ let language_name = buffer
+ .language()
+ .map(|l| l.name().to_string())
+ .unwrap_or_else(|| "Unknown".to_string());
+ (
+ ExampleBuffer {
+ content: buffer.text(),
+ cursor_row: cursor_point.row,
+ cursor_column: cursor_point.column,
+ cursor_offset: cursor_position.to_offset(&buffer),
+ },
+ language_name,
+ )
})
.unwrap();
+
+ progress.set_info(language_name, InfoStyle::Normal);
+
+ example.buffer = Some(example_buffer);
example.state = Some(ExampleState {
buffer,
project,
@@ -77,6 +74,19 @@ async fn cursor_position(
project: &Entity,
cx: &mut AsyncApp,
) -> (Entity, Anchor) {
+ let language_registry = project
+ .read_with(cx, |project, _| project.languages().clone())
+ .unwrap();
+ let result = language_registry
+ .load_language_for_file_path(&example.cursor_path)
+ .await;
+
+ if let Err(error) = result
+ && !error.is::()
+ {
+ panic!("Failed to load language for file path: {}", error);
+ }
+
let worktree = project
.read_with(cx, |project, cx| {
project.visible_worktrees(cx).next().unwrap()
@@ -115,7 +125,8 @@ async fn cursor_position(
let mut matches = text.match_indices(&cursor_excerpt);
let (excerpt_offset, _) = matches.next().unwrap_or_else(|| {
panic!(
- "\nExcerpt:\n\n{cursor_excerpt}\nBuffer text:\n{text}\n.Cursor excerpt did not exist in buffer."
+ "\nExcerpt:\n\n{cursor_excerpt}\nBuffer text:\n{text}\n.Example: {}\nCursor excerpt did not exist in buffer.",
+ example.name
);
});
assert!(matches.next().is_none(), "More than one cursor position match found for {}", &example.name);
@@ -133,9 +144,38 @@ async fn cursor_position(
async fn setup_project(
example: &mut Example,
app_state: &Arc,
+ step_progress: &StepProgress,
cx: &mut AsyncApp,
) -> Entity {
- setup_worktree(example).await;
+ let ep_store = cx
+ .update(|cx| EditPredictionStore::try_global(cx).unwrap())
+ .unwrap();
+
+ let worktree_path = setup_worktree(example, step_progress).await;
+
+ if let Some(project) = app_state.project_cache.get(&example.repository_url) {
+ ep_store
+ .update(cx, |ep_store, _| {
+ ep_store.clear_history_for_project(&project);
+ })
+ .unwrap();
+ let buffer_store = project
+ .read_with(cx, |project, _| project.buffer_store().clone())
+ .unwrap();
+ let buffers = buffer_store
+ .read_with(cx, |buffer_store, _| {
+ buffer_store.buffers().collect::>()
+ })
+ .unwrap();
+ for buffer in buffers {
+ buffer
+ .update(cx, |buffer, cx| buffer.reload(cx))
+ .unwrap()
+ .await
+ .ok();
+ }
+ return project;
+ }
let project = cx
.update(|cx| {
@@ -151,27 +191,47 @@ async fn setup_project(
})
.unwrap();
- let worktree = project
+ project
.update(cx, |project, cx| {
- project.create_worktree(&example.worktree_path(), true, cx)
+ project.disable_worktree_scanner(cx);
+ project.create_worktree(&worktree_path, true, cx)
})
.unwrap()
.await
.unwrap();
- worktree
- .read_with(cx, |worktree, _cx| {
- worktree.as_local().unwrap().scan_complete()
- })
- .unwrap()
- .await;
+
+ app_state
+ .project_cache
+ .insert(example.repository_url.clone(), project.clone());
+
+ let buffer_store = project
+ .read_with(cx, |project, _| project.buffer_store().clone())
+ .unwrap();
+ cx.subscribe(&buffer_store, {
+ let project = project.clone();
+ move |_, event, cx| match event {
+ BufferStoreEvent::BufferAdded(buffer) => {
+ ep_store.update(cx, |store, cx| store.register_buffer(&buffer, &project, cx));
+ }
+ _ => {}
+ }
+ })
+ .unwrap()
+ .detach();
+
project
}
-pub async fn setup_worktree(example: &Example) {
- let repo_dir = example.repo_path();
+async fn setup_worktree(example: &Example, step_progress: &StepProgress) -> PathBuf {
+ let (repo_owner, repo_name) = example.repo_name().expect("failed to get repo name");
+ let repo_dir = REPOS_DIR.join(repo_owner.as_ref()).join(repo_name.as_ref());
+ let worktree_path = WORKTREES_DIR
+ .join(repo_owner.as_ref())
+ .join(repo_name.as_ref());
let repo_lock = lock_repo(&repo_dir).await;
if !repo_dir.is_dir() {
+ step_progress.set_substatus(format!("cloning {}", repo_name));
fs::create_dir_all(&repo_dir).unwrap();
run_git(&repo_dir, &["init"]).await.unwrap();
run_git(
@@ -191,6 +251,7 @@ pub async fn setup_worktree(example: &Example) {
let revision = if let Ok(revision) = revision {
revision
} else {
+ step_progress.set_substatus("fetching");
if run_git(
&repo_dir,
&["fetch", "--depth", "1", "origin", &example.revision],
@@ -203,16 +264,11 @@ pub async fn setup_worktree(example: &Example) {
let revision = run_git(&repo_dir, &["rev-parse", "FETCH_HEAD"])
.await
.unwrap();
- if revision != example.revision {
- run_git(&repo_dir, &["tag", &example.revision, &revision])
- .await
- .unwrap();
- }
revision
};
// Create the worktree for this example if needed.
- let worktree_path = example.worktree_path();
+ step_progress.set_substatus("preparing worktree");
if worktree_path.is_dir() {
run_git(&worktree_path, &["clean", "--force", "-d"])
.await
@@ -248,6 +304,7 @@ pub async fn setup_worktree(example: &Example) {
// Apply the uncommitted diff for this example.
if !example.uncommitted_diff.is_empty() {
+ step_progress.set_substatus("applying diff");
let mut apply_process = smol::process::Command::new("git")
.current_dir(&worktree_path)
.args(&["apply", "-"])
@@ -273,6 +330,9 @@ pub async fn setup_worktree(example: &Example) {
);
}
}
+
+ step_progress.clear_substatus();
+ worktree_path
}
async fn apply_edit_history(
diff --git a/crates/edit_prediction_cli/src/main.rs b/crates/edit_prediction_cli/src/main.rs
index 51ea23649d0ec0b124c38ead2897ba16ecd96e26..075f8862e6f86276a0df550c6d27f8c15a5d1293 100644
--- a/crates/edit_prediction_cli/src/main.rs
+++ b/crates/edit_prediction_cli/src/main.rs
@@ -1,4 +1,5 @@
mod anthropic_client;
+mod distill;
mod example;
mod format_prompt;
mod headless;
@@ -6,6 +7,7 @@ mod load_project;
mod metrics;
mod paths;
mod predict;
+mod progress;
mod retrieve_context;
mod score;
@@ -16,10 +18,12 @@ use reqwest_client::ReqwestClient;
use serde::{Deserialize, Serialize};
use std::{path::PathBuf, sync::Arc};
-use crate::example::{read_examples, write_examples};
+use crate::distill::run_distill;
+use crate::example::{group_examples_by_repo, read_examples, write_examples};
use crate::format_prompt::run_format_prompt;
use crate::load_project::run_load_project;
use crate::predict::run_prediction;
+use crate::progress::Progress;
use crate::retrieve_context::run_context_retrieval;
use crate::score::run_scoring;
@@ -28,7 +32,7 @@ use crate::score::run_scoring;
struct EpArgs {
#[arg(long, default_value_t = false)]
printenv: bool,
- #[clap(long, default_value_t = 10)]
+ #[clap(long, default_value_t = 10, global = true)]
max_parallelism: usize,
#[command(subcommand)]
command: Option,
@@ -45,7 +49,7 @@ enum Command {
/// Parse markdown examples and output a combined .jsonl file
ParseExample,
/// Create git worktrees for each example and load file contents
- LoadBuffer,
+ LoadProject,
/// Retrieve context for input examples.
Context,
/// Generate a prompt string for a specific model
@@ -54,6 +58,9 @@ enum Command {
Predict(PredictArgs),
/// Computes a score based on actual and expected patches
Score(PredictArgs),
+ /// Prepares a distillation dataset by copying expected outputs to
+ /// predicted outputs and removing actual outputs and prompts.
+ Distill,
/// Print aggregated scores
Eval(PredictArgs),
/// Remove git repositories and worktrees
@@ -87,6 +94,7 @@ enum PredictionProvider {
Zeta1,
Zeta2,
Teacher,
+ TeacherNonBatching,
}
impl EpArgs {
@@ -104,8 +112,6 @@ impl EpArgs {
}
fn main() {
- zlog::init();
- zlog::init_output_stderr();
let args = EpArgs::parse();
if args.printenv {
@@ -139,27 +145,35 @@ fn main() {
EditPredictionStore::global(&app_state.client, &app_state.user_store, cx);
cx.spawn(async move |cx| {
- match &command {
- Command::Predict(args) => predict::sync_batches(&args.provider).await,
- _ => (),
+ if let Command::Predict(args) = &command {
+ predict::sync_batches(&args.provider).await
};
- for data in examples.chunks_mut(args.max_parallelism) {
- let mut futures = Vec::new();
- for example in data.iter_mut() {
- let cx = cx.clone();
- let app_state = app_state.clone();
- futures.push(async {
+ let total_examples = examples.len();
+ Progress::global().set_total_examples(total_examples);
+
+ let mut grouped_examples = group_examples_by_repo(&mut examples);
+ let example_batches = grouped_examples.chunks_mut(args.max_parallelism);
+
+ for example_batch in example_batches {
+ let futures = example_batch.into_iter().map(|repo_examples| async {
+ for example in repo_examples.iter_mut() {
match &command {
Command::ParseExample => {}
- Command::LoadBuffer => {
- run_load_project(example, app_state.clone(), cx).await;
+ Command::LoadProject => {
+ run_load_project(example, app_state.clone(), cx.clone()).await;
}
Command::Context => {
- run_context_retrieval(example, app_state, cx).await;
+ run_context_retrieval(example, app_state.clone(), cx.clone()).await;
}
Command::FormatPrompt(args) => {
- run_format_prompt(example, args.prompt_format, app_state, cx).await;
+ run_format_prompt(
+ example,
+ args.prompt_format,
+ app_state.clone(),
+ cx.clone(),
+ )
+ .await;
}
Command::Predict(args) => {
run_prediction(
@@ -167,21 +181,25 @@ fn main() {
Some(args.provider),
args.repetitions,
app_state.clone(),
- cx,
+ cx.clone(),
)
.await;
}
+ Command::Distill => {
+ run_distill(example).await;
+ }
Command::Score(args) | Command::Eval(args) => {
- run_scoring(example, &args, app_state, cx).await;
+ run_scoring(example, &args, app_state.clone(), cx.clone()).await;
}
Command::Clean => {
unreachable!()
}
}
- });
- }
+ }
+ });
futures::future::join_all(futures).await;
}
+ Progress::global().clear();
if args.output.is_some() || !matches!(command, Command::Eval(_)) {
write_examples(&examples, output.as_ref());
diff --git a/crates/edit_prediction_cli/src/predict.rs b/crates/edit_prediction_cli/src/predict.rs
index 11ed0e3bab0551d1e9d3e87cc98ef91ee015ac13..3f690266e3165b2d52f642457e7aebf959a40a03 100644
--- a/crates/edit_prediction_cli/src/predict.rs
+++ b/crates/edit_prediction_cli/src/predict.rs
@@ -2,10 +2,11 @@ use crate::{
PredictionProvider, PromptFormat,
anthropic_client::AnthropicClient,
example::{Example, ExamplePrediction},
- format_prompt::{PromptParser, TeacherPrompt, run_format_prompt},
+ format_prompt::{TeacherPrompt, run_format_prompt},
headless::EpAppState,
load_project::run_load_project,
paths::{LATEST_EXAMPLE_RUN_DIR, RUN_DIR},
+ progress::{InfoStyle, Progress, Step},
retrieve_context::run_context_retrieval,
};
use edit_prediction::{DebugEvent, EditPredictionStore};
@@ -30,20 +31,28 @@ pub async fn run_prediction(
return;
}
- run_load_project(example, app_state.clone(), cx.clone()).await;
+ let provider = provider.unwrap();
+
run_context_retrieval(example, app_state.clone(), cx.clone()).await;
- let provider = provider.unwrap();
+ if matches!(
+ provider,
+ PredictionProvider::Teacher | PredictionProvider::TeacherNonBatching
+ ) {
+ let _step_progress = Progress::global().start(Step::Predict, &example.name);
- if matches!(provider, PredictionProvider::Teacher) {
if example.prompt.is_none() {
run_format_prompt(example, PromptFormat::Teacher, app_state.clone(), cx).await;
}
- let batched = true;
+ let batched = matches!(provider, PredictionProvider::Teacher);
return predict_anthropic(example, repetition_count, batched).await;
}
+ run_load_project(example, app_state.clone(), cx.clone()).await;
+
+ let _step_progress = Progress::global().start(Step::Predict, &example.name);
+
if matches!(
provider,
PredictionProvider::Zeta1 | PredictionProvider::Zeta2
@@ -75,7 +84,9 @@ pub async fn run_prediction(
PredictionProvider::Zeta2 => edit_prediction::EditPredictionModel::Zeta2,
PredictionProvider::Sweep => edit_prediction::EditPredictionModel::Sweep,
PredictionProvider::Mercury => edit_prediction::EditPredictionModel::Mercury,
- PredictionProvider::Teacher => unreachable!(),
+ PredictionProvider::Teacher | PredictionProvider::TeacherNonBatching => {
+ unreachable!()
+ }
};
store.set_edit_prediction_model(model);
})
@@ -175,18 +186,31 @@ pub async fn run_prediction(
.await
.unwrap();
+ let actual_patch = prediction
+ .and_then(|prediction| {
+ let prediction = prediction.prediction.ok()?;
+ prediction.edit_preview.as_unified_diff(&prediction.edits)
+ })
+ .unwrap_or_default();
+
+ let has_prediction = !actual_patch.is_empty();
+
updated_example
.lock()
.unwrap()
.predictions
.last_mut()
.unwrap()
- .actual_patch = prediction
- .and_then(|prediction| {
- let prediction = prediction.prediction.ok()?;
- prediction.edit_preview.as_unified_diff(&prediction.edits)
- })
- .unwrap_or_default();
+ .actual_patch = actual_patch;
+
+ if ix == repetition_count - 1 {
+ let (info, style) = if has_prediction {
+ ("predicted", InfoStyle::Normal)
+ } else {
+ ("no prediction", InfoStyle::Warning)
+ };
+ _step_progress.set_info(info, style);
+ }
}
ep_store
diff --git a/crates/edit_prediction_cli/src/progress.rs b/crates/edit_prediction_cli/src/progress.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8195485d70c70c0cbfb38e2de83a055598d5e4e5
--- /dev/null
+++ b/crates/edit_prediction_cli/src/progress.rs
@@ -0,0 +1,474 @@
+use std::{
+ borrow::Cow,
+ collections::HashMap,
+ io::{IsTerminal, Write},
+ sync::{Arc, Mutex, OnceLock},
+ time::{Duration, Instant},
+};
+
+use log::{Level, Log, Metadata, Record};
+
+pub struct Progress {
+ inner: Mutex,
+}
+
+struct ProgressInner {
+ completed: Vec,
+ in_progress: HashMap,
+ is_tty: bool,
+ terminal_width: usize,
+ max_example_name_len: usize,
+ status_lines_displayed: usize,
+ total_examples: usize,
+ last_line_is_logging: bool,
+}
+
+#[derive(Clone)]
+struct InProgressTask {
+ step: Step,
+ started_at: Instant,
+ substatus: Option,
+ info: Option<(String, InfoStyle)>,
+}
+
+struct CompletedTask {
+ step: Step,
+ example_name: String,
+ duration: Duration,
+ info: Option<(String, InfoStyle)>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Step {
+ LoadProject,
+ Context,
+ FormatPrompt,
+ Predict,
+ Score,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum InfoStyle {
+ Normal,
+ Warning,
+}
+
+impl Step {
+ pub fn label(&self) -> &'static str {
+ match self {
+ Step::LoadProject => "Load",
+ Step::Context => "Context",
+ Step::FormatPrompt => "Format",
+ Step::Predict => "Predict",
+ Step::Score => "Score",
+ }
+ }
+
+ fn color_code(&self) -> &'static str {
+ match self {
+ Step::LoadProject => "\x1b[33m",
+ Step::Context => "\x1b[35m",
+ Step::FormatPrompt => "\x1b[34m",
+ Step::Predict => "\x1b[32m",
+ Step::Score => "\x1b[31m",
+ }
+ }
+}
+
+static GLOBAL: OnceLock> = OnceLock::new();
+static LOGGER: ProgressLogger = ProgressLogger;
+
+const RIGHT_MARGIN: usize = 4;
+const MAX_STATUS_LINES: usize = 10;
+
+impl Progress {
+ /// Returns the global Progress instance, initializing it if necessary.
+ pub fn global() -> Arc