Subtract FREE_TIER_MONTHLY_SPENDING_LIMIT from reported monthly spend

.github/actions/check_style/action.yml

@@ -7,3 +7,9 @@ runs:
     - name: cargo fmt
       shell: bash -euxo pipefail {0}
       run: cargo fmt --all -- --check
+
+    - name: Find modified migrations
+      shell: bash -euxo pipefail {0}
+      run: |
+        export SQUAWK_GITHUB_TOKEN=${{ github.token }}
+        . ./script/squawk

.github/workflows/ci.yml

@@ -14,7 +14,6 @@ on:
       - "**"
     paths-ignore:
       - "docs/**"
-      - ".github/workflows/community_*"
 
 concurrency:
   # Allow only one workflow per any non-`main` branch.
@@ -27,10 +26,9 @@ env:
   RUST_BACKTRACE: 1
 
 jobs:
-  migration_checks:
-    name: Check Postgres and Protobuf migrations, mergability
-    if: github.repository_owner == 'zed-industries'
+  style:
     timeout-minutes: 60
+    name: Check formatting and spelling
     runs-on:
       - self-hosted
       - test
@@ -39,16 +37,25 @@ jobs:
         uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
-          fetch-depth: 0 # fetch full history
+          fetch-depth: 0
 
       - name: Remove untracked files
         run: git clean -df
 
-      - name: Find modified migrations
-        shell: bash -euxo pipefail {0}
-        run: |
-          export SQUAWK_GITHUB_TOKEN=${{ github.token }}
-          . ./script/squawk
+      - name: Check spelling
+        run: script/check-spelling
+
+      - name: Run style checks
+        uses: ./.github/actions/check_style
+
+      - name: Check unused dependencies
+        uses: bnjbvr/cargo-machete@main
+
+      - name: Check licenses are present
+        run: script/check-licenses
+
+      - name: Check license generation
+        run: script/generate-licenses /tmp/zed_licenses_output
 
       - name: Ensure fresh merge
         shell: bash -euxo pipefail {0}
@@ -70,24 +77,6 @@ jobs:
           input: "crates/proto/proto/"
           against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/proto/proto/"
 
-  style:
-    timeout-minutes: 60
-    name: Check formatting and spelling
-    if: github.repository_owner == 'zed-industries'
-    runs-on:
-      - buildjet-8vcpu-ubuntu-2204
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
-
-      - name: Run style checks
-        uses: ./.github/actions/check_style
-
-      - name: Check for typos
-        uses: crate-ci/typos@v1.24.6
-        with:
-          config: ./typos.toml
-
   macos_tests:
     timeout-minutes: 60
     name: (macOS) Run Clippy and tests
@@ -103,14 +92,6 @@ jobs:
       - name: cargo clippy
         run: ./script/clippy
 
-      - name: Check unused dependencies
-        uses: bnjbvr/cargo-machete@main
-
-      - name: Check licenses
-        run: |
-          script/check-licenses
-          script/generate-licenses /tmp/zed_licenses_output
-
       - name: Run tests
         uses: ./.github/actions/run_tests
 
@@ -267,20 +248,20 @@ jobs:
           mv target/x86_64-apple-darwin/release/Zed.dmg target/x86_64-apple-darwin/release/Zed-x86_64.dmg
 
       - name: Upload app bundle (universal) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
           path: target/release/Zed.dmg
       - name: Upload app bundle (aarch64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-aarch64.dmg
           path: target/aarch64-apple-darwin/release/Zed-aarch64.dmg
 
       - name: Upload app bundle (x86_64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-x86_64.dmg
@@ -331,7 +312,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-x86_64-unknown-linux-gnu.tar.gz
@@ -378,7 +359,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-aarch64-unknown-linux-gnu.tar.gz

.github/workflows/close_stale_issues.yml

@@ -17,7 +17,7 @@ jobs:
             We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 7 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
 
             Thanks for your help!
-            close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, please open a new issue with a link to this issue."
+          close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, feel free to ping a Zed team member to reopen this issue or open a new one."
           # We will increase `days-before-stale` to 365 on or after Jan 24th,
           # 2024. This date marks one year since migrating issues from
           # 'community' to 'zed' repository. The migration added activity to all

.github/workflows/deploy_cloudflare.yml

@@ -8,7 +8,6 @@ on:
 jobs:
   deploy-docs:
     name: Deploy Docs
-    if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
 
     steps:

.github/workflows/docs.yml

@@ -11,7 +11,6 @@ on:
 jobs:
   check_formatting:
     name: "Check formatting"
-    if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
 
     steps:
@@ -30,8 +29,5 @@ jobs:
             false
           }
 
-      - name: Check for Typos with Typos-CLI
-        uses: crate-ci/typos@v1.24.6
-        with:
-          config: ./typos.toml
-          files: ./docs/
+      - name: Check spelling
+        run: script/check-spelling docs/

Cargo.lock

@@ -412,7 +412,6 @@ dependencies = [
  "parking_lot",
  "paths",
  "picker",
- "pretty_assertions",
  "project",
  "proto",
  "rand 0.8.5",
@@ -8473,7 +8472,6 @@ dependencies = [
  "terminal",
  "text",
  "unindent",
- "url",
  "util",
  "which 6.0.3",
  "windows 0.58.0",
@@ -8975,7 +8973,6 @@ dependencies = [
  "futures 0.3.30",
  "fuzzy",
  "gpui",
- "itertools 0.13.0",
  "language",
  "log",
  "menu",
@@ -9150,8 +9147,6 @@ dependencies = [
  "env_logger",
  "fs",
  "futures 0.3.30",
- "git",
- "git_hosting_providers",
  "gpui",
  "http_client",
  "language",
@@ -9303,7 +9298,6 @@ dependencies = [
  "system-configuration 0.6.1",
  "tokio",
  "tokio-rustls 0.26.0",
- "tokio-socks",
  "tokio-util",
  "tower-service",
  "url",
@@ -12002,7 +11996,6 @@ dependencies = [
  "futures-io",
  "futures-util",
  "thiserror",
- "tokio",
 ]
 
 [[package]]
@@ -14742,7 +14735,7 @@ dependencies = [
 
 [[package]]
 name = "zed_elixir"
-version = "0.1.1"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
@@ -14866,6 +14859,13 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
+[[package]]
+name = "zed_svelte"
+version = "0.2.0"
+dependencies = [
+ "zed_extension_api 0.1.0",
+]
+
 [[package]]
 name = "zed_terraform"
 version = "0.1.1"
@@ -14894,6 +14894,14 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
+[[package]]
+name = "zed_vue"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "zed_extension_api 0.1.0",
+]
+
 [[package]]
 name = "zed_zig"
 version = "0.3.1"

Cargo.toml

@@ -158,10 +158,12 @@ members = [
     "extensions/ruff",
     "extensions/slash-commands-example",
     "extensions/snippets",
+    "extensions/svelte",
     "extensions/terraform",
     "extensions/test-extension",
     "extensions/toml",
     "extensions/uiua",
+    "extensions/vue",
     "extensions/zig",
 
     #
@@ -389,14 +391,7 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
-reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = [
-    "charset",
-    "http2",
-    "macos-system-configuration",
-    "rustls-tls-native-roots",
-    "socks",
-    "stream",
-] }
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = ["charset", "http2", "macos-system-configuration", "rustls-tls-native-roots", "stream"]}
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",

assets/icons/diff.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-diff"><path d="M12 3v14"/><path d="M5 10h14"/><path d="M5 21h14"/></svg>

assets/icons/file_icons/file_types.json

@@ -128,7 +128,6 @@
     "php": "php",
     "plist": "template",
     "png": "image",
-    "postcss": "css",
     "ppt": "document",
     "pptx": "document",
     "prettierignore": "prettier",

assets/keymaps/macos/jetbrains.json

@@ -34,7 +34,7 @@
       "cmd-]": "pane::GoForward",
       "alt-f7": "editor::FindAllReferences",
       "cmd-alt-f7": "editor::FindAllReferences",
-      "cmd-b": "editor::GoToDefinition", // Conflicts with workspace::ToggleLeftDock
+      "cmd-b": "editor::GoToDefinition",
       "cmd-alt-b": "editor::GoToDefinitionSplit",
       "cmd-shift-b": "editor::GoToTypeDefinition",
       "cmd-alt-shift-b": "editor::GoToTypeDefinitionSplit",
@@ -64,8 +64,7 @@
       "cmd-shift-o": "file_finder::Toggle",
       "cmd-shift-a": "command_palette::Toggle",
       "shift shift": "command_palette::Toggle",
-      "cmd-alt-o": "project_symbols::Toggle", // JetBrains: Go to Symbol
-      "cmd-o": "project_symbols::Toggle", // JetBrains: Go to Class
+      "cmd-alt-o": "project_symbols::Toggle",
       "cmd-1": "workspace::ToggleLeftDock",
       "cmd-6": "diagnostics::Deploy"
     }

assets/prompts/edit_workflow.hbs

@@ -1,33 +1,85 @@
 <task_description>
 
-The user of a code editor wants to make a change to their codebase.
-You must describe the change using the following XML structure:
+# Code Change Workflow
 
-- <patch> - A group of related code changes.
-  Child tags:
-    - <title> (required) - A high-level description of the changes. This should be as short
-      as possible, possibly using common abbreviations.
-    - <edit> (1 or more) - An edit to make at a particular range within a file.
-      Includes the following child tags:
-        - <path> (required) - The path to the file that will be changed.
-        - <description> (optional) - An arbitrarily-long comment that describes the purpose
-          of this edit.
-        - <old_text> (optional) - An excerpt from the file's current contents that uniquely
-          identifies a range within the file where the edit should occur. If this tag is not
-          specified, then the entire file will be used as the range.
-        - <new_text> (required) - The new text to insert into the file.
-        - <operation> (required) - The type of change that should occur at the given range
-          of the file. Must be one of the following values:
-            - `update`: Replaces the entire range with the new text.
-            - `insert_before`: Inserts the new text before the range.
-            - `insert_after`: Inserts new text after the range.
-            - `create`: Creates a new file with the given path and the new text.
-            - `delete`: Deletes the specified range from the file.
+Your task is to guide the user through code changes using a series of steps. Each step should describe a high-level change, which can consist of multiple edits to distinct locations in the codebase.
+
+## Output Example
+
+Provide output as XML, with the following format:
+
+<step>
+Update the Person struct to store an age
+
+```rust
+struct Person {
+    // existing fields...
+    age: u8,
+    height: f32,
+    // existing fields...
+}
+
+impl Person {
+    fn age(&self) -> u8 {
+        self.age
+    }
+}
+```
+
+<edit>
+<path>src/person.rs</path>
+<operation>insert_before</operation>
+<search>height: f32,</search>
+<description>Add the age field</description>
+</edit>
+
+<edit>
+<path>src/person.rs</path>
+<operation>insert_after</operation>
+<search>impl Person {</search>
+<description>Add the age getter</description>
+</edit>
+</step>
+
+## Output Format
+
+First, each `<step>` must contain a written description of the change that should be made. The description should begin with a high-level overview, and can contain markdown code blocks as well. The description should be self-contained and actionable.
+
+After the description, each `<step>` must contain one or more `<edit>` tags, each of which refer to a specific range in a source file. Each `<edit>` tag must contain the following child tags:
+
+### `<path>` (required)
+
+This tag contains the path to the file that will be changed. It can be an existing path, or a path that should be created.
+
+### `<search>` (optional)
+
+This tag contains a search string to locate in the source file, e.g. `pub fn baz() {`. If not provided, the new content will be inserted at the top of the file. Make sure to produce a string that exists in the source file and that isn't ambiguous. When there's ambiguity, add more lines to the search to eliminate it.
+
+### `<description>` (required)
+
+This tag contains a single-line description of the edit that should be made at the given location.
+
+### `<operation>` (required)
+
+This tag indicates what type of change should be made, relative to the given location. It can be one of the following:
+- `update`: Rewrites the specified string entirely based on the given description.
+- `create`: Creates a new file with the given path based on the provided description.
+- `insert_before`: Inserts new text based on the given description before the specified search string.
+- `insert_after`: Inserts new text based on the given description after the specified search string.
+- `delete`: Deletes the specified string from the containing file.
 
 <guidelines>
-- Never provide multiple edits whose ranges intersect each other. Instead, merge them into one edit.
-- Prefer multiple edits to smaller, disjoint ranges, rather than one edit to a larger range.
-- There's no need to escape angle brackets within XML tags.
+- There's no need to describe *what* to do, just *where* to do it.
+- Only reference locations that actually exist (unless you're creating a file).
+- If creating a file, assume any subsequent updates are included at the time of creation.
+- Don't create and then update a file. Always create new files in one hot.
+- Prefer multiple edits to smaller regions, as opposed to one big edit to a larger region.
+- Don't produce edits that intersect each other. In that case, merge them into a bigger edit.
+- Never nest an edit with another edit. Never include CDATA. All edits are leaf nodes.
+- Descriptions are required for all edits except delete.
+- When generating multiple edits, ensure the descriptions are specific to each individual operation.
+- Avoid referring to the search string in the description. Focus on the change to be made, not the location where it's made. That's implicit with the `search` string you provide.
+- Don't generate multiple edits at the same location. Instead, combine them together in a single edit with a succinct combined description.
 - Always ensure imports are added if you're referencing symbols that are not in scope.
 </guidelines>
 
@@ -72,137 +124,189 @@ Update all shapes to store their origin as an (x, y) tuple and implement Display
 <message role="assistant">
 We'll need to update both the rectangle and circle modules.
 
-<patch>
-<title>Add origins and display impls to shapes</title>
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<description>Add the origin field to Rectangle struct</description>
-<operation>insert_after</operation>
-<old_text>
-pub struct Rectangle {
-</old_text>
-<new_text>
-origin: (f64, f64),
-</new_text>
-</edit>
+<step>
+Add origin fields to both shape types.
 
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<description>Update the Rectangle's new function to take an origin parameter</description>
-<operation>update</operation>
-<old_text>
-fn new(width: f64, height: f64) -> Self {
-    Rectangle { width, height }
-}
-</old_text>
-<new_text>
-fn new(origin: (f64, f64), width: f64, height: f64) -> Self {
-    Rectangle { origin, width, height }
-}
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/circle.rs</path>
-<description>Add the origin field to Circle struct</description>
-<operation>insert_after</operation>
-<old_text>
-pub struct Circle {
-    radius: f64,
-</old_text>
-<new_text>
+```rust
+struct Rectangle {
+    // existing fields ...
     origin: (f64, f64),
-</new_text>
+}
+```
+
+```rust
+struct Circle {
+    // existing fields ...
+    origin: (f64, f64),
+}
+```
+
+<edit>
+<path>src/shapes/rectangle.rs</path>
+<operation>insert_before</operation>
+<search>
+    width: f64,
+    height: f64,
+</search>
+<description>Add the origin field to Rectangle</description>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
-<description>Update the Circle's new function to take an origin parameter</description>
+<operation>insert_before</operation>
+<search>
+    radius: f64,
+</search>
+<description>Add the origin field to Circle</description>
+</edit>
+
+<step>
+Update both shape's constructors to take an origin.
+
+<edit>
+<path>src/shapes/rectangle.rs</path>
 <operation>update</operation>
-<old_text>
-fn new(radius: f64) -> Self {
-    Circle { radius }
-}
-</old_text>
-<new_text>
-fn new(origin: (f64, f64), radius: f64) -> Self {
-    Circle { origin, radius }
-}
-</new_text>
+<search>
+    fn new(width: f64, height: f64) -> Self {
+        Rectangle { width, height }
+    }
+</search>
+<description>Update the Rectangle new function to take an origin</description>
+</edit>
+
+<edit>
+<path>src/shapes/circle.rs</path>
+<operation>update</operation>
+<search>
+    fn new(radius: f64) -> Self {
+        Circle { radius }
+    }
+</search>
+<description>Update the Circle new function to take an origin</description>
 </edit>
 </step>
 
+<step>
+Implement Display for both shapes
+
 <edit>
 <path>src/shapes/rectangle.rs</path>
-<description>Add an import for the std::fmt module</description>
 <operation>insert_before</operation>
-<old_text>
+<search>
 struct Rectangle {
-</old_text>
-<new_text>
-use std::fmt;
-
-</new_text>
+</search>
+<description>Add an import for the `std::fmt` module</description>
 </edit>
 
 <edit>
 <path>src/shapes/rectangle.rs</path>
-<description>Add a Display implementation for Rectangle</description>
 <operation>insert_after</operation>
-<old_text>
+<search>
         Rectangle { width, height }
     }
 }
-</old_text>
-<new_text>
-impl fmt::Display for Rectangle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.format_struct(f, "Rectangle")
-            .field("origin", &self.origin)
-            .field("width", &self.width)
-            .field("height", &self.height)
-            .finish()
-    }
-}
-</new_text>
+</search>
+<description>Add a Display implementation for Rectangle</description>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
-<description>Add an import for the `std::fmt` module</description>
 <operation>insert_before</operation>
-<old_text>
+<search>
 struct Circle {
-</old_text>
-<new_text>
-use std::fmt;
-</new_text>
+</search>
+<description>Add an import for the `std::fmt` module</description>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
-<description>Add a Display implementation for Circle</description>
 <operation>insert_after</operation>
-<old_text>
+<search>
         Circle { radius }
     }
 }
-</old_text>
-<new_text>
-impl fmt::Display for Rectangle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.format_struct(f, "Rectangle")
-            .field("origin", &self.origin)
-            .field("width", &self.width)
-            .field("height", &self.height)
-            .finish()
-    }
-}
-</new_text>
+</search>
+<description>Add a Display implementation for Circle</description>
 </edit>
-</patch>
-
+</step>
 </message>
 </example>
 
+<example number=2>
+<message role="user">
+
+```rs src/user.rs
+struct User {
+    pub name: String,
+    age: u32,
+    email: String,
+}
+
+impl User {
+    fn new(name: String, age: u32, email: String) -> Self {
+        User { name, age, email }
+    }
+
+    pub fn print_info(&self) {
+        todo!()
+    }
+}
+```
+
+Let's print all the user information and delete the email field.
+</message>
+
+<message role="assistant">
+<step>
+Update the 'print_info' method to print user information
+
+```rust
+impl User {
+    // ... other methods ...
+
+    pub fn print_info(&self) {
+        println!("Name: {name}, Age: {age}", name = self.name, age = self.age);
+    }
+}
+```
+
+<edit>
+<path>src/user.rs</path>
+<operation>update</operation>
+<search>
+    pub fn print_info(&self) {
+        todo!()
+    }
+</search>
+<description>Print all the user information</description>
+</edit>
+</step>
+
+<step>
+Remove the 'email' field from the User struct
+
+<edit>
+<path>src/user.rs</path>
+<operation>delete</operation>
+<search>
+email: String,
+</search>
+</edit>
+
+<edit>
+<path>src/user.rs</path>
+<operation>update</operation>
+<symbol>
+fn new(name: String, age: u32, email: String) -> Self {
+    User { name, age, email }
+}
+</symbol>
+<description>Remove email parameter from new method</description>
+</edit>
+</step>
+</message>
+</example>
+
+You should think step by step. When possible, produce smaller, coherent logical steps as opposed to one big step that combines lots of heterogeneous edits.
+
 </task_description>

assets/prompts/step_resolution.hbs

@@ -0,0 +1,496 @@
+<overview>
+Your task is to map a step from a workflow to locations in source code where code needs to be changed to fulfill that step.
+Given a workflow containing background context plus a series of <step> tags, you will resolve *one* of these step tags to resolve to one or more locations in the code.
+With each location, you will produce a brief, one-line description of the changes to be made.
+
+<guidelines>
+- There's no need to describe *what* to do, just *where* to do it.
+- Only reference locations that actually exist (unless you're creating a file).
+- If creating a file, assume any subsequent updates are included at the time of creation.
+- Don't create and then update a file. Always create new files in shot.
+- Prefer updating symbols lower in the syntax tree if possible.
+- Never include suggestions on a parent symbol and one of its children in the same suggestions block.
+- Never nest an operation with another operation or include CDATA or other content. All suggestions are leaf nodes.
+- Descriptions are required for all suggestions except delete.
+- When generating multiple suggestions, ensure the descriptions are specific to each individual operation.
+- Avoid referring to the location in the description. Focus on the change to be made, not the location where it's made. That's implicit with the symbol you provide.
+- Don't generate multiple suggestions at the same location. Instead, combine them together in a single operation with a succinct combined description.
+- To add imports respond with a suggestion where the `"symbol"` key is set to `"#imports"`
+</guidelines>
+</overview>
+
+<examples>
+<example>
+<workflow_context>
+<message role="user">
+```rs src/rectangle.rs
+struct Rectangle {
+    width: f64,
+    height: f64,
+}
+
+impl Rectangle {
+    fn new(width: f64, height: f64) -> Self {
+        Rectangle { width, height }
+    }
+}
+```
+
+We need to add methods to calculate the area and perimeter of the rectangle. Can you help with that?
+</message>
+<message role="assistant">
+Sure, I can help with that!
+
+<step>Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle struct</step>
+<step>Implement the 'Display' trait for the Rectangle struct</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle struct
+</step_to_resolve>
+
+<incorrect_output reason="NEVER append multiple children at the same location.">
+{
+  "title": "Add Rectangle methods",
+  "suggestions": [
+    {
+      "kind": "AppendChild",
+      "path": "src/shapes.rs",
+      "symbol": "impl Rectangle",
+      "description": "Add calculate_area method"
+    },
+    {
+      "kind": "AppendChild",
+      "path": "src/shapes.rs",
+      "symbol": "impl Rectangle",
+      "description": "Add calculate_perimeter method"
+    }
+  ]
+}
+</incorrect_output>
+
+<correct_output>
+{
+  "title": "Add Rectangle methods",
+  "suggestions": [
+    {
+      "kind": "AppendChild",
+      "path": "src/shapes.rs",
+      "symbol": "impl Rectangle",
+      "description": "Add calculate area and perimeter methods"
+    }
+  ]
+}
+</correct_output>
+
+<step_to_resolve>
+Implement the 'Display' trait for the Rectangle struct
+</step_to_resolve>
+
+<output>
+{
+  "title": "Implement Display for Rectangle",
+  "suggestions": [
+    {
+      "kind": "InsertSiblingAfter",
+      "path": "src/shapes.rs",
+      "symbol": "impl Rectangle",
+      "description": "Implement Display trait for Rectangle"
+    }
+  ]
+}
+</output>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/user.rs
+struct User {
+    pub name: String,
+    age: u32,
+    email: String,
+}
+
+impl User {
+    fn new(name: String, age: u32, email: String) -> Self {
+        User { name, age, email }
+    }
+
+    pub fn print_info(&self) {
+        println!("Name: {}, Age: {}, Email: {}", self.name, self.age, self.email);
+    }
+}
+```
+</message>
+<message role="assistant">
+Certainly!
+<step>Update the 'print_info' method to use formatted output</step>
+<step>Remove the 'email' field from the User struct</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Update the 'print_info' method to use formatted output
+</step_to_resolve>
+
+<output>
+{
+  "title": "Use formatted output",
+  "suggestions": [
+    {
+      "kind": "Update",
+      "path": "src/user.rs",
+      "symbol": "impl User pub fn print_info",
+      "description": "Use formatted output"
+    }
+  ]
+}
+</output>
+
+<step_to_resolve>
+Remove the 'email' field from the User struct
+</step_to_resolve>
+
+<output>
+{
+  "title": "Remove email field",
+  "suggestions": [
+      {
+        "kind": "Delete",
+        "path": "src/user.rs",
+        "symbol": "struct User email"
+      }
+    ]
+}
+</output>
+</example>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/vehicle.rs
+struct Vehicle {
+    make: String,
+    model: String,
+    year: u32,
+}
+
+impl Vehicle {
+    fn new(make: String, model: String, year: u32) -> Self {
+        Vehicle { make, model, year }
+    }
+
+    fn print_year(&self) {
+        println!("Year: {}", self.year);
+    }
+}
+```
+</message>
+<message role="assistant">
+<step>Add a 'use std::fmt;' statement at the beginning of the file</step>
+<step>Add a new method 'start_engine' in the Vehicle impl block</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Add a 'use std::fmt;' statement at the beginning of the file
+</step_to_resolve>
+
+<output>
+{
+  "title": "Add use std::fmt statement",
+  "suggestions": [
+    {
+      "kind": "PrependChild",
+      "path": "src/vehicle.rs",
+      "symbol": "#imports",
+      "description": "Add 'use std::fmt' statement"
+    }
+  ]
+}
+</output>
+
+<step_to_resolve>
+Add a new method 'start_engine' in the Vehicle impl block
+</step_to_resolve>
+
+<output>
+{
+  "title": "Add start_engine method",
+  "suggestions": [
+    {
+      "kind": "InsertSiblingAfter",
+      "path": "src/vehicle.rs",
+      "symbol": "impl Vehicle fn new",
+      "description": "Add start_engine method"
+    }
+  ]
+}
+</output>
+</example>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/employee.rs
+struct Employee {
+    name: String,
+    position: String,
+    salary: u32,
+    department: String,
+}
+
+impl Employee {
+    fn new(name: String, position: String, salary: u32, department: String) -> Self {
+        Employee { name, position, salary, department }
+    }
+
+    fn print_details(&self) {
+        println!("Name: {}, Position: {}, Salary: {}, Department: {}",
+                  self.name, self.position, self.salary, self.department);
+    }
+
+    fn give_raise(&mut self, amount: u32) {
+        self.salary += amount;
+    }
+}
+```
+</message>
+<message role="assistant">
+<step>Make salary an f32</step>
+<step>Remove the 'department' field and update the 'print_details' method</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Make salary an f32
+</step_to_resolve>
+
+<incorrect_output reason="NEVER include suggestions on a parent symbol and one of its children in the same suggestions block.">
+{
+  "title": "Change salary to f32",
+  "suggestions": [
+    {
+      "kind": "Update",
+      "path": "src/employee.rs",
+      "symbol": "struct Employee",
+      "description": "Change the type of salary to an f32"
+    },
+    {
+      "kind": "Update",
+      "path": "src/employee.rs",
+      "symbol": "struct Employee salary",
+      "description": "Change the type to an f32"
+    }
+  ]
+}
+</incorrect_output>
+
+<correct_output>
+{
+  "title": "Change salary to f32",
+  "suggestions": [
+    {
+      "kind": "Update",
+      "path": "src/employee.rs",
+      "symbol": "struct Employee salary",
+      "description": "Change the type to an f32"
+    }
+  ]
+}
+</correct_output>
+
+<step_to_resolve>
+Remove the 'department' field and update the 'print_details' method
+</step_to_resolve>
+
+<output>
+{
+  "title": "Remove department",
+  "suggestions": [
+    {
+      "kind": "Delete",
+      "path": "src/employee.rs",
+      "symbol": "struct Employee department"
+    },
+    {
+      "kind": "Update",
+      "path": "src/employee.rs",
+      "symbol": "impl Employee fn print_details",
+      "description": "Don't print the 'department' field"
+    }
+  ]
+}
+</output>
+</example>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/game.rs
+struct Player {
+    name: String,
+    health: i32,
+    pub score: u32,
+}
+
+impl Player {
+    pub fn new(name: String) -> Self {
+        Player { name, health: 100, score: 0 }
+    }
+}
+
+struct Game {
+    players: Vec<Player>,
+}
+
+impl Game {
+    fn new() -> Self {
+        Game { players: Vec::new() }
+    }
+}
+```
+</message>
+<message role="assistant">
+<step>Add a 'level' field to Player and update the 'new' method</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Add a 'level' field to Player and update the 'new' method
+</step_to_resolve>
+
+<output>
+{
+  "title": "Add level field to Player",
+  "suggestions": [
+    {
+      "kind": "InsertSiblingAfter",
+      "path": "src/game.rs",
+      "symbol": "struct Player pub score",
+      "description": "Add level field to Player"
+    },
+    {
+      "kind": "Update",
+      "path": "src/game.rs",
+      "symbol": "impl Player pub fn new",
+      "description": "Initialize level in new method"
+    }
+  ]
+}
+</output>
+</example>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/config.rs
+use std::collections::HashMap;
+
+struct Config {
+    settings: HashMap<String, String>,
+}
+
+impl Config {
+    fn new() -> Self {
+        Config { settings: HashMap::new() }
+    }
+}
+```
+</message>
+<message role="assistant">
+<step>Add a 'load_from_file' method to Config and import necessary modules</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Add a 'load_from_file' method to Config and import necessary modules
+</step_to_resolve>
+
+<output>
+{
+  "title": "Add load_from_file method",
+  "suggestions": [
+    {
+      "kind": "PrependChild",
+      "path": "src/config.rs",
+      "symbol": "#imports",
+      "description": "Import std::fs and std::io modules"
+    },
+    {
+      "kind": "AppendChild",
+      "path": "src/config.rs",
+      "symbol": "impl Config",
+      "description": "Add load_from_file method"
+    }
+  ]
+}
+</output>
+</example>
+
+<example>
+<workflow_context>
+<message role="user">
+```rs src/database.rs
+pub(crate) struct Database {
+    connection: Connection,
+}
+
+impl Database {
+    fn new(url: &str) -> Result<Self, Error> {
+        let connection = Connection::connect(url)?;
+        Ok(Database { connection })
+    }
+
+    async fn query(&self, sql: &str) -> Result<Vec<Row>, Error> {
+        self.connection.query(sql, &[])
+    }
+}
+```
+</message>
+<message role="assistant">
+<step>Add error handling to the 'query' method and create a custom error type</step>
+</message>
+</workflow_context>
+
+<step_to_resolve>
+Add error handling to the 'query' method and create a custom error type
+</step_to_resolve>
+
+<output>
+{
+  "title": "Add error handling to query",
+  "suggestions": [
+    {
+      "kind": "PrependChild",
+      "path": "src/database.rs",
+      "description": "Import necessary error handling modules"
+    },
+    {
+      "kind": "InsertSiblingBefore",
+      "path": "src/database.rs",
+      "symbol": "pub(crate) struct Database",
+      "description": "Define custom DatabaseError enum"
+    },
+    {
+      "kind": "Update",
+      "path": "src/database.rs",
+      "symbol": "impl Database async fn query",
+      "description": "Implement error handling in query method"
+    }
+  ]
+}
+</output>
+</example>
+</examples>
+
+Now generate the suggestions for the following step:
+
+<workflow_context>
+{{{workflow_context}}}
+</workflow_context>
+
+<step_to_resolve>
+{{{step_to_resolve}}}
+</step_to_resolve>

assets/settings/default.json

@@ -712,10 +712,10 @@
     // May take 2 values:
     //  1. Rely on default platform handling of option key, on macOS
     //     this means generating certain unicode characters
-    //         "option_as_meta": false,
+    //         "option_to_meta": false,
     //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
-    //         "option_as_meta": true,
-    "option_as_meta": false,
+    //         "option_to_meta": true,
+    "option_as_meta": true,
     // Whether or not selecting text in the terminal will automatically
     // copy to the system clipboard.
     "copy_on_select": false,

crates/assistant/Cargo.toml

@@ -97,7 +97,6 @@ language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
 languages = { workspace = true, features = ["test-support"] }
 log.workspace = true
-pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
 serde_json_lenient.workspace = true

crates/assistant/src/assistant.rs

@@ -6,7 +6,6 @@ mod context;
 pub mod context_store;
 mod inline_assistant;
 mod model_selector;
-mod patch;
 mod prompt_library;
 mod prompts;
 mod slash_command;
@@ -15,6 +14,7 @@ pub mod slash_command_settings;
 mod streaming_diff;
 mod terminal_inline_assistant;
 mod tools;
+mod workflow;
 
 pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
 use assistant_settings::AssistantSettings;
@@ -35,13 +35,11 @@ use language_model::{
     LanguageModelId, LanguageModelProviderId, LanguageModelRegistry, LanguageModelResponseMessage,
 };
 pub(crate) use model_selector::*;
-pub use patch::*;
 pub use prompts::PromptBuilder;
 use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
-use slash_command::workflow_command::WorkflowSlashCommand;
 use slash_command::{
     auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
     diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
@@ -52,6 +50,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;
+pub use workflow::*;
 
 use crate::slash_command_settings::SlashCommandSettings;
 
@@ -394,25 +393,12 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     slash_command_registry.register_command(now_command::NowSlashCommand, false);
     slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
-    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
     if let Some(prompt_builder) = prompt_builder {
-        cx.observe_global::<SettingsStore>({
-            let slash_command_registry = slash_command_registry.clone();
-            let prompt_builder = prompt_builder.clone();
-            move |cx| {
-                if AssistantSettings::get_global(cx).are_live_diffs_enabled(cx) {
-                    slash_command_registry.register_command(
-                        workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
-                        true,
-                    );
-                } else {
-                    slash_command_registry.unregister_command_by_name(WorkflowSlashCommand::NAME);
-                }
-            }
-        })
-        .detach();
-
+        slash_command_registry.register_command(
+            workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
+            true,
+        );
         cx.observe_flag::<project_command::ProjectSlashCommandFeatureFlag, _>({
             let slash_command_registry = slash_command_registry.clone();
             move |is_enabled, _cx| {

crates/assistant/src/assistant_settings.rs

@@ -2,7 +2,6 @@ use std::sync::Arc;
 
 use ::open_ai::Model as OpenAiModel;
 use anthropic::Model as AnthropicModel;
-use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
 use gpui::{AppContext, Pixels};
 use language_model::provider::open_ai;
@@ -62,13 +61,6 @@ pub struct AssistantSettings {
     pub default_model: LanguageModelSelection,
     pub inline_alternatives: Vec<LanguageModelSelection>,
     pub using_outdated_settings_version: bool,
-    pub enable_experimental_live_diffs: bool,
-}
-
-impl AssistantSettings {
-    pub fn are_live_diffs_enabled(&self, cx: &AppContext) -> bool {
-        cx.is_staff() || self.enable_experimental_live_diffs
-    }
 }
 
 /// Assistant panel settings
@@ -246,7 +238,6 @@ impl AssistantSettingsContent {
                             }
                         }),
                     inline_alternatives: None,
-                    enable_experimental_live_diffs: None,
                 },
                 VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
             },
@@ -266,7 +257,6 @@ impl AssistantSettingsContent {
                         .to_string(),
                 }),
                 inline_alternatives: None,
-                enable_experimental_live_diffs: None,
             },
         }
     }
@@ -383,7 +373,6 @@ impl Default for VersionedAssistantSettingsContent {
             default_height: None,
             default_model: None,
             inline_alternatives: None,
-            enable_experimental_live_diffs: None,
         })
     }
 }
@@ -414,10 +403,6 @@ pub struct AssistantSettingsContentV2 {
     default_model: Option<LanguageModelSelection>,
     /// Additional models with which to generate alternatives when performing inline assists.
     inline_alternatives: Option<Vec<LanguageModelSelection>>,
-    /// Enable experimental live diffs in the assistant panel.
-    ///
-    /// Default: false
-    enable_experimental_live_diffs: Option<bool>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
@@ -540,10 +525,7 @@ impl Settings for AssistantSettings {
             );
             merge(&mut settings.default_model, value.default_model);
             merge(&mut settings.inline_alternatives, value.inline_alternatives);
-            merge(
-                &mut settings.enable_experimental_live_diffs,
-                value.enable_experimental_live_diffs,
-            );
+            // merge(&mut settings.infer_context, value.infer_context); TODO re-enable this once we ship context inference
         }
 
         Ok(settings)
@@ -602,7 +584,6 @@ mod tests {
                             dock: None,
                             default_width: None,
                             default_height: None,
-                            enable_experimental_live_diffs: None,
                         }),
                     )
                 },

crates/assistant/src/context.rs

@@ -2,8 +2,8 @@
 mod context_tests;
 
 use crate::{
-    prompts::PromptBuilder, slash_command::SlashCommandLine, AssistantEdit, AssistantPatch,
-    AssistantPatchStatus, MessageId, MessageStatus,
+    prompts::PromptBuilder, slash_command::SlashCommandLine, MessageId, MessageStatus,
+    WorkflowStep, WorkflowStepEdit, WorkflowStepResolution, WorkflowSuggestionGroup,
 };
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{
@@ -15,10 +15,13 @@ use clock::ReplicaId;
 use collections::{HashMap, HashSet};
 use feature_flags::{FeatureFlag, FeatureFlagAppExt};
 use fs::{Fs, RemoveOptions};
-use futures::{future::Shared, FutureExt, StreamExt};
+use futures::{
+    future::{self, Shared},
+    FutureExt, StreamExt,
+};
 use gpui::{
-    AppContext, Context as _, EventEmitter, Model, ModelContext, RenderImage, SharedString,
-    Subscription, Task,
+    AppContext, AsyncAppContext, Context as _, EventEmitter, Model, ModelContext, RenderImage,
+    SharedString, Subscription, Task,
 };
 
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
@@ -35,7 +38,7 @@ use project::Project;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::{
-    cmp::{max, Ordering},
+    cmp::{self, max, Ordering},
     fmt::Debug,
     iter, mem,
     ops::Range,
@@ -297,7 +300,7 @@ pub enum ContextEvent {
     MessagesEdited,
     SummaryChanged,
     StreamedCompletion,
-    PatchesUpdated {
+    WorkflowStepsUpdated {
         removed: Vec<Range<language::Anchor>>,
         updated: Vec<Range<language::Anchor>>,
     },
@@ -451,14 +454,13 @@ pub struct XmlTag {
 #[derive(Copy, Clone, Debug, strum::EnumString, PartialEq, Eq, strum::AsRefStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum XmlTagKind {
-    Patch,
-    Title,
+    Step,
     Edit,
     Path,
-    Description,
-    OldText,
-    NewText,
+    Search,
+    Within,
     Operation,
+    Description,
 }
 
 pub struct Context {
@@ -488,7 +490,7 @@ pub struct Context {
     _subscriptions: Vec<Subscription>,
     telemetry: Option<Arc<Telemetry>>,
     language_registry: Arc<LanguageRegistry>,
-    patches: Vec<AssistantPatch>,
+    workflow_steps: Vec<WorkflowStep>,
     xml_tags: Vec<XmlTag>,
     project: Option<Model<Project>>,
     prompt_builder: Arc<PromptBuilder>,
@@ -504,7 +506,7 @@ impl ContextAnnotation for PendingSlashCommand {
     }
 }
 
-impl ContextAnnotation for AssistantPatch {
+impl ContextAnnotation for WorkflowStep {
     fn range(&self) -> &Range<language::Anchor> {
         &self.range
     }
@@ -589,7 +591,7 @@ impl Context {
             telemetry,
             project,
             language_registry,
-            patches: Vec::new(),
+            workflow_steps: Vec::new(),
             xml_tags: Vec::new(),
             prompt_builder,
         };
@@ -927,49 +929,48 @@ impl Context {
         self.summary.as_ref()
     }
 
-    pub(crate) fn patch_containing(
+    pub(crate) fn workflow_step_containing(
         &self,
-        position: Point,
+        offset: usize,
         cx: &AppContext,
-    ) -> Option<&AssistantPatch> {
+    ) -> Option<&WorkflowStep> {
         let buffer = self.buffer.read(cx);
-        let index = self.patches.binary_search_by(|patch| {
-            let patch_range = patch.range.to_point(&buffer);
-            if position < patch_range.start {
-                Ordering::Greater
-            } else if position > patch_range.end {
-                Ordering::Less
-            } else {
-                Ordering::Equal
-            }
-        });
-        if let Ok(ix) = index {
-            Some(&self.patches[ix])
-        } else {
-            None
-        }
+        let index = self
+            .workflow_steps
+            .binary_search_by(|step| {
+                let step_range = step.range.to_offset(&buffer);
+                if offset < step_range.start {
+                    Ordering::Greater
+                } else if offset > step_range.end {
+                    Ordering::Less
+                } else {
+                    Ordering::Equal
+                }
+            })
+            .ok()?;
+        Some(&self.workflow_steps[index])
     }
 
-    pub fn patch_ranges(&self) -> impl Iterator<Item = Range<language::Anchor>> + '_ {
-        self.patches.iter().map(|patch| patch.range.clone())
+    pub fn workflow_step_ranges(&self) -> impl Iterator<Item = Range<language::Anchor>> + '_ {
+        self.workflow_steps.iter().map(|step| step.range.clone())
     }
 
-    pub(crate) fn patch_for_range(
+    pub(crate) fn workflow_step_for_range(
         &self,
         range: &Range<language::Anchor>,
         cx: &AppContext,
-    ) -> Option<&AssistantPatch> {
+    ) -> Option<&WorkflowStep> {
         let buffer = self.buffer.read(cx);
-        let index = self.patch_index_for_range(range, buffer).ok()?;
-        Some(&self.patches[index])
+        let index = self.workflow_step_index_for_range(range, buffer).ok()?;
+        Some(&self.workflow_steps[index])
     }
 
-    fn patch_index_for_range(
+    fn workflow_step_index_for_range(
         &self,
         tagged_range: &Range<text::Anchor>,
         buffer: &text::BufferSnapshot,
     ) -> Result<usize, usize> {
-        self.patches
+        self.workflow_steps
             .binary_search_by(|probe| probe.range.cmp(&tagged_range, buffer))
     }
 
@@ -1017,6 +1018,8 @@ impl Context {
             language::BufferEvent::Edited => {
                 self.count_remaining_tokens(cx);
                 self.reparse(cx);
+                // Use `inclusive = true` to invalidate a step when an edit occurs
+                // at the start/end of a parsed step.
                 cx.emit(ContextEvent::MessagesEdited);
             }
             _ => {}
@@ -1245,8 +1248,8 @@ impl Context {
 
         let mut removed_slash_command_ranges = Vec::new();
         let mut updated_slash_commands = Vec::new();
-        let mut removed_patches = Vec::new();
-        let mut updated_patches = Vec::new();
+        let mut removed_steps = Vec::new();
+        let mut updated_steps = Vec::new();
         while let Some(mut row_range) = row_ranges.next() {
             while let Some(next_row_range) = row_ranges.peek() {
                 if row_range.end >= next_row_range.start {
@@ -1270,11 +1273,11 @@ impl Context {
                 &mut removed_slash_command_ranges,
                 cx,
             );
-            self.reparse_patches_in_range(
+            self.reparse_workflow_steps_in_range(
                 start..end,
                 &buffer,
-                &mut updated_patches,
-                &mut removed_patches,
+                &mut updated_steps,
+                &mut removed_steps,
                 cx,
             );
         }
@@ -1286,10 +1289,10 @@ impl Context {
             });
         }
 
-        if !updated_patches.is_empty() || !removed_patches.is_empty() {
-            cx.emit(ContextEvent::PatchesUpdated {
-                removed: removed_patches,
-                updated: updated_patches,
+        if !updated_steps.is_empty() || !removed_steps.is_empty() {
+            cx.emit(ContextEvent::WorkflowStepsUpdated {
+                removed: removed_steps,
+                updated: updated_steps,
             });
         }
     }
@@ -1351,7 +1354,7 @@ impl Context {
         removed.extend(removed_commands.map(|command| command.source_range));
     }
 
-    fn reparse_patches_in_range(
+    fn reparse_workflow_steps_in_range(
         &mut self,
         range: Range<text::Anchor>,
         buffer: &BufferSnapshot,
@@ -1366,32 +1369,41 @@ impl Context {
         self.xml_tags
             .splice(intersecting_tags_range.clone(), new_tags);
 
-        // Find which patches intersect the changed range.
-        let intersecting_patches_range =
-            self.indices_intersecting_buffer_range(&self.patches, range.clone(), cx);
+        // Find which steps intersect the changed range.
+        let intersecting_steps_range =
+            self.indices_intersecting_buffer_range(&self.workflow_steps, range.clone(), cx);
 
-        // Reparse all tags after the last unchanged patch before the change.
+        // Reparse all tags after the last unchanged step before the change.
         let mut tags_start_ix = 0;
-        if let Some(preceding_unchanged_patch) =
-            self.patches[..intersecting_patches_range.start].last()
+        if let Some(preceding_unchanged_step) =
+            self.workflow_steps[..intersecting_steps_range.start].last()
         {
             tags_start_ix = match self.xml_tags.binary_search_by(|tag| {
                 tag.range
                     .start
-                    .cmp(&preceding_unchanged_patch.range.end, buffer)
+                    .cmp(&preceding_unchanged_step.range.end, buffer)
                     .then(Ordering::Less)
             }) {
                 Ok(ix) | Err(ix) => ix,
             };
         }
 
-        // Rebuild the patches in the range.
-        let new_patches = self.parse_patches(tags_start_ix, range.end, buffer, cx);
-        updated.extend(new_patches.iter().map(|patch| patch.range.clone()));
-        let removed_patches = self.patches.splice(intersecting_patches_range, new_patches);
+        // Rebuild the edit suggestions in the range.
+        let mut new_steps = self.parse_steps(tags_start_ix, range.end, buffer);
+
+        if let Some(project) = self.project() {
+            for step in &mut new_steps {
+                Self::resolve_workflow_step_internal(step, &project, cx);
+            }
+        }
+
+        updated.extend(new_steps.iter().map(|step| step.range.clone()));
+        let removed_steps = self
+            .workflow_steps
+            .splice(intersecting_steps_range, new_steps);
         removed.extend(
-            removed_patches
-                .map(|patch| patch.range)
+            removed_steps
+                .map(|step| step.range)
                 .filter(|range| !updated.contains(&range)),
         );
     }
@@ -1452,95 +1464,60 @@ impl Context {
         tags
     }
 
-    fn parse_patches(
+    fn parse_steps(
         &mut self,
         tags_start_ix: usize,
         buffer_end: text::Anchor,
         buffer: &BufferSnapshot,
-        cx: &AppContext,
-    ) -> Vec<AssistantPatch> {
-        let mut new_patches = Vec::new();
-        let mut pending_patch = None;
-        let mut patch_tag_depth = 0;
+    ) -> Vec<WorkflowStep> {
+        let mut new_steps = Vec::new();
+        let mut pending_step = None;
+        let mut edit_step_depth = 0;
         let mut tags = self.xml_tags[tags_start_ix..].iter().peekable();
         'tags: while let Some(tag) = tags.next() {
-            if tag.range.start.cmp(&buffer_end, buffer).is_gt() && patch_tag_depth == 0 {
+            if tag.range.start.cmp(&buffer_end, buffer).is_gt() && edit_step_depth == 0 {
                 break;
             }
 
-            if tag.kind == XmlTagKind::Patch && tag.is_open_tag {
-                patch_tag_depth += 1;
-                let patch_start = tag.range.start;
-                let mut edits = Vec::<Result<AssistantEdit>>::new();
-                let mut patch = AssistantPatch {
-                    range: patch_start..patch_start,
-                    title: String::new().into(),
+            if tag.kind == XmlTagKind::Step && tag.is_open_tag {
+                edit_step_depth += 1;
+                let edit_start = tag.range.start;
+                let mut edits = Vec::new();
+                let mut step = WorkflowStep {
+                    range: edit_start..edit_start,
+                    leading_tags_end: tag.range.end,
+                    trailing_tag_start: None,
                     edits: Default::default(),
-                    status: crate::AssistantPatchStatus::Pending,
+                    resolution: None,
+                    resolution_task: None,
                 };
 
                 while let Some(tag) = tags.next() {
-                    if tag.kind == XmlTagKind::Patch && !tag.is_open_tag {
-                        patch_tag_depth -= 1;
-                        if patch_tag_depth == 0 {
-                            patch.range.end = tag.range.end;
+                    step.trailing_tag_start.get_or_insert(tag.range.start);
 
-                            // Include the line immediately after this <patch> tag if it's empty.
-                            let patch_end_offset = patch.range.end.to_offset(buffer);
-                            let mut patch_end_chars = buffer.chars_at(patch_end_offset);
-                            if patch_end_chars.next() == Some('\n')
-                                && patch_end_chars.next().map_or(true, |ch| ch == '\n')
-                            {
-                                let messages = self.messages_for_offsets(
-                                    [patch_end_offset, patch_end_offset + 1],
-                                    cx,
-                                );
-                                if messages.len() == 1 {
-                                    patch.range.end = buffer.anchor_before(patch_end_offset + 1);
-                                }
-                            }
-
-                            edits.sort_unstable_by(|a, b| {
-                                if let (Ok(a), Ok(b)) = (a, b) {
-                                    a.path.cmp(&b.path)
-                                } else {
-                                    Ordering::Equal
-                                }
-                            });
-                            patch.edits = edits.into();
-                            patch.status = AssistantPatchStatus::Ready;
-                            new_patches.push(patch);
+                    if tag.kind == XmlTagKind::Step && !tag.is_open_tag {
+                        // step.trailing_tag_start = Some(tag.range.start);
+                        edit_step_depth -= 1;
+                        if edit_step_depth == 0 {
+                            step.range.end = tag.range.end;
+                            step.edits = edits.into();
+                            new_steps.push(step);
                             continue 'tags;
                         }
                     }
 
-                    if tag.kind == XmlTagKind::Title && tag.is_open_tag {
-                        let content_start = tag.range.end;
-                        while let Some(tag) = tags.next() {
-                            if tag.kind == XmlTagKind::Title && !tag.is_open_tag {
-                                let content_end = tag.range.start;
-                                patch.title =
-                                    trimmed_text_in_range(buffer, content_start..content_end)
-                                        .into();
-                                break;
-                            }
-                        }
-                    }
-
                     if tag.kind == XmlTagKind::Edit && tag.is_open_tag {
                         let mut path = None;
-                        let mut old_text = None;
-                        let mut new_text = None;
+                        let mut search = None;
                         let mut operation = None;
                         let mut description = None;
 
                         while let Some(tag) = tags.next() {
                             if tag.kind == XmlTagKind::Edit && !tag.is_open_tag {
-                                edits.push(AssistantEdit::new(
+                                edits.push(WorkflowStepEdit::new(
                                     path,
                                     operation,
-                                    old_text,
-                                    new_text,
+                                    search,
                                     description,
                                 ));
                                 break;
@@ -1549,8 +1526,7 @@ impl Context {
                             if tag.is_open_tag
                                 && [
                                     XmlTagKind::Path,
-                                    XmlTagKind::OldText,
-                                    XmlTagKind::NewText,
+                                    XmlTagKind::Search,
                                     XmlTagKind::Operation,
                                     XmlTagKind::Description,
                                 ]
@@ -1562,18 +1538,15 @@ impl Context {
                                     if tag.kind == kind && !tag.is_open_tag {
                                         let tag = tags.next().unwrap();
                                         let content_end = tag.range.start;
-                                        let content = trimmed_text_in_range(
-                                            buffer,
-                                            content_start..content_end,
-                                        );
+                                        let mut content = buffer
+                                            .text_for_range(content_start..content_end)
+                                            .collect::<String>();
+                                        content.truncate(content.trim_end().len());
                                         match kind {
                                             XmlTagKind::Path => path = Some(content),
                                             XmlTagKind::Operation => operation = Some(content),
-                                            XmlTagKind::OldText => {
-                                                old_text = Some(content).filter(|s| !s.is_empty())
-                                            }
-                                            XmlTagKind::NewText => {
-                                                new_text = Some(content).filter(|s| !s.is_empty())
+                                            XmlTagKind::Search => {
+                                                search = Some(content).filter(|s| !s.is_empty())
                                             }
                                             XmlTagKind::Description => {
                                                 description =
@@ -1588,28 +1561,162 @@ impl Context {
                     }
                 }
 
-                patch.edits = edits.into();
-                pending_patch = Some(patch);
+                pending_step = Some(step);
             }
         }
 
-        if let Some(mut pending_patch) = pending_patch {
-            let patch_start = pending_patch.range.start.to_offset(buffer);
-            if let Some(message) = self.message_for_offset(patch_start, cx) {
-                if message.anchor_range.end == text::Anchor::MAX {
-                    pending_patch.range.end = text::Anchor::MAX;
+        if let Some(mut pending_step) = pending_step {
+            pending_step.range.end = text::Anchor::MAX;
+            new_steps.push(pending_step);
+        }
+
+        new_steps
+    }
+
+    pub fn resolve_workflow_step(
+        &mut self,
+        tagged_range: Range<text::Anchor>,
+        cx: &mut ModelContext<Self>,
+    ) -> Option<()> {
+        let index = self
+            .workflow_step_index_for_range(&tagged_range, self.buffer.read(cx))
+            .ok()?;
+        let step = &mut self.workflow_steps[index];
+        let project = self.project.as_ref()?;
+        step.resolution.take();
+        Self::resolve_workflow_step_internal(step, project, cx);
+        None
+    }
+
+    fn resolve_workflow_step_internal(
+        step: &mut WorkflowStep,
+        project: &Model<Project>,
+        cx: &mut ModelContext<'_, Context>,
+    ) {
+        step.resolution_task = Some(cx.spawn({
+            let range = step.range.clone();
+            let edits = step.edits.clone();
+            let project = project.clone();
+            |this, mut cx| async move {
+                let suggestion_groups =
+                    Self::compute_step_resolution(project, edits, &mut cx).await;
+
+                this.update(&mut cx, |this, cx| {
+                    let buffer = this.buffer.read(cx).text_snapshot();
+                    let ix = this.workflow_step_index_for_range(&range, &buffer).ok();
+                    if let Some(ix) = ix {
+                        let step = &mut this.workflow_steps[ix];
+
+                        let resolution = suggestion_groups.map(|suggestion_groups| {
+                            let mut title = String::new();
+                            for mut chunk in buffer.text_for_range(
+                                step.leading_tags_end
+                                    ..step.trailing_tag_start.unwrap_or(step.range.end),
+                            ) {
+                                if title.is_empty() {
+                                    chunk = chunk.trim_start();
+                                }
+                                if let Some((prefix, _)) = chunk.split_once('\n') {
+                                    title.push_str(prefix);
+                                    break;
+                                } else {
+                                    title.push_str(chunk);
+                                }
+                            }
+
+                            WorkflowStepResolution {
+                                title,
+                                suggestion_groups,
+                            }
+                        });
+
+                        step.resolution = Some(Arc::new(resolution));
+                        cx.emit(ContextEvent::WorkflowStepsUpdated {
+                            removed: vec![],
+                            updated: vec![range],
+                        })
+                    }
+                })
+                .ok();
+            }
+        }));
+    }
+
+    async fn compute_step_resolution(
+        project: Model<Project>,
+        edits: Arc<[Result<WorkflowStepEdit>]>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<HashMap<Model<Buffer>, Vec<WorkflowSuggestionGroup>>> {
+        let mut suggestion_tasks = Vec::new();
+        for edit in edits.iter() {
+            let edit = edit.as_ref().map_err(|e| anyhow!("{e}"))?;
+            suggestion_tasks.push(edit.resolve(project.clone(), cx.clone()));
+        }
+
+        // Expand the context ranges of each suggestion and group suggestions with overlapping context ranges.
+        let suggestions = future::try_join_all(suggestion_tasks).await?;
+
+        let mut suggestions_by_buffer = HashMap::default();
+        for (buffer, suggestion) in suggestions {
+            suggestions_by_buffer
+                .entry(buffer)
+                .or_insert_with(Vec::new)
+                .push(suggestion);
+        }
+
+        let mut suggestion_groups_by_buffer = HashMap::default();
+        for (buffer, mut suggestions) in suggestions_by_buffer {
+            let mut suggestion_groups = Vec::<WorkflowSuggestionGroup>::new();
+            let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
+            // Sort suggestions by their range so that earlier, larger ranges come first
+            suggestions.sort_by(|a, b| a.range().cmp(&b.range(), &snapshot));
+
+            // Merge overlapping suggestions
+            suggestions.dedup_by(|a, b| b.try_merge(a, &snapshot));
+
+            // Create context ranges for each suggestion
+            for suggestion in suggestions {
+                let context_range = {
+                    let suggestion_point_range = suggestion.range().to_point(&snapshot);
+                    let start_row = suggestion_point_range.start.row.saturating_sub(5);
+                    let end_row =
+                        cmp::min(suggestion_point_range.end.row + 5, snapshot.max_point().row);
+                    let start = snapshot.anchor_before(Point::new(start_row, 0));
+                    let end =
+                        snapshot.anchor_after(Point::new(end_row, snapshot.line_len(end_row)));
+                    start..end
+                };
+
+                if let Some(last_group) = suggestion_groups.last_mut() {
+                    if last_group
+                        .context_range
+                        .end
+                        .cmp(&context_range.start, &snapshot)
+                        .is_ge()
+                    {
+                        // Merge with the previous group if context ranges overlap
+                        last_group.context_range.end = context_range.end;
+                        last_group.suggestions.push(suggestion);
+                    } else {
+                        // Create a new group
+                        suggestion_groups.push(WorkflowSuggestionGroup {
+                            context_range,
+                            suggestions: vec![suggestion],
+                        });
+                    }
                 } else {
-                    let message_end = buffer.anchor_after(message.offset_range.end - 1);
-                    pending_patch.range.end = message_end;
+                    // Create the first group
+                    suggestion_groups.push(WorkflowSuggestionGroup {
+                        context_range,
+                        suggestions: vec![suggestion],
+                    });
                 }
-            } else {
-                pending_patch.range.end = text::Anchor::MAX;
             }
 
-            new_patches.push(pending_patch);
+            suggestion_groups_by_buffer.insert(buffer, suggestion_groups);
         }
 
-        new_patches
+        Ok(suggestion_groups_by_buffer)
     }
 
     pub fn pending_command_for_position(
@@ -2208,11 +2315,11 @@ impl Context {
         let mut updated = Vec::new();
         let mut removed = Vec::new();
         for range in ranges {
-            self.reparse_patches_in_range(range, &buffer, &mut updated, &mut removed, cx);
+            self.reparse_workflow_steps_in_range(range, &buffer, &mut updated, &mut removed, cx);
         }
 
         if !updated.is_empty() || !removed.is_empty() {
-            cx.emit(ContextEvent::PatchesUpdated { removed, updated })
+            cx.emit(ContextEvent::WorkflowStepsUpdated { removed, updated })
         }
     }
 
@@ -2718,24 +2825,6 @@ impl Context {
     }
 }
 
-fn trimmed_text_in_range(buffer: &BufferSnapshot, range: Range<text::Anchor>) -> String {
-    let mut is_start = true;
-    let mut content = buffer
-        .text_for_range(range)
-        .map(|mut chunk| {
-            if is_start {
-                chunk = chunk.trim_start_matches('\n');
-                if !chunk.is_empty() {
-                    is_start = false;
-                }
-            }
-            chunk
-        })
-        .collect::<String>();
-    content.truncate(content.trim_end().len());
-    content
-}
-
 #[derive(Debug, Default)]
 pub struct ContextVersion {
     context: clock::Global,

crates/assistant/src/context/context_tests.rs

@@ -1,7 +1,8 @@
-use super::{AssistantEdit, MessageCacheMetadata};
+use super::{MessageCacheMetadata, WorkflowStepEdit};
 use crate::{
-    assistant_panel, prompt_library, slash_command::file_command, AssistantEditKind, CacheStatus,
-    Context, ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
+    assistant_panel, prompt_library, slash_command::file_command, CacheStatus, Context,
+    ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
+    WorkflowStepEditKind,
 };
 use anyhow::Result;
 use assistant_slash_command::{
@@ -14,7 +15,6 @@ use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
 use parking_lot::Mutex;
-use pretty_assertions::assert_eq;
 use project::Project;
 use rand::prelude::*;
 use serde_json::json;
@@ -478,15 +478,7 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
 #[gpui::test]
 async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
     cx.update(prompt_library::init);
-    let mut settings_store = cx.update(SettingsStore::test);
-    cx.update(|cx| {
-        settings_store
-            .set_user_settings(
-                r#"{ "assistant": { "enable_experimental_live_diffs": true } }"#,
-                cx,
-            )
-            .unwrap()
-    });
+    let settings_store = cx.update(SettingsStore::test);
     cx.set_global(settings_store);
     cx.update(language::init);
     cx.update(Project::init_settings);
@@ -528,7 +520,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         »",
         cx,
     );
-    expect_patches(
+    expect_steps(
         &context,
         "
 
@@ -547,17 +539,17 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
         «
-        <patch»",
+        <step»",
         cx,
     );
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        <patch",
+        <step",
         &[],
         cx,
     );
@@ -571,24 +563,36 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <patch«>
+        <step«>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>»",
         cx,
     );
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        «<patch>
+        «<step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>»",
         &[&[]],
         cx,
     );
 
-    // The full patch is added
+    // The full suggestion is added
     edit(
         &context,
         "
@@ -596,46 +600,51 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <patch>
+        <step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>«
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn one</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn one</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
+        </step>
 
         also,»",
         cx,
     );
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        «<patch>
+        «<step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn one</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn one</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
-        »
+        </step>»
+
         also,",
-        &[&[AssistantEdit {
+        &[&[WorkflowStepEdit {
             path: "src/lib.rs".into(),
-            kind: AssistantEditKind::InsertAfter {
-                old_text: "fn one".into(),
-                new_text: "fn two() {}".into(),
+            kind: WorkflowStepEditKind::InsertAfter {
+                search: "fn one".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -650,46 +659,51 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <patch>
+        <step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>«fn zero»</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>«fn zero»</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
+        </step>
 
         also,",
         cx,
     );
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        «<patch>
+        «<step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn zero</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn zero</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
-        »
+        </step>»
+
         also,",
-        &[&[AssistantEdit {
+        &[&[WorkflowStepEdit {
             path: "src/lib.rs".into(),
-            kind: AssistantEditKind::InsertAfter {
-                old_text: "fn zero".into(),
-                new_text: "fn two() {}".into(),
+            kind: WorkflowStepEditKind::InsertAfter {
+                search: "fn zero".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -701,24 +715,27 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
     });
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        <patch>
+        <step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn zero</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn zero</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
+        </step>
 
         also,",
         &[],
@@ -729,31 +746,33 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
     context.update(cx, |context, cx| {
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
     });
-    expect_patches(
+    expect_steps(
         &context,
         "
 
         one
         two
 
-        «<patch>
+        «<step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn zero</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn zero</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
-        »
+        </step>»
+
         also,",
-        &[&[AssistantEdit {
+        &[&[WorkflowStepEdit {
             path: "src/lib.rs".into(),
-            kind: AssistantEditKind::InsertAfter {
-                old_text: "fn zero".into(),
-                new_text: "fn two() {}".into(),
+            kind: WorkflowStepEditKind::InsertAfter {
+                search: "fn zero".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -773,31 +792,33 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
             cx,
         )
     });
-    expect_patches(
+    expect_steps(
         &deserialized_context,
         "
 
         one
         two
 
-        «<patch>
+        «<step>
+        Add a second function
+
+        ```rust
+        fn two() {}
+        ```
+
         <edit>
-        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <old_text>fn zero</old_text>
-        <new_text>
-        fn two() {}
-        </new_text>
+        <search>fn zero</search>
+        <description>add a `two` function</description>
         </edit>
-        </patch>
-        »
+        </step>»
+
         also,",
-        &[&[AssistantEdit {
+        &[&[WorkflowStepEdit {
             path: "src/lib.rs".into(),
-            kind: AssistantEditKind::InsertAfter {
-                old_text: "fn zero".into(),
-                new_text: "fn two() {}".into(),
+            kind: WorkflowStepEditKind::InsertAfter {
+                search: "fn zero".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -813,58 +834,48 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         cx.executor().run_until_parked();
     }
 
-    #[track_caller]
-    fn expect_patches(
+    fn expect_steps(
         context: &Model<Context>,
         expected_marked_text: &str,
-        expected_suggestions: &[&[AssistantEdit]],
+        expected_suggestions: &[&[WorkflowStepEdit]],
         cx: &mut TestAppContext,
     ) {
-        let expected_marked_text = expected_marked_text.unindent();
-        let (expected_text, _) = marked_text_ranges(&expected_marked_text, false);
-
-        let (buffer_text, ranges, patches) = context.update(cx, |context, cx| {
+        context.update(cx, |context, cx| {
+            let expected_marked_text = expected_marked_text.unindent();
+            let (expected_text, expected_ranges) = marked_text_ranges(&expected_marked_text, false);
             context.buffer.read_with(cx, |buffer, _| {
+                assert_eq!(buffer.text(), expected_text);
                 let ranges = context
-                    .patches
+                    .workflow_steps
                     .iter()
                     .map(|entry| entry.range.to_offset(buffer))
                     .collect::<Vec<_>>();
-                (
-                    buffer.text(),
-                    ranges,
-                    context
-                        .patches
-                        .iter()
-                        .map(|step| step.edits.clone())
-                        .collect::<Vec<_>>(),
-                )
-            })
+                let marked = generate_marked_text(&expected_text, &ranges, false);
+                assert_eq!(
+                    marked,
+                    expected_marked_text,
+                    "unexpected suggestion ranges. actual: {ranges:?}, expected: {expected_ranges:?}"
+                );
+                let suggestions = context
+                    .workflow_steps
+                    .iter()
+                    .map(|step| {
+                        step.edits
+                            .iter()
+                            .map(|edit| {
+                                let edit = edit.as_ref().unwrap();
+                                WorkflowStepEdit {
+                                    path: edit.path.clone(),
+                                    kind: edit.kind.clone(),
+                                }
+                            })
+                            .collect::<Vec<_>>()
+                    })
+                    .collect::<Vec<_>>();
+
+                assert_eq!(suggestions, expected_suggestions);
+            });
         });
-
-        assert_eq!(buffer_text, expected_text);
-
-        let actual_marked_text = generate_marked_text(&expected_text, &ranges, false);
-        assert_eq!(actual_marked_text, expected_marked_text);
-
-        assert_eq!(
-            patches
-                .iter()
-                .map(|patch| {
-                    patch
-                        .iter()
-                        .map(|edit| {
-                            let edit = edit.as_ref().unwrap();
-                            AssistantEdit {
-                                path: edit.path.clone(),
-                                kind: edit.kind.clone(),
-                            }
-                        })
-                        .collect::<Vec<_>>()
-                })
-                .collect::<Vec<_>>(),
-            expected_suggestions
-        );
     }
 }
 

crates/assistant/src/inline_assistant.rs

@@ -82,6 +82,13 @@ pub struct InlineAssistant {
     assists: HashMap<InlineAssistId, InlineAssist>,
     assists_by_editor: HashMap<WeakView<Editor>, EditorInlineAssists>,
     assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,
+    assist_observations: HashMap<
+        InlineAssistId,
+        (
+            async_watch::Sender<AssistStatus>,
+            async_watch::Receiver<AssistStatus>,
+        ),
+    >,
     confirmed_assists: HashMap<InlineAssistId, Model<CodegenAlternative>>,
     prompt_history: VecDeque<String>,
     prompt_builder: Arc<PromptBuilder>,
@@ -89,6 +96,19 @@ pub struct InlineAssistant {
     fs: Arc<dyn Fs>,
 }
 
+pub enum AssistStatus {
+    Idle,
+    Started,
+    Stopped,
+    Finished,
+}
+
+impl AssistStatus {
+    pub fn is_done(&self) -> bool {
+        matches!(self, Self::Stopped | Self::Finished)
+    }
+}
+
 impl Global for InlineAssistant {}
 
 impl InlineAssistant {
@@ -103,6 +123,7 @@ impl InlineAssistant {
             assists: HashMap::default(),
             assists_by_editor: HashMap::default(),
             assist_groups: HashMap::default(),
+            assist_observations: HashMap::default(),
             confirmed_assists: HashMap::default(),
             prompt_history: VecDeque::default(),
             prompt_builder,
@@ -814,6 +835,17 @@ impl InlineAssistant {
                     .insert(assist_id, confirmed_alternative);
             }
         }
+
+        // Remove the assist from the status updates map
+        self.assist_observations.remove(&assist_id);
+    }
+
+    pub fn undo_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) -> bool {
+        let Some(codegen) = self.confirmed_assists.remove(&assist_id) else {
+            return false;
+        };
+        codegen.update(cx, |this, cx| this.undo(cx));
+        true
     }
 
     fn dismiss_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) -> bool {
@@ -1007,6 +1039,10 @@ impl InlineAssistant {
                 codegen.start(user_prompt, assistant_panel_context, cx)
             })
             .log_err();
+
+        if let Some((tx, _)) = self.assist_observations.get(&assist_id) {
+            tx.send(AssistStatus::Started).ok();
+        }
     }
 
     pub fn stop_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
@@ -1017,6 +1053,25 @@ impl InlineAssistant {
         };
 
         assist.codegen.update(cx, |codegen, cx| codegen.stop(cx));
+
+        if let Some((tx, _)) = self.assist_observations.get(&assist_id) {
+            tx.send(AssistStatus::Stopped).ok();
+        }
+    }
+
+    pub fn assist_status(&self, assist_id: InlineAssistId, cx: &AppContext) -> InlineAssistStatus {
+        if let Some(assist) = self.assists.get(&assist_id) {
+            match assist.codegen.read(cx).status(cx) {
+                CodegenStatus::Idle => InlineAssistStatus::Idle,
+                CodegenStatus::Pending => InlineAssistStatus::Pending,
+                CodegenStatus::Done => InlineAssistStatus::Done,
+                CodegenStatus::Error(_) => InlineAssistStatus::Error,
+            }
+        } else if self.confirmed_assists.contains_key(&assist_id) {
+            InlineAssistStatus::Confirmed
+        } else {
+            InlineAssistStatus::Canceled
+        }
     }
 
     fn update_editor_highlights(&self, editor: &View<Editor>, cx: &mut WindowContext) {
@@ -1202,6 +1257,42 @@ impl InlineAssistant {
                 .collect();
         })
     }
+
+    pub fn observe_assist(
+        &mut self,
+        assist_id: InlineAssistId,
+    ) -> async_watch::Receiver<AssistStatus> {
+        if let Some((_, rx)) = self.assist_observations.get(&assist_id) {
+            rx.clone()
+        } else {
+            let (tx, rx) = async_watch::channel(AssistStatus::Idle);
+            self.assist_observations.insert(assist_id, (tx, rx.clone()));
+            rx
+        }
+    }
+}
+
+pub enum InlineAssistStatus {
+    Idle,
+    Pending,
+    Done,
+    Error,
+    Confirmed,
+    Canceled,
+}
+
+impl InlineAssistStatus {
+    pub(crate) fn is_pending(&self) -> bool {
+        matches!(self, Self::Pending)
+    }
+
+    pub(crate) fn is_confirmed(&self) -> bool {
+        matches!(self, Self::Confirmed)
+    }
+
+    pub(crate) fn is_done(&self) -> bool {
+        matches!(self, Self::Done)
+    }
 }
 
 struct EditorInlineAssists {
@@ -2199,6 +2290,8 @@ impl InlineAssist {
 
                             if assist.decorations.is_none() {
                                 this.finish_assist(assist_id, false, cx);
+                            } else if let Some(tx) = this.assist_observations.get(&assist_id) {
+                                tx.0.send(AssistStatus::Finished).ok();
                             }
                         }
                     })

crates/assistant/src/patch.rs

@@ -1,829 +0,0 @@
-use anyhow::{anyhow, Context as _, Result};
-use collections::HashMap;
-use editor::ProposedChangesEditor;
-use futures::{future, TryFutureExt as _};
-use gpui::{AppContext, AsyncAppContext, Model, SharedString};
-use language::{AutoindentMode, Buffer, BufferSnapshot};
-use project::{Project, ProjectPath};
-use std::{cmp, ops::Range, path::Path, sync::Arc};
-use text::{AnchorRangeExt as _, Bias, OffsetRangeExt as _, Point};
-
-#[derive(Clone, Debug)]
-pub(crate) struct AssistantPatch {
-    pub range: Range<language::Anchor>,
-    pub title: SharedString,
-    pub edits: Arc<[Result<AssistantEdit>]>,
-    pub status: AssistantPatchStatus,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub(crate) enum AssistantPatchStatus {
-    Pending,
-    Ready,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct AssistantEdit {
-    pub path: String,
-    pub kind: AssistantEditKind,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum AssistantEditKind {
-    Update {
-        old_text: String,
-        new_text: String,
-        description: String,
-    },
-    Create {
-        new_text: String,
-        description: String,
-    },
-    InsertBefore {
-        old_text: String,
-        new_text: String,
-        description: String,
-    },
-    InsertAfter {
-        old_text: String,
-        new_text: String,
-        description: String,
-    },
-    Delete {
-        old_text: String,
-    },
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct ResolvedPatch {
-    pub edit_groups: HashMap<Model<Buffer>, Vec<ResolvedEditGroup>>,
-    pub errors: Vec<AssistantPatchResolutionError>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ResolvedEditGroup {
-    pub context_range: Range<language::Anchor>,
-    pub edits: Vec<ResolvedEdit>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ResolvedEdit {
-    range: Range<language::Anchor>,
-    new_text: String,
-    description: Option<String>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct AssistantPatchResolutionError {
-    pub edit_ix: usize,
-    pub message: String,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-enum SearchDirection {
-    Up,
-    Left,
-    Diagonal,
-}
-
-// A measure of the currently quality of an in-progress fuzzy search.
-//
-// Uses 60 bits to store a numeric cost, and 4 bits to store the preceding
-// operation in the search.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-struct SearchState {
-    score: u32,
-    direction: SearchDirection,
-}
-
-impl SearchState {
-    fn new(score: u32, direction: SearchDirection) -> Self {
-        Self { score, direction }
-    }
-}
-
-impl ResolvedPatch {
-    pub fn apply(&self, editor: &ProposedChangesEditor, cx: &mut AppContext) {
-        for (buffer, groups) in &self.edit_groups {
-            let branch = editor.branch_buffer_for_base(buffer).unwrap();
-            Self::apply_edit_groups(groups, &branch, cx);
-        }
-        editor.recalculate_all_buffer_diffs();
-    }
-
-    fn apply_edit_groups(
-        groups: &Vec<ResolvedEditGroup>,
-        buffer: &Model<Buffer>,
-        cx: &mut AppContext,
-    ) {
-        let mut edits = Vec::new();
-        for group in groups {
-            for suggestion in &group.edits {
-                edits.push((suggestion.range.clone(), suggestion.new_text.clone()));
-            }
-        }
-        buffer.update(cx, |buffer, cx| {
-            buffer.edit(
-                edits,
-                Some(AutoindentMode::Block {
-                    original_indent_columns: Vec::new(),
-                }),
-                cx,
-            );
-        });
-    }
-}
-
-impl ResolvedEdit {
-    pub fn try_merge(&mut self, other: &Self, buffer: &text::BufferSnapshot) -> bool {
-        let range = &self.range;
-        let other_range = &other.range;
-
-        // Don't merge if we don't contain the other suggestion.
-        if range.start.cmp(&other_range.start, buffer).is_gt()
-            || range.end.cmp(&other_range.end, buffer).is_lt()
-        {
-            return false;
-        }
-
-        let other_offset_range = other_range.to_offset(buffer);
-        let offset_range = range.to_offset(buffer);
-
-        // If the other range is empty at the start of this edit's range, combine the new text
-        if other_offset_range.is_empty() && other_offset_range.start == offset_range.start {
-            self.new_text = format!("{}\n{}", other.new_text, self.new_text);
-            self.range.start = other_range.start;
-
-            if let Some((description, other_description)) =
-                self.description.as_mut().zip(other.description.as_ref())
-            {
-                *description = format!("{}\n{}", other_description, description)
-            }
-        } else {
-            if let Some((description, other_description)) =
-                self.description.as_mut().zip(other.description.as_ref())
-            {
-                description.push('\n');
-                description.push_str(other_description);
-            }
-        }
-
-        true
-    }
-}
-
-impl AssistantEdit {
-    pub fn new(
-        path: Option<String>,
-        operation: Option<String>,
-        old_text: Option<String>,
-        new_text: Option<String>,
-        description: Option<String>,
-    ) -> Result<Self> {
-        let path = path.ok_or_else(|| anyhow!("missing path"))?;
-        let operation = operation.ok_or_else(|| anyhow!("missing operation"))?;
-
-        let kind = match operation.as_str() {
-            "update" => AssistantEditKind::Update {
-                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
-                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "insert_before" => AssistantEditKind::InsertBefore {
-                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
-                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "insert_after" => AssistantEditKind::InsertAfter {
-                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
-                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "delete" => AssistantEditKind::Delete {
-                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
-            },
-            "create" => AssistantEditKind::Create {
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-            },
-            _ => Err(anyhow!("unknown operation {operation:?}"))?,
-        };
-
-        Ok(Self { path, kind })
-    }
-
-    pub async fn resolve(
-        &self,
-        project: Model<Project>,
-        mut cx: AsyncAppContext,
-    ) -> Result<(Model<Buffer>, ResolvedEdit)> {
-        let path = self.path.clone();
-        let kind = self.kind.clone();
-        let buffer = project
-            .update(&mut cx, |project, cx| {
-                let project_path = project
-                    .find_project_path(Path::new(&path), cx)
-                    .or_else(|| {
-                        // If we couldn't find a project path for it, put it in the active worktree
-                        // so that when we create the buffer, it can be saved.
-                        let worktree = project
-                            .active_entry()
-                            .and_then(|entry_id| project.worktree_for_entry(entry_id, cx))
-                            .or_else(|| project.worktrees(cx).next())?;
-                        let worktree = worktree.read(cx);
-
-                        Some(ProjectPath {
-                            worktree_id: worktree.id(),
-                            path: Arc::from(Path::new(&path)),
-                        })
-                    })
-                    .with_context(|| format!("worktree not found for {:?}", path))?;
-                anyhow::Ok(project.open_buffer(project_path, cx))
-            })??
-            .await?;
-
-        let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
-        let suggestion = cx
-            .background_executor()
-            .spawn(async move { kind.resolve(&snapshot) })
-            .await;
-
-        Ok((buffer, suggestion))
-    }
-}
-
-impl AssistantEditKind {
-    fn resolve(self, snapshot: &BufferSnapshot) -> ResolvedEdit {
-        match self {
-            Self::Update {
-                old_text,
-                new_text,
-                description,
-            } => {
-                let range = Self::resolve_location(&snapshot, &old_text);
-                ResolvedEdit {
-                    range,
-                    new_text,
-                    description: Some(description),
-                }
-            }
-            Self::Create {
-                new_text,
-                description,
-            } => ResolvedEdit {
-                range: text::Anchor::MIN..text::Anchor::MAX,
-                description: Some(description),
-                new_text,
-            },
-            Self::InsertBefore {
-                old_text,
-                mut new_text,
-                description,
-            } => {
-                let range = Self::resolve_location(&snapshot, &old_text);
-                new_text.push('\n');
-                ResolvedEdit {
-                    range: range.start..range.start,
-                    new_text,
-                    description: Some(description),
-                }
-            }
-            Self::InsertAfter {
-                old_text,
-                mut new_text,
-                description,
-            } => {
-                let range = Self::resolve_location(&snapshot, &old_text);
-                new_text.insert(0, '\n');
-                ResolvedEdit {
-                    range: range.end..range.end,
-                    new_text,
-                    description: Some(description),
-                }
-            }
-            Self::Delete { old_text } => {
-                let range = Self::resolve_location(&snapshot, &old_text);
-                ResolvedEdit {
-                    range,
-                    new_text: String::new(),
-                    description: None,
-                }
-            }
-        }
-    }
-
-    fn resolve_location(buffer: &text::BufferSnapshot, search_query: &str) -> Range<text::Anchor> {
-        const INSERTION_COST: u32 = 3;
-        const WHITESPACE_INSERTION_COST: u32 = 1;
-        const DELETION_COST: u32 = 3;
-        const WHITESPACE_DELETION_COST: u32 = 1;
-        const EQUALITY_BONUS: u32 = 5;
-
-        struct Matrix {
-            cols: usize,
-            data: Vec<SearchState>,
-        }
-
-        impl Matrix {
-            fn new(rows: usize, cols: usize) -> Self {
-                Matrix {
-                    cols,
-                    data: vec![SearchState::new(0, SearchDirection::Diagonal); rows * cols],
-                }
-            }
-
-            fn get(&self, row: usize, col: usize) -> SearchState {
-                self.data[row * self.cols + col]
-            }
-
-            fn set(&mut self, row: usize, col: usize, cost: SearchState) {
-                self.data[row * self.cols + col] = cost;
-            }
-        }
-
-        let buffer_len = buffer.len();
-        let query_len = search_query.len();
-        let mut matrix = Matrix::new(query_len + 1, buffer_len + 1);
-
-        for (row, query_byte) in search_query.bytes().enumerate() {
-            for (col, buffer_byte) in buffer.bytes_in_range(0..buffer.len()).flatten().enumerate() {
-                let deletion_cost = if query_byte.is_ascii_whitespace() {
-                    WHITESPACE_DELETION_COST
-                } else {
-                    DELETION_COST
-                };
-                let insertion_cost = if buffer_byte.is_ascii_whitespace() {
-                    WHITESPACE_INSERTION_COST
-                } else {
-                    INSERTION_COST
-                };
-
-                let up = SearchState::new(
-                    matrix.get(row, col + 1).score.saturating_sub(deletion_cost),
-                    SearchDirection::Up,
-                );
-                let left = SearchState::new(
-                    matrix
-                        .get(row + 1, col)
-                        .score
-                        .saturating_sub(insertion_cost),
-                    SearchDirection::Left,
-                );
-                let diagonal = SearchState::new(
-                    if query_byte == *buffer_byte {
-                        matrix.get(row, col).score.saturating_add(EQUALITY_BONUS)
-                    } else {
-                        matrix
-                            .get(row, col)
-                            .score
-                            .saturating_sub(deletion_cost + insertion_cost)
-                    },
-                    SearchDirection::Diagonal,
-                );
-                matrix.set(row + 1, col + 1, up.max(left).max(diagonal));
-            }
-        }
-
-        // Traceback to find the best match
-        let mut best_buffer_end = buffer_len;
-        let mut best_score = 0;
-        for col in 1..=buffer_len {
-            let score = matrix.get(query_len, col).score;
-            if score > best_score {
-                best_score = score;
-                best_buffer_end = col;
-            }
-        }
-
-        let mut query_ix = query_len;
-        let mut buffer_ix = best_buffer_end;
-        while query_ix > 0 && buffer_ix > 0 {
-            let current = matrix.get(query_ix, buffer_ix);
-            match current.direction {
-                SearchDirection::Diagonal => {
-                    query_ix -= 1;
-                    buffer_ix -= 1;
-                }
-                SearchDirection::Up => {
-                    query_ix -= 1;
-                }
-                SearchDirection::Left => {
-                    buffer_ix -= 1;
-                }
-            }
-        }
-
-        let mut start = buffer.offset_to_point(buffer.clip_offset(buffer_ix, Bias::Left));
-        start.column = 0;
-        let mut end = buffer.offset_to_point(buffer.clip_offset(best_buffer_end, Bias::Right));
-        if end.column > 0 {
-            end.column = buffer.line_len(end.row);
-        }
-
-        buffer.anchor_after(start)..buffer.anchor_before(end)
-    }
-}
-
-impl AssistantPatch {
-    pub(crate) async fn resolve(
-        &self,
-        project: Model<Project>,
-        cx: &mut AsyncAppContext,
-    ) -> ResolvedPatch {
-        let mut resolve_tasks = Vec::new();
-        for (ix, edit) in self.edits.iter().enumerate() {
-            if let Ok(edit) = edit.as_ref() {
-                resolve_tasks.push(
-                    edit.resolve(project.clone(), cx.clone())
-                        .map_err(move |error| (ix, error)),
-                );
-            }
-        }
-
-        let edits = future::join_all(resolve_tasks).await;
-        let mut errors = Vec::new();
-        let mut edits_by_buffer = HashMap::default();
-        for entry in edits {
-            match entry {
-                Ok((buffer, edit)) => {
-                    edits_by_buffer
-                        .entry(buffer)
-                        .or_insert_with(Vec::new)
-                        .push(edit);
-                }
-                Err((edit_ix, error)) => errors.push(AssistantPatchResolutionError {
-                    edit_ix,
-                    message: error.to_string(),
-                }),
-            }
-        }
-
-        // Expand the context ranges of each edit and group edits with overlapping context ranges.
-        let mut edit_groups_by_buffer = HashMap::default();
-        for (buffer, edits) in edits_by_buffer {
-            if let Ok(snapshot) = buffer.update(cx, |buffer, _| buffer.text_snapshot()) {
-                edit_groups_by_buffer.insert(buffer, Self::group_edits(edits, &snapshot));
-            }
-        }
-
-        ResolvedPatch {
-            edit_groups: edit_groups_by_buffer,
-            errors,
-        }
-    }
-
-    fn group_edits(
-        mut edits: Vec<ResolvedEdit>,
-        snapshot: &text::BufferSnapshot,
-    ) -> Vec<ResolvedEditGroup> {
-        let mut edit_groups = Vec::<ResolvedEditGroup>::new();
-        // Sort edits by their range so that earlier, larger ranges come first
-        edits.sort_by(|a, b| a.range.cmp(&b.range, &snapshot));
-
-        // Merge overlapping edits
-        edits.dedup_by(|a, b| b.try_merge(a, &snapshot));
-
-        // Create context ranges for each edit
-        for edit in edits {
-            let context_range = {
-                let edit_point_range = edit.range.to_point(&snapshot);
-                let start_row = edit_point_range.start.row.saturating_sub(5);
-                let end_row = cmp::min(edit_point_range.end.row + 5, snapshot.max_point().row);
-                let start = snapshot.anchor_before(Point::new(start_row, 0));
-                let end = snapshot.anchor_after(Point::new(end_row, snapshot.line_len(end_row)));
-                start..end
-            };
-
-            if let Some(last_group) = edit_groups.last_mut() {
-                if last_group
-                    .context_range
-                    .end
-                    .cmp(&context_range.start, &snapshot)
-                    .is_ge()
-                {
-                    // Merge with the previous group if context ranges overlap
-                    last_group.context_range.end = context_range.end;
-                    last_group.edits.push(edit);
-                } else {
-                    // Create a new group
-                    edit_groups.push(ResolvedEditGroup {
-                        context_range,
-                        edits: vec![edit],
-                    });
-                }
-            } else {
-                // Create the first group
-                edit_groups.push(ResolvedEditGroup {
-                    context_range,
-                    edits: vec![edit],
-                });
-            }
-        }
-
-        edit_groups
-    }
-
-    pub fn path_count(&self) -> usize {
-        self.paths().count()
-    }
-
-    pub fn paths(&self) -> impl '_ + Iterator<Item = &str> {
-        let mut prev_path = None;
-        self.edits.iter().filter_map(move |edit| {
-            if let Ok(edit) = edit {
-                let path = Some(edit.path.as_str());
-                if path != prev_path {
-                    prev_path = path;
-                    return path;
-                }
-            }
-            None
-        })
-    }
-}
-
-impl PartialEq for AssistantPatch {
-    fn eq(&self, other: &Self) -> bool {
-        self.range == other.range
-            && self.title == other.title
-            && Arc::ptr_eq(&self.edits, &other.edits)
-    }
-}
-
-impl Eq for AssistantPatch {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gpui::{AppContext, Context};
-    use language::{
-        language_settings::AllLanguageSettings, Language, LanguageConfig, LanguageMatcher,
-    };
-    use settings::SettingsStore;
-    use text::{OffsetRangeExt, Point};
-    use ui::BorrowAppContext;
-    use unindent::Unindent as _;
-
-    #[gpui::test]
-    fn test_resolve_location(cx: &mut AppContext) {
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "    Lorem\n",
-                        "    ipsum\n",
-                        "    dolor sit amet\n",
-                        "    consecteur",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                AssistantEditKind::resolve_location(&snapshot, "ipsum\ndolor").to_point(&snapshot),
-                Point::new(1, 0)..Point::new(2, 18)
-            );
-        }
-
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "fn foo1(a: usize) -> usize {\n",
-                        "    40\n",
-                        "}\n",
-                        "\n",
-                        "fn foo2(b: usize) -> usize {\n",
-                        "    42\n",
-                        "}\n",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                AssistantEditKind::resolve_location(&snapshot, "fn foo1(b: usize) {\n40\n}")
-                    .to_point(&snapshot),
-                Point::new(0, 0)..Point::new(2, 1)
-            );
-        }
-
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "fn main() {\n",
-                        "    Foo\n",
-                        "        .bar()\n",
-                        "        .baz()\n",
-                        "        .qux()\n",
-                        "}\n",
-                        "\n",
-                        "fn foo2(b: usize) -> usize {\n",
-                        "    42\n",
-                        "}\n",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                AssistantEditKind::resolve_location(&snapshot, "Foo.bar.baz.qux()")
-                    .to_point(&snapshot),
-                Point::new(1, 0)..Point::new(4, 14)
-            );
-        }
-    }
-
-    #[gpui::test]
-    fn test_resolve_edits(cx: &mut AppContext) {
-        let settings_store = SettingsStore::test(cx);
-        cx.set_global(settings_store);
-        language::init(cx);
-        cx.update_global::<SettingsStore, _>(|settings, cx| {
-            settings.update_user_settings::<AllLanguageSettings>(cx, |_| {});
-        });
-
-        assert_edits(
-            "
-                /// A person
-                struct Person {
-                    name: String,
-                    age: usize,
-                }
-
-                /// A dog
-                struct Dog {
-                    weight: f32,
-                }
-
-                impl Person {
-                    fn name(&self) -> &str {
-                        &self.name
-                    }
-                }
-            "
-            .unindent(),
-            vec![
-                AssistantEditKind::Update {
-                    old_text: "
-                        name: String,
-                    "
-                    .unindent(),
-                    new_text: "
-                        first_name: String,
-                        last_name: String,
-                    "
-                    .unindent(),
-                    description: "".into(),
-                },
-                AssistantEditKind::Update {
-                    old_text: "
-                        fn name(&self) -> &str {
-                            &self.name
-                        }
-                    "
-                    .unindent(),
-                    new_text: "
-                        fn name(&self) -> String {
-                            format!(\"{} {}\", self.first_name, self.last_name)
-                        }
-                    "
-                    .unindent(),
-                    description: "".into(),
-                },
-            ],
-            "
-                /// A person
-                struct Person {
-                    first_name: String,
-                    last_name: String,
-                    age: usize,
-                }
-
-                /// A dog
-                struct Dog {
-                    weight: f32,
-                }
-
-                impl Person {
-                    fn name(&self) -> String {
-                        format!(\"{} {}\", self.first_name, self.last_name)
-                    }
-                }
-            "
-            .unindent(),
-            cx,
-        );
-
-        // Ensure InsertBefore merges correctly with Update of the same text
-
-        assert_edits(
-            "
-                fn foo() {
-
-                }
-            "
-            .unindent(),
-            vec![
-                AssistantEditKind::InsertBefore {
-                    old_text: "
-                        fn foo() {"
-                        .unindent(),
-                    new_text: "
-                        fn bar() {
-                            qux();
-                        }"
-                    .unindent(),
-                    description: "implement bar".into(),
-                },
-                AssistantEditKind::Update {
-                    old_text: "
-                        fn foo() {
-
-                        }"
-                    .unindent(),
-                    new_text: "
-                        fn foo() {
-                            bar();
-                        }"
-                    .unindent(),
-                    description: "call bar in foo".into(),
-                },
-                AssistantEditKind::InsertAfter {
-                    old_text: "
-                        fn foo() {
-
-                        }
-                    "
-                    .unindent(),
-                    new_text: "
-                        fn qux() {
-                            // todo
-                        }
-                    "
-                    .unindent(),
-                    description: "implement qux".into(),
-                },
-            ],
-            "
-                fn bar() {
-                    qux();
-                }
-
-                fn foo() {
-                    bar();
-                }
-
-                fn qux() {
-                    // todo
-                }
-            "
-            .unindent(),
-            cx,
-        );
-    }
-
-    #[track_caller]
-    fn assert_edits(
-        old_text: String,
-        edits: Vec<AssistantEditKind>,
-        new_text: String,
-        cx: &mut AppContext,
-    ) {
-        let buffer =
-            cx.new_model(|cx| Buffer::local(old_text, cx).with_language(Arc::new(rust_lang()), cx));
-        let snapshot = buffer.read(cx).snapshot();
-        let resolved_edits = edits
-            .into_iter()
-            .map(|kind| kind.resolve(&snapshot))
-            .collect();
-        let edit_groups = AssistantPatch::group_edits(resolved_edits, &snapshot);
-        ResolvedPatch::apply_edit_groups(&edit_groups, &buffer, cx);
-        let actual_new_text = buffer.read(cx).text();
-        pretty_assertions::assert_eq!(actual_new_text, new_text);
-    }
-
-    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_indents_query(
-            r#"
-            (call_expression) @indent
-            (field_expression) @indent
-            (_ "(" ")" @end) @indent
-            (_ "{" "}" @end) @indent
-            "#,
-        )
-        .unwrap()
-    }
-}

crates/assistant/src/prompts.rs

@@ -45,6 +45,15 @@ pub struct ProjectSlashCommandPromptContext {
     pub context_buffer: String,
 }
 
+/// Context required to generate a workflow step resolution prompt.
+#[derive(Debug, Serialize)]
+pub struct StepResolutionContext {
+    /// The full context, including <step>...</step> tags
+    pub workflow_context: String,
+    /// The text of the specific step from the context to resolve
+    pub step_to_resolve: String,
+}
+
 pub struct PromptLoadingParams<'a> {
     pub fs: Arc<dyn Fs>,
     pub repo_path: Option<PathBuf>,

crates/assistant/src/slash_command/workflow_command.rs

@@ -18,8 +18,6 @@ pub(crate) struct WorkflowSlashCommand {
 }
 
 impl WorkflowSlashCommand {
-    pub const NAME: &'static str = "workflow";
-
     pub fn new(prompt_builder: Arc<PromptBuilder>) -> Self {
         Self { prompt_builder }
     }
@@ -27,7 +25,7 @@ impl WorkflowSlashCommand {
 
 impl SlashCommand for WorkflowSlashCommand {
     fn name(&self) -> String {
-        Self::NAME.into()
+        "workflow".into()
     }
 
     fn description(&self) -> String {

crates/assistant/src/workflow.rs

@@ -0,0 +1,507 @@
+use crate::{AssistantPanel, InlineAssistId, InlineAssistant};
+use anyhow::{anyhow, Context as _, Result};
+use collections::HashMap;
+use editor::Editor;
+use gpui::AsyncAppContext;
+use gpui::{Model, Task, UpdateGlobal as _, View, WeakView, WindowContext};
+use language::{Buffer, BufferSnapshot};
+use project::{Project, ProjectPath};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{ops::Range, path::Path, sync::Arc};
+use text::Bias;
+use workspace::Workspace;
+
+#[derive(Debug)]
+pub(crate) struct WorkflowStep {
+    pub range: Range<language::Anchor>,
+    pub leading_tags_end: text::Anchor,
+    pub trailing_tag_start: Option<text::Anchor>,
+    pub edits: Arc<[Result<WorkflowStepEdit>]>,
+    pub resolution_task: Option<Task<()>>,
+    pub resolution: Option<Arc<Result<WorkflowStepResolution>>>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct WorkflowStepEdit {
+    pub path: String,
+    pub kind: WorkflowStepEditKind,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct WorkflowStepResolution {
+    pub title: String,
+    pub suggestion_groups: HashMap<Model<Buffer>, Vec<WorkflowSuggestionGroup>>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct WorkflowSuggestionGroup {
+    pub context_range: Range<language::Anchor>,
+    pub suggestions: Vec<WorkflowSuggestion>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum WorkflowSuggestion {
+    Update {
+        range: Range<language::Anchor>,
+        description: String,
+    },
+    CreateFile {
+        description: String,
+    },
+    InsertBefore {
+        position: language::Anchor,
+        description: String,
+    },
+    InsertAfter {
+        position: language::Anchor,
+        description: String,
+    },
+    Delete {
+        range: Range<language::Anchor>,
+    },
+}
+
+impl WorkflowSuggestion {
+    pub fn range(&self) -> Range<language::Anchor> {
+        match self {
+            Self::Update { range, .. } => range.clone(),
+            Self::CreateFile { .. } => language::Anchor::MIN..language::Anchor::MAX,
+            Self::InsertBefore { position, .. } | Self::InsertAfter { position, .. } => {
+                *position..*position
+            }
+            Self::Delete { range, .. } => range.clone(),
+        }
+    }
+
+    pub fn description(&self) -> Option<&str> {
+        match self {
+            Self::Update { description, .. }
+            | Self::CreateFile { description }
+            | Self::InsertBefore { description, .. }
+            | Self::InsertAfter { description, .. } => Some(description),
+            Self::Delete { .. } => None,
+        }
+    }
+
+    fn description_mut(&mut self) -> Option<&mut String> {
+        match self {
+            Self::Update { description, .. }
+            | Self::CreateFile { description }
+            | Self::InsertBefore { description, .. }
+            | Self::InsertAfter { description, .. } => Some(description),
+            Self::Delete { .. } => None,
+        }
+    }
+
+    pub fn try_merge(&mut self, other: &Self, buffer: &BufferSnapshot) -> bool {
+        let range = self.range();
+        let other_range = other.range();
+
+        // Don't merge if we don't contain the other suggestion.
+        if range.start.cmp(&other_range.start, buffer).is_gt()
+            || range.end.cmp(&other_range.end, buffer).is_lt()
+        {
+            return false;
+        }
+
+        if let Some(description) = self.description_mut() {
+            if let Some(other_description) = other.description() {
+                description.push('\n');
+                description.push_str(other_description);
+            }
+        }
+        true
+    }
+
+    pub fn show(
+        &self,
+        editor: &View<Editor>,
+        excerpt_id: editor::ExcerptId,
+        workspace: &WeakView<Workspace>,
+        assistant_panel: &View<AssistantPanel>,
+        cx: &mut WindowContext,
+    ) -> Option<InlineAssistId> {
+        let mut initial_transaction_id = None;
+        let initial_prompt;
+        let suggestion_range;
+        let buffer = editor.read(cx).buffer().clone();
+        let snapshot = buffer.read(cx).snapshot(cx);
+
+        match self {
+            Self::Update {
+                range, description, ..
+            } => {
+                initial_prompt = description.clone();
+                suggestion_range = snapshot.anchor_in_excerpt(excerpt_id, range.start)?
+                    ..snapshot.anchor_in_excerpt(excerpt_id, range.end)?;
+            }
+            Self::CreateFile { description } => {
+                initial_prompt = description.clone();
+                suggestion_range = editor::Anchor::min()..editor::Anchor::min();
+            }
+            Self::InsertBefore {
+                position,
+                description,
+                ..
+            } => {
+                let position = snapshot.anchor_in_excerpt(excerpt_id, *position)?;
+                initial_prompt = description.clone();
+                suggestion_range = buffer.update(cx, |buffer, cx| {
+                    buffer.start_transaction(cx);
+                    let line_start = buffer.insert_empty_line(position, true, true, cx);
+                    initial_transaction_id = buffer.end_transaction(cx);
+                    buffer.refresh_preview(cx);
+
+                    let line_start = buffer.read(cx).anchor_before(line_start);
+                    line_start..line_start
+                });
+            }
+            Self::InsertAfter {
+                position,
+                description,
+                ..
+            } => {
+                let position = snapshot.anchor_in_excerpt(excerpt_id, *position)?;
+                initial_prompt = description.clone();
+                suggestion_range = buffer.update(cx, |buffer, cx| {
+                    buffer.start_transaction(cx);
+                    let line_start = buffer.insert_empty_line(position, true, true, cx);
+                    initial_transaction_id = buffer.end_transaction(cx);
+                    buffer.refresh_preview(cx);
+
+                    let line_start = buffer.read(cx).anchor_before(line_start);
+                    line_start..line_start
+                });
+            }
+            Self::Delete { range, .. } => {
+                initial_prompt = "Delete".to_string();
+                suggestion_range = snapshot.anchor_in_excerpt(excerpt_id, range.start)?
+                    ..snapshot.anchor_in_excerpt(excerpt_id, range.end)?;
+            }
+        }
+
+        InlineAssistant::update_global(cx, |inline_assistant, cx| {
+            Some(inline_assistant.suggest_assist(
+                editor,
+                suggestion_range,
+                initial_prompt,
+                initial_transaction_id,
+                false,
+                Some(workspace.clone()),
+                Some(assistant_panel),
+                cx,
+            ))
+        })
+    }
+}
+
+impl WorkflowStepEdit {
+    pub fn new(
+        path: Option<String>,
+        operation: Option<String>,
+        search: Option<String>,
+        description: Option<String>,
+    ) -> Result<Self> {
+        let path = path.ok_or_else(|| anyhow!("missing path"))?;
+        let operation = operation.ok_or_else(|| anyhow!("missing operation"))?;
+
+        let kind = match operation.as_str() {
+            "update" => WorkflowStepEditKind::Update {
+                search: search.ok_or_else(|| anyhow!("missing search"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "insert_before" => WorkflowStepEditKind::InsertBefore {
+                search: search.ok_or_else(|| anyhow!("missing search"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "insert_after" => WorkflowStepEditKind::InsertAfter {
+                search: search.ok_or_else(|| anyhow!("missing search"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "delete" => WorkflowStepEditKind::Delete {
+                search: search.ok_or_else(|| anyhow!("missing search"))?,
+            },
+            "create" => WorkflowStepEditKind::Create {
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            _ => Err(anyhow!("unknown operation {operation:?}"))?,
+        };
+
+        Ok(Self { path, kind })
+    }
+
+    pub async fn resolve(
+        &self,
+        project: Model<Project>,
+        mut cx: AsyncAppContext,
+    ) -> Result<(Model<Buffer>, super::WorkflowSuggestion)> {
+        let path = self.path.clone();
+        let kind = self.kind.clone();
+        let buffer = project
+            .update(&mut cx, |project, cx| {
+                let project_path = project
+                    .find_project_path(Path::new(&path), cx)
+                    .or_else(|| {
+                        // If we couldn't find a project path for it, put it in the active worktree
+                        // so that when we create the buffer, it can be saved.
+                        let worktree = project
+                            .active_entry()
+                            .and_then(|entry_id| project.worktree_for_entry(entry_id, cx))
+                            .or_else(|| project.worktrees(cx).next())?;
+                        let worktree = worktree.read(cx);
+
+                        Some(ProjectPath {
+                            worktree_id: worktree.id(),
+                            path: Arc::from(Path::new(&path)),
+                        })
+                    })
+                    .with_context(|| format!("worktree not found for {:?}", path))?;
+                anyhow::Ok(project.open_buffer(project_path, cx))
+            })??
+            .await?;
+
+        let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
+        let suggestion = cx
+            .background_executor()
+            .spawn(async move {
+                match kind {
+                    WorkflowStepEditKind::Update {
+                        search,
+                        description,
+                    } => {
+                        let range = Self::resolve_location(&snapshot, &search);
+                        WorkflowSuggestion::Update { range, description }
+                    }
+                    WorkflowStepEditKind::Create { description } => {
+                        WorkflowSuggestion::CreateFile { description }
+                    }
+                    WorkflowStepEditKind::InsertBefore {
+                        search,
+                        description,
+                    } => {
+                        let range = Self::resolve_location(&snapshot, &search);
+                        WorkflowSuggestion::InsertBefore {
+                            position: range.start,
+                            description,
+                        }
+                    }
+                    WorkflowStepEditKind::InsertAfter {
+                        search,
+                        description,
+                    } => {
+                        let range = Self::resolve_location(&snapshot, &search);
+                        WorkflowSuggestion::InsertAfter {
+                            position: range.end,
+                            description,
+                        }
+                    }
+                    WorkflowStepEditKind::Delete { search } => {
+                        let range = Self::resolve_location(&snapshot, &search);
+                        WorkflowSuggestion::Delete { range }
+                    }
+                }
+            })
+            .await;
+
+        Ok((buffer, suggestion))
+    }
+
+    fn resolve_location(buffer: &text::BufferSnapshot, search_query: &str) -> Range<text::Anchor> {
+        const INSERTION_SCORE: f64 = -1.0;
+        const DELETION_SCORE: f64 = -1.0;
+        const REPLACEMENT_SCORE: f64 = -1.0;
+        const EQUALITY_SCORE: f64 = 5.0;
+
+        struct Matrix {
+            cols: usize,
+            data: Vec<f64>,
+        }
+
+        impl Matrix {
+            fn new(rows: usize, cols: usize) -> Self {
+                Matrix {
+                    cols,
+                    data: vec![0.0; rows * cols],
+                }
+            }
+
+            fn get(&self, row: usize, col: usize) -> f64 {
+                self.data[row * self.cols + col]
+            }
+
+            fn set(&mut self, row: usize, col: usize, value: f64) {
+                self.data[row * self.cols + col] = value;
+            }
+        }
+
+        let buffer_len = buffer.len();
+        let query_len = search_query.len();
+        let mut matrix = Matrix::new(query_len + 1, buffer_len + 1);
+
+        for (i, query_byte) in search_query.bytes().enumerate() {
+            for (j, buffer_byte) in buffer.bytes_in_range(0..buffer.len()).flatten().enumerate() {
+                let match_score = if query_byte == *buffer_byte {
+                    EQUALITY_SCORE
+                } else {
+                    REPLACEMENT_SCORE
+                };
+                let up = matrix.get(i + 1, j) + DELETION_SCORE;
+                let left = matrix.get(i, j + 1) + INSERTION_SCORE;
+                let diagonal = matrix.get(i, j) + match_score;
+                let score = up.max(left.max(diagonal)).max(0.);
+                matrix.set(i + 1, j + 1, score);
+            }
+        }
+
+        // Traceback to find the best match
+        let mut best_buffer_end = buffer_len;
+        let mut best_score = 0.0;
+        for col in 1..=buffer_len {
+            let score = matrix.get(query_len, col);
+            if score > best_score {
+                best_score = score;
+                best_buffer_end = col;
+            }
+        }
+
+        let mut query_ix = query_len;
+        let mut buffer_ix = best_buffer_end;
+        while query_ix > 0 && buffer_ix > 0 {
+            let current = matrix.get(query_ix, buffer_ix);
+            let up = matrix.get(query_ix - 1, buffer_ix);
+            let left = matrix.get(query_ix, buffer_ix - 1);
+            if current == left + INSERTION_SCORE {
+                buffer_ix -= 1;
+            } else if current == up + DELETION_SCORE {
+                query_ix -= 1;
+            } else {
+                query_ix -= 1;
+                buffer_ix -= 1;
+            }
+        }
+
+        let mut start = buffer.offset_to_point(buffer.clip_offset(buffer_ix, Bias::Left));
+        start.column = 0;
+        let mut end = buffer.offset_to_point(buffer.clip_offset(best_buffer_end, Bias::Right));
+        end.column = buffer.line_len(end.row);
+
+        buffer.anchor_after(start)..buffer.anchor_before(end)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "operation")]
+pub enum WorkflowStepEditKind {
+    /// Rewrites the specified text entirely based on the given description.
+    /// This operation completely replaces the given text.
+    Update {
+        /// A string in the source text to apply the update to.
+        search: String,
+        /// A brief description of the transformation to apply to the symbol.
+        description: String,
+    },
+    /// Creates a new file with the given path based on the provided description.
+    /// This operation adds a new file to the codebase.
+    Create {
+        /// A brief description of the file to be created.
+        description: String,
+    },
+    /// Inserts text before the specified text in the source file.
+    InsertBefore {
+        /// A string in the source text to insert text before.
+        search: String,
+        /// A brief description of how the new text should be generated.
+        description: String,
+    },
+    /// Inserts text after the specified text in the source file.
+    InsertAfter {
+        /// A string in the source text to insert text after.
+        search: String,
+        /// A brief description of how the new text should be generated.
+        description: String,
+    },
+    /// Deletes the specified symbol from the containing file.
+    Delete {
+        /// A string in the source text to delete.
+        search: String,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{AppContext, Context};
+    use text::{OffsetRangeExt, Point};
+
+    #[gpui::test]
+    fn test_resolve_location(cx: &mut AppContext) {
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "    Lorem\n",
+                        "    ipsum\n",
+                        "    dolor sit amet\n",
+                        "    consecteur",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                WorkflowStepEdit::resolve_location(&snapshot, "ipsum\ndolor").to_point(&snapshot),
+                Point::new(1, 0)..Point::new(2, 18)
+            );
+        }
+
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn foo1(a: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                WorkflowStepEdit::resolve_location(&snapshot, "fn foo1(b: usize) {\n42\n}")
+                    .to_point(&snapshot),
+                Point::new(0, 0)..Point::new(2, 1)
+            );
+        }
+
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn main() {\n",
+                        "    Foo\n",
+                        "        .bar()\n",
+                        "        .baz()\n",
+                        "        .qux()\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                WorkflowStepEdit::resolve_location(&snapshot, "Foo.bar.baz.qux()")
+                    .to_point(&snapshot),
+                Point::new(1, 0)..Point::new(4, 14)
+            );
+        }
+    }
+}

crates/client/src/client.rs

@@ -4,7 +4,6 @@ pub mod test;
 mod socks;
 pub mod telemetry;
 pub mod user;
-pub mod zed_urls;
 
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_recursion::async_recursion;

crates/client/src/zed_urls.rs

@@ -1,19 +0,0 @@
-//! Contains helper functions for constructing URLs to various Zed-related pages.
-//!
-//! These URLs will adapt to the configured server URL in order to construct
-//! links appropriate for the environment (e.g., by linking to a local copy of
-//! zed.dev in development).
-
-use gpui::AppContext;
-use settings::Settings;
-
-use crate::ClientSettings;
-
-fn server_url(cx: &AppContext) -> &str {
-    &ClientSettings::get_global(cx).server_url
-}
-
-/// Returns the URL to the account page on zed.dev.
-pub fn account_url(cx: &AppContext) -> String {
-    format!("{server_url}/account", server_url = server_url(cx))
-}

crates/collab/src/cents.rs

@@ -10,8 +10,6 @@
     Copy,
     derive_more::Add,
     derive_more::AddAssign,
-    derive_more::Sub,
-    derive_more::SubAssign,
 )]
 pub struct Cents(pub u32);
 

crates/collab/src/lib.rs

@@ -198,6 +198,10 @@ impl Config {
         }
     }
 
+    pub fn is_llm_billing_enabled(&self) -> bool {
+        self.stripe_api_key.is_some()
+    }
+
     #[cfg(test)]
     pub fn test() -> Self {
         Self {

crates/collab/src/llm.rs

@@ -21,24 +21,6 @@ use axum::{
 use chrono::{DateTime, Duration, Utc};
 use collections::HashMap;
 use db::TokenUsage;
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub struct ComputeEmbeddingsRequest {
-    pub model: String,
-    pub texts: Vec<String>,
-}
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub struct ComputeEmbeddingsResponse {
-    pub embeddings: Vec<Embedding>,
-}
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub struct Embedding {
-    pub digest: Vec<u8>,
-    pub dimensions: Vec<f32>,
-}
-
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
 use reqwest_client::ReqwestClient;
@@ -46,7 +28,6 @@ use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
 };
 use rpc::{ListModelsResponse, MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME};
-use sha2::Sha256;
 use std::{
     pin::Pin,
     sync::Arc,
@@ -132,79 +113,10 @@ impl LlmState {
     }
 }
 
-async fn compute_embeddings_http(
-    Extension(state): Extension<Arc<LlmState>>,
-    Extension(claims): Extension<LlmTokenClaims>,
-    Json(request): Json<proto::ComputeEmbeddings>,
-) -> Result<impl IntoResponse> {
-    let api_key = state
-        .config
-        .openai_api_key
-        .as_ref()
-        .context("no OpenAI API key configured on the server")?;
-
-    let rate_limit: Box<dyn RateLimit> = match claims.plan {
-        proto::Plan::ZedPro => Box::new(ZedProComputeEmbeddingsRateLimit),
-        proto::Plan::Free => Box::new(FreeComputeEmbeddingsRateLimit),
-    };
-
-    state
-        .app_state
-        .rate_limiter
-        .check(&*rate_limit, UserId::from_proto(claims.user_id))
-        .await?;
-
-    let embeddings = match request.model.as_str() {
-        "openai/text-embedding-3-small" => {
-            open_ai::embed(
-                &state.http_client,
-                OPEN_AI_API_URL,
-                api_key,
-                OpenAiEmbeddingModel::TextEmbedding3Small,
-                request.texts.iter().map(|text| text.as_str()),
-            )
-            .await?
-        }
-        provider => return Err(anyhow!("unsupported embedding provider {:?}", provider))?,
-    };
-
-    let embeddings = request
-        .texts
-        .iter()
-        .map(|text| {
-            let mut hasher = Sha256::new();
-            hasher.update(text.as_bytes());
-            let result = hasher.finalize();
-            result.to_vec()
-        })
-        .zip(
-            embeddings
-                .data
-                .into_iter()
-                .map(|embedding| embedding.embedding),
-        )
-        .collect::<HashMap<_, _>>();
-
-    state
-        .db
-        .save_embeddings(&request.model, &embeddings)
-        .await
-        .context("failed to save embeddings")
-        .trace_err();
-
-    Ok(Json(proto::ComputeEmbeddingsResponse {
-        embeddings: embeddings
-            .into_iter()
-            .map(|(digest, dimensions)| proto::Embedding { digest, dimensions })
-            .collect(),
-    }))
-}
-
 pub fn routes() -> Router<(), Body> {
     Router::new()
         .route("/models", get(list_models))
         .route("/completion", post(perform_completion))
-        .route("/compute_embeddings", post(compute_embeddings_http))
         .layer(middleware::from_fn(validate_api_token))
 }
 
@@ -548,27 +460,27 @@ async fn check_usage_limit(
         )
         .await?;
 
-    if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
-        if !claims.has_llm_subscription {
-            return Err(Error::http(
-                StatusCode::PAYMENT_REQUIRED,
-                "Maximum spending limit reached for this month.".to_string(),
-            ));
-        }
+    if state.config.is_llm_billing_enabled() {
+        if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
+            if !claims.has_llm_subscription {
+                return Err(Error::http(
+                    StatusCode::PAYMENT_REQUIRED,
+                    "Maximum spending limit reached for this month.".to_string(),
+                ));
+            }
 
-        if (usage.spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT)
-            >= Cents(claims.max_monthly_spend_in_cents)
-        {
-            return Err(Error::Http(
-                StatusCode::FORBIDDEN,
-                "Maximum spending limit reached for this month.".to_string(),
-                [(
-                    HeaderName::from_static(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME),
-                    HeaderValue::from_static("true"),
-                )]
-                .into_iter()
-                .collect(),
-            ));
+            if usage.spending_this_month >= Cents(claims.max_monthly_spend_in_cents) {
+                return Err(Error::Http(
+                    StatusCode::FORBIDDEN,
+                    "Maximum spending limit reached for this month.".to_string(),
+                    [(
+                        HeaderName::from_static(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME),
+                        HeaderValue::from_static("true"),
+                    )]
+                    .into_iter()
+                    .collect(),
+                ));
+            }
         }
     }
 
@@ -713,6 +625,7 @@ where
 impl<S> Drop for TokenCountingStream<S> {
     fn drop(&mut self) {
         let state = self.state.clone();
+        let is_llm_billing_enabled = state.config.is_llm_billing_enabled();
         let claims = self.claims.clone();
         let provider = self.provider;
         let model = std::mem::take(&mut self.model);
@@ -726,7 +639,14 @@ impl<S> Drop for TokenCountingStream<S> {
                     provider,
                     &model,
                     tokens,
-                    claims.has_llm_subscription,
+                    // We're passing `false` here if LLM billing is not enabled
+                    // so that we don't write any records to the
+                    // `billing_events` table until we're ready to bill users.
+                    if is_llm_billing_enabled {
+                        claims.has_llm_subscription
+                    } else {
+                        false
+                    },
                     Cents(claims.max_monthly_spend_in_cents),
                     Utc::now(),
                 )

crates/collab/src/llm/db/queries/usages.rs

@@ -412,7 +412,7 @@ impl LlmDatabase {
             if !is_staff
                 && spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT
                 && has_llm_subscription
-                && (spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT) <= max_monthly_spend
+                && spending_this_month <= max_monthly_spend
             {
                 billing_event::ActiveModel {
                     id: ActiveValue::not_set(),

crates/collab/src/llm/db/tests/billing_tests.rs

@@ -1,7 +1,10 @@
 use crate::{
     db::UserId,
     llm::{
-        db::{queries::providers::ModelParams, LlmDatabase, TokenUsage},
+        db::{
+            queries::{providers::ModelParams, usages::Usage},
+            LlmDatabase, TokenUsage,
+        },
         FREE_TIER_MONTHLY_SPENDING_LIMIT,
     },
     test_llm_db, Cents,
@@ -73,9 +76,29 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
 
     // Verify the recorded usage and spending
     let recorded_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+
     // Verify that we exceeded the free tier usage
-    assert_eq!(recorded_usage.spending_this_month, Cents::new(1050));
-    assert!(recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT);
+    assert!(
+        recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT,
+        "Expected spending to exceed free tier limit"
+    );
+
+    assert_eq!(
+        recorded_usage,
+        Usage {
+            requests_this_minute: 1,
+            tokens_this_minute: tokens_to_use,
+            tokens_this_day: tokens_to_use,
+            tokens_this_month: TokenUsage {
+                input: tokens_to_use,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
+            spending_this_month: Cents::new(1050),
+            lifetime_spending: Cents::new(1050),
+        }
+    );
 
     // Verify that there is one `billing_event` record
     let billing_events = db.get_billing_events().await.unwrap();
@@ -88,35 +111,7 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
     assert_eq!(billing_event.input_cache_read_tokens, 0);
     assert_eq!(billing_event.output_tokens, 0);
 
-    // Record usage that puts us at $20.50
-    let usage_2 = TokenUsage {
-        input: 200_000_000, // This will cost $10 more, pushing us from $10.50 to $20.50,
-        input_cache_creation: 0,
-        input_cache_read: 0,
-        output: 0,
-    };
-    db.record_usage(
-        user_id,
-        false,
-        provider,
-        model,
-        usage_2,
-        true,
-        max_monthly_spend,
-        now,
-    )
-    .await
-    .unwrap();
-
-    // Verify the updated usage and spending
-    let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
-    assert_eq!(updated_usage.spending_this_month, Cents::new(2050));
-
-    // Verify that there are now two billing events
-    let billing_events = db.get_billing_events().await.unwrap();
-    assert_eq!(billing_events.len(), 2);
-
-    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $20.50 to $21.50, which is over the $11 monthly maximum limit
+    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $10.50 to $11.50, which is over the $11 monthly maximum limit
     let usage_exceeding = TokenUsage {
         input: tokens_to_exceed,
         input_cache_creation: 0,
@@ -137,12 +132,27 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
     )
     .await
     .unwrap();
+
+    // Verify that there is still one billing record
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 1);
+
     // Verify the updated usage and spending
     let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
-    assert_eq!(updated_usage.spending_this_month, Cents::new(2150));
-
-    // Verify that we never exceed the user max spending for the user
-    // and avoid charging them.
-    let billing_events = db.get_billing_events().await.unwrap();
-    assert_eq!(billing_events.len(), 2);
+    assert_eq!(
+        updated_usage,
+        Usage {
+            requests_this_minute: 2,
+            tokens_this_minute: tokens_to_use + tokens_to_exceed,
+            tokens_this_day: tokens_to_use + tokens_to_exceed,
+            tokens_this_month: TokenUsage {
+                input: tokens_to_use + tokens_to_exceed,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
+            spending_this_month: Cents::new(1150),
+            lifetime_spending: Cents::new(1150),
+        }
+    );
 }

crates/collab/src/stripe_billing.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::{llm, Cents, Result};
 use anyhow::Context;
-use chrono::{Datelike, Utc};
+use chrono::Utc;
 use collections::HashMap;
 use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
@@ -349,20 +349,10 @@ impl StripeBilling {
         model: &StripeModel,
         success_url: &str,
     ) -> Result<String> {
-        let first_of_next_month = Utc::now()
-            .checked_add_months(chrono::Months::new(1))
-            .unwrap()
-            .with_day(1)
-            .unwrap();
-
         let mut params = stripe::CreateCheckoutSession::new();
         params.mode = Some(stripe::CheckoutSessionMode::Subscription);
         params.customer = Some(customer_id);
         params.client_reference_id = Some(github_login);
-        params.subscription_data = Some(stripe::CreateCheckoutSessionSubscriptionData {
-            billing_cycle_anchor: Some(first_of_next_month.timestamp()),
-            ..Default::default()
-        });
         params.line_items = Some(
             [
                 &model.input_tokens_price.id,

crates/diagnostics/src/diagnostics_tests.rs

@@ -962,6 +962,7 @@ fn random_diagnostic(
 
 const FILE_HEADER: &str = "file header";
 const EXCERPT_HEADER: &str = "excerpt header";
+const EXCERPT_FOOTER: &str = "excerpt footer";
 
 fn editor_blocks(
     editor: &View<Editor>,
@@ -997,7 +998,7 @@ fn editor_blocks(
                                     .ok()?
                             }
 
-                            Block::ExcerptBoundary {
+                            Block::ExcerptHeader {
                                 starts_new_buffer, ..
                             } => {
                                 if *starts_new_buffer {
@@ -1006,6 +1007,7 @@ fn editor_blocks(
                                     EXCERPT_HEADER.into()
                                 }
                             }
+                            Block::ExcerptFooter { .. } => EXCERPT_FOOTER.into(),
                         };
 
                         Some((row, name))

crates/editor/src/display_map/block_map.rs

@@ -5,8 +5,8 @@ use super::{
 use crate::{EditorStyle, GutterDimensions};
 use collections::{Bound, HashMap, HashSet};
 use gpui::{AnyElement, EntityId, Pixels, WindowContext};
-use language::{Chunk, Patch, Point};
-use multi_buffer::{Anchor, ExcerptId, ExcerptInfo, MultiBufferRow, ToPoint as _};
+use language::{BufferSnapshot, Chunk, Patch, Point};
+use multi_buffer::{Anchor, ExcerptId, ExcerptRange, MultiBufferRow, ToPoint as _};
 use parking_lot::Mutex;
 use std::{
     cell::RefCell,
@@ -128,17 +128,26 @@ pub struct BlockContext<'a, 'b> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum BlockId {
     Custom(CustomBlockId),
-    ExcerptBoundary(Option<ExcerptId>),
+    ExcerptHeader(ExcerptId),
+    ExcerptFooter(ExcerptId),
+}
+
+impl From<BlockId> for EntityId {
+    fn from(value: BlockId) -> Self {
+        match value {
+            BlockId::Custom(CustomBlockId(id)) => EntityId::from(id as u64),
+            BlockId::ExcerptHeader(id) => id.into(),
+            BlockId::ExcerptFooter(id) => id.into(),
+        }
+    }
 }
 
 impl From<BlockId> for ElementId {
     fn from(value: BlockId) -> Self {
         match value {
             BlockId::Custom(CustomBlockId(id)) => ("Block", id).into(),
-            BlockId::ExcerptBoundary(next_excerpt) => match next_excerpt {
-                Some(id) => ("ExcerptBoundary", EntityId::from(id)).into(),
-                None => "LastExcerptBoundary".into(),
-            },
+            BlockId::ExcerptHeader(id) => ("ExcerptHeader", EntityId::from(id)).into(),
+            BlockId::ExcerptFooter(id) => ("ExcerptFooter", EntityId::from(id)).into(),
         }
     }
 }
@@ -147,7 +156,8 @@ impl std::fmt::Display for BlockId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Custom(id) => write!(f, "Block({id:?})"),
-            Self::ExcerptBoundary(id) => write!(f, "ExcerptHeader({id:?})"),
+            Self::ExcerptHeader(id) => write!(f, "ExcerptHeader({id:?})"),
+            Self::ExcerptFooter(id) => write!(f, "ExcerptFooter({id:?})"),
         }
     }
 }
@@ -167,7 +177,8 @@ struct Transform {
 
 pub(crate) enum BlockType {
     Custom(CustomBlockId),
-    ExcerptBoundary,
+    Header,
+    Footer,
 }
 
 pub(crate) trait BlockLike {
@@ -180,20 +191,27 @@ pub(crate) trait BlockLike {
 #[derive(Clone)]
 pub enum Block {
     Custom(Arc<CustomBlock>),
-    ExcerptBoundary {
-        prev_excerpt: Option<ExcerptInfo>,
-        next_excerpt: Option<ExcerptInfo>,
+    ExcerptHeader {
+        id: ExcerptId,
+        buffer: BufferSnapshot,
+        range: ExcerptRange<text::Anchor>,
         height: u32,
         starts_new_buffer: bool,
         show_excerpt_controls: bool,
     },
+    ExcerptFooter {
+        id: ExcerptId,
+        disposition: BlockDisposition,
+        height: u32,
+    },
 }
 
 impl BlockLike for Block {
     fn block_type(&self) -> BlockType {
         match self {
             Block::Custom(block) => BlockType::Custom(block.id),
-            Block::ExcerptBoundary { .. } => BlockType::ExcerptBoundary,
+            Block::ExcerptHeader { .. } => BlockType::Header,
+            Block::ExcerptFooter { .. } => BlockType::Footer,
         }
     }
 
@@ -204,7 +222,8 @@ impl BlockLike for Block {
     fn priority(&self) -> usize {
         match self {
             Block::Custom(block) => block.priority,
-            Block::ExcerptBoundary { .. } => usize::MAX,
+            Block::ExcerptHeader { .. } => usize::MAX,
+            Block::ExcerptFooter { .. } => 0,
         }
     }
 }
@@ -213,36 +232,32 @@ impl Block {
     pub fn id(&self) -> BlockId {
         match self {
             Block::Custom(block) => BlockId::Custom(block.id),
-            Block::ExcerptBoundary { next_excerpt, .. } => {
-                BlockId::ExcerptBoundary(next_excerpt.as_ref().map(|info| info.id))
-            }
+            Block::ExcerptHeader { id, .. } => BlockId::ExcerptHeader(*id),
+            Block::ExcerptFooter { id, .. } => BlockId::ExcerptFooter(*id),
         }
     }
 
     fn disposition(&self) -> BlockDisposition {
         match self {
             Block::Custom(block) => block.disposition,
-            Block::ExcerptBoundary { next_excerpt, .. } => {
-                if next_excerpt.is_some() {
-                    BlockDisposition::Above
-                } else {
-                    BlockDisposition::Below
-                }
-            }
+            Block::ExcerptHeader { .. } => BlockDisposition::Above,
+            Block::ExcerptFooter { disposition, .. } => *disposition,
         }
     }
 
     pub fn height(&self) -> u32 {
         match self {
             Block::Custom(block) => block.height,
-            Block::ExcerptBoundary { height, .. } => *height,
+            Block::ExcerptHeader { height, .. } => *height,
+            Block::ExcerptFooter { height, .. } => *height,
         }
     }
 
     pub fn style(&self) -> BlockStyle {
         match self {
             Block::Custom(block) => block.style,
-            Block::ExcerptBoundary { .. } => BlockStyle::Sticky,
+            Block::ExcerptHeader { .. } => BlockStyle::Sticky,
+            Block::ExcerptFooter { .. } => BlockStyle::Sticky,
         }
     }
 }
@@ -251,17 +266,24 @@ impl Debug for Block {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Custom(block) => f.debug_struct("Custom").field("block", block).finish(),
-            Self::ExcerptBoundary {
+            Self::ExcerptHeader {
+                buffer,
                 starts_new_buffer,
-                next_excerpt,
-                prev_excerpt,
+                id,
                 ..
             } => f
-                .debug_struct("ExcerptBoundary")
-                .field("prev_excerpt", &prev_excerpt)
-                .field("next_excerpt", &next_excerpt)
+                .debug_struct("ExcerptHeader")
+                .field("id", &id)
+                .field("path", &buffer.file().map(|f| f.path()))
                 .field("starts_new_buffer", &starts_new_buffer)
                 .finish(),
+            Block::ExcerptFooter {
+                id, disposition, ..
+            } => f
+                .debug_struct("ExcerptFooter")
+                .field("id", &id)
+                .field("disposition", &disposition)
+                .finish(),
         }
     }
 }
@@ -573,62 +595,66 @@ impl BlockMap {
     {
         buffer
             .excerpt_boundaries_in_range(range)
-            .filter_map(move |excerpt_boundary| {
-                let wrap_row;
-                if excerpt_boundary.next.is_some() {
-                    wrap_row = wrap_snapshot
-                        .make_wrap_point(Point::new(excerpt_boundary.row.0, 0), Bias::Left)
-                        .row();
-                } else {
-                    wrap_row = wrap_snapshot
-                        .make_wrap_point(
-                            Point::new(
-                                excerpt_boundary.row.0,
-                                buffer.line_len(excerpt_boundary.row),
-                            ),
-                            Bias::Left,
+            .flat_map(move |excerpt_boundary| {
+                let mut wrap_row = wrap_snapshot
+                    .make_wrap_point(Point::new(excerpt_boundary.row.0, 0), Bias::Left)
+                    .row();
+
+                [
+                    show_excerpt_controls
+                        .then(|| {
+                            let disposition;
+                            if excerpt_boundary.next.is_some() {
+                                disposition = BlockDisposition::Above;
+                            } else {
+                                wrap_row = wrap_snapshot
+                                    .make_wrap_point(
+                                        Point::new(
+                                            excerpt_boundary.row.0,
+                                            buffer.line_len(excerpt_boundary.row),
+                                        ),
+                                        Bias::Left,
+                                    )
+                                    .row();
+                                disposition = BlockDisposition::Below;
+                            }
+
+                            excerpt_boundary.prev.as_ref().map(|prev| {
+                                (
+                                    wrap_row,
+                                    Block::ExcerptFooter {
+                                        id: prev.id,
+                                        height: excerpt_footer_height,
+                                        disposition,
+                                    },
+                                )
+                            })
+                        })
+                        .flatten(),
+                    excerpt_boundary.next.map(|next| {
+                        let starts_new_buffer = excerpt_boundary
+                            .prev
+                            .map_or(true, |prev| prev.buffer_id != next.buffer_id);
+
+                        (
+                            wrap_row,
+                            Block::ExcerptHeader {
+                                id: next.id,
+                                buffer: next.buffer,
+                                range: next.range,
+                                height: if starts_new_buffer {
+                                    buffer_header_height
+                                } else {
+                                    excerpt_header_height
+                                },
+                                starts_new_buffer,
+                                show_excerpt_controls,
+                            },
                         )
-                        .row();
-                }
-
-                let starts_new_buffer = match (&excerpt_boundary.prev, &excerpt_boundary.next) {
-                    (_, None) => false,
-                    (None, Some(_)) => true,
-                    (Some(prev), Some(next)) => prev.buffer_id != next.buffer_id,
-                };
-
-                let mut height = 0;
-                if excerpt_boundary.prev.is_some() {
-                    if show_excerpt_controls {
-                        height += excerpt_footer_height;
-                    }
-                }
-                if excerpt_boundary.next.is_some() {
-                    if starts_new_buffer {
-                        height += buffer_header_height;
-                        if show_excerpt_controls {
-                            height += excerpt_header_height;
-                        }
-                    } else {
-                        height += excerpt_header_height;
-                    }
-                }
-
-                if height == 0 {
-                    return None;
-                }
-
-                Some((
-                    wrap_row,
-                    Block::ExcerptBoundary {
-                        prev_excerpt: excerpt_boundary.prev,
-                        next_excerpt: excerpt_boundary.next,
-                        height,
-                        starts_new_buffer,
-                        show_excerpt_controls,
-                    },
-                ))
+                    }),
+                ]
             })
+            .flatten()
     }
 
     pub(crate) fn sort_blocks<B: BlockLike>(blocks: &mut [(u32, B)]) {
@@ -639,9 +665,12 @@ impl BlockMap {
                     .disposition()
                     .cmp(&block_b.disposition())
                     .then_with(|| match ((block_a.block_type()), (block_b.block_type())) {
-                        (BlockType::ExcerptBoundary, BlockType::ExcerptBoundary) => Ordering::Equal,
-                        (BlockType::ExcerptBoundary, _) => Ordering::Less,
-                        (_, BlockType::ExcerptBoundary) => Ordering::Greater,
+                        (BlockType::Footer, BlockType::Footer) => Ordering::Equal,
+                        (BlockType::Footer, _) => Ordering::Less,
+                        (_, BlockType::Footer) => Ordering::Greater,
+                        (BlockType::Header, BlockType::Header) => Ordering::Equal,
+                        (BlockType::Header, _) => Ordering::Less,
+                        (_, BlockType::Header) => Ordering::Greater,
                         (BlockType::Custom(a_id), BlockType::Custom(b_id)) => block_b
                             .priority()
                             .cmp(&block_a.priority())
@@ -1016,19 +1045,33 @@ impl BlockSnapshot {
                 let custom_block = self.custom_blocks_by_id.get(&custom_block_id)?;
                 Some(Block::Custom(custom_block.clone()))
             }
-            BlockId::ExcerptBoundary(next_excerpt_id) => {
-                let wrap_point;
-                if let Some(next_excerpt_id) = next_excerpt_id {
-                    let excerpt_range = buffer.range_for_excerpt::<Point>(next_excerpt_id)?;
-                    wrap_point = self
-                        .wrap_snapshot
-                        .make_wrap_point(excerpt_range.start, Bias::Left);
-                } else {
-                    wrap_point = self
-                        .wrap_snapshot
-                        .make_wrap_point(buffer.max_point(), Bias::Left);
+            BlockId::ExcerptHeader(excerpt_id) => {
+                let excerpt_range = buffer.range_for_excerpt::<Point>(excerpt_id)?;
+                let wrap_point = self
+                    .wrap_snapshot
+                    .make_wrap_point(excerpt_range.start, Bias::Left);
+                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
+                cursor.seek(&WrapRow(wrap_point.row()), Bias::Left, &());
+                while let Some(transform) = cursor.item() {
+                    if let Some(block) = transform.block.as_ref() {
+                        if block.id() == block_id {
+                            return Some(block.clone());
+                        }
+                    } else if cursor.start().0 > WrapRow(wrap_point.row()) {
+                        break;
+                    }
+
+                    cursor.next(&());
                 }
 
+                None
+            }
+            BlockId::ExcerptFooter(excerpt_id) => {
+                let excerpt_range = buffer.range_for_excerpt::<Point>(excerpt_id)?;
+                let wrap_point = self
+                    .wrap_snapshot
+                    .make_wrap_point(excerpt_range.end, Bias::Left);
+
                 let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
                 cursor.seek(&WrapRow(wrap_point.row()), Bias::Left, &());
                 while let Some(transform) = cursor.item() {
@@ -1425,7 +1468,7 @@ mod tests {
     };
     use gpui::{div, font, px, AppContext, Context as _, Element};
     use language::{Buffer, Capability};
-    use multi_buffer::{ExcerptRange, MultiBuffer};
+    use multi_buffer::MultiBuffer;
     use rand::prelude::*;
     use settings::SettingsStore;
     use std::env;
@@ -1681,20 +1724,22 @@ mod tests {
         // Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
         assert_eq!(
             snapshot.text(),
-            "\n\nBuff\ner 1\n\n\n\nBuff\ner 2\n\n\n\nBuff\ner 3\n"
+            "\nBuff\ner 1\n\n\nBuff\ner 2\n\n\nBuff\ner 3\n"
         );
 
         let blocks: Vec<_> = snapshot
             .blocks_in_range(0..u32::MAX)
-            .map(|(row, block)| (row..row + block.height(), block.id()))
+            .map(|(row, block)| (row, block.id()))
             .collect();
         assert_eq!(
             blocks,
             vec![
-                (0..2, BlockId::ExcerptBoundary(Some(excerpt_ids[0]))), // path, header
-                (4..7, BlockId::ExcerptBoundary(Some(excerpt_ids[1]))), // footer, path, header
-                (9..12, BlockId::ExcerptBoundary(Some(excerpt_ids[2]))), // footer, path, header
-                (14..15, BlockId::ExcerptBoundary(None)),               // footer
+                (0, BlockId::ExcerptHeader(excerpt_ids[0])),
+                (3, BlockId::ExcerptFooter(excerpt_ids[0])),
+                (4, BlockId::ExcerptHeader(excerpt_ids[1])),
+                (7, BlockId::ExcerptFooter(excerpt_ids[1])),
+                (8, BlockId::ExcerptHeader(excerpt_ids[2])),
+                (11, BlockId::ExcerptFooter(excerpt_ids[2]))
             ]
         );
     }
@@ -2238,10 +2283,13 @@ mod tests {
 
         #[derive(Debug, Eq, PartialEq)]
         enum ExpectedBlock {
-            ExcerptBoundary {
+            ExcerptHeader {
                 height: u32,
                 starts_new_buffer: bool,
-                is_last: bool,
+            },
+            ExcerptFooter {
+                height: u32,
+                disposition: BlockDisposition,
             },
             Custom {
                 disposition: BlockDisposition,
@@ -2255,7 +2303,8 @@ mod tests {
             fn block_type(&self) -> BlockType {
                 match self {
                     ExpectedBlock::Custom { id, .. } => BlockType::Custom(*id),
-                    ExpectedBlock::ExcerptBoundary { .. } => BlockType::ExcerptBoundary,
+                    ExpectedBlock::ExcerptHeader { .. } => BlockType::Header,
+                    ExpectedBlock::ExcerptFooter { .. } => BlockType::Footer,
                 }
             }
 
@@ -2266,7 +2315,8 @@ mod tests {
             fn priority(&self) -> usize {
                 match self {
                     ExpectedBlock::Custom { priority, .. } => *priority,
-                    ExpectedBlock::ExcerptBoundary { .. } => usize::MAX,
+                    ExpectedBlock::ExcerptHeader { .. } => usize::MAX,
+                    ExpectedBlock::ExcerptFooter { .. } => 0,
                 }
             }
         }
@@ -2274,21 +2324,17 @@ mod tests {
         impl ExpectedBlock {
             fn height(&self) -> u32 {
                 match self {
-                    ExpectedBlock::ExcerptBoundary { height, .. } => *height,
+                    ExpectedBlock::ExcerptHeader { height, .. } => *height,
                     ExpectedBlock::Custom { height, .. } => *height,
+                    ExpectedBlock::ExcerptFooter { height, .. } => *height,
                 }
             }
 
             fn disposition(&self) -> BlockDisposition {
                 match self {
-                    ExpectedBlock::ExcerptBoundary { is_last, .. } => {
-                        if *is_last {
-                            BlockDisposition::Below
-                        } else {
-                            BlockDisposition::Above
-                        }
-                    }
+                    ExpectedBlock::ExcerptHeader { .. } => BlockDisposition::Above,
                     ExpectedBlock::Custom { disposition, .. } => *disposition,
+                    ExpectedBlock::ExcerptFooter { disposition, .. } => *disposition,
                 }
             }
         }
@@ -2302,15 +2348,21 @@ mod tests {
                         height: block.height,
                         priority: block.priority,
                     },
-                    Block::ExcerptBoundary {
+                    Block::ExcerptHeader {
                         height,
                         starts_new_buffer,
-                        next_excerpt,
                         ..
-                    } => ExpectedBlock::ExcerptBoundary {
+                    } => ExpectedBlock::ExcerptHeader {
                         height,
                         starts_new_buffer,
-                        is_last: next_excerpt.is_none(),
+                    },
+                    Block::ExcerptFooter {
+                        height,
+                        disposition,
+                        ..
+                    } => ExpectedBlock::ExcerptFooter {
+                        height,
+                        disposition,
                     },
                 }
             }
@@ -2328,7 +2380,8 @@ mod tests {
         fn as_custom(&self) -> Option<&CustomBlock> {
             match self {
                 Block::Custom(block) => Some(block),
-                Block::ExcerptBoundary { .. } => None,
+                Block::ExcerptHeader { .. } => None,
+                Block::ExcerptFooter { .. } => None,
             }
         }
     }

crates/editor/src/editor.rs

@@ -48,6 +48,7 @@ mod signature_help;
 pub mod test;
 
 use ::git::diff::DiffHunkStatus;
+use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 pub(crate) use actions::*;
 use aho_corasick::AhoCorasick;
 use anyhow::{anyhow, Context as _, Result};
@@ -73,12 +74,12 @@ use git::blame::GitBlame;
 use gpui::{
     div, impl_actions, point, prelude::*, px, relative, size, uniform_list, Action, AnyElement,
     AppContext, AsyncWindowContext, AvailableSpace, BackgroundExecutor, Bounds, ClipboardEntry,
-    ClipboardItem, Context, DispatchPhase, ElementId, EventEmitter, FocusHandle, FocusOutEvent,
-    FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText, KeyContext,
-    ListSizingBehavior, Model, MouseButton, PaintQuad, ParentElement, Pixels, Render, SharedString,
-    Size, StrikethroughStyle, Styled, StyledText, Subscription, Task, TextStyle, UTF16Selection,
-    UnderlineStyle, UniformListScrollHandle, View, ViewContext, ViewInputHandler, VisualContext,
-    WeakFocusHandle, WeakView, WindowContext,
+    ClipboardItem, Context, DispatchPhase, ElementId, EntityId, EventEmitter, FocusHandle,
+    FocusOutEvent, FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText,
+    KeyContext, ListSizingBehavior, Model, MouseButton, PaintQuad, ParentElement, Pixels, Render,
+    SharedString, Size, StrikethroughStyle, Styled, StyledText, Subscription, Task, TextStyle,
+    UTF16Selection, UnderlineStyle, UniformListScrollHandle, View, ViewContext, ViewInputHandler,
+    VisualContext, WeakFocusHandle, WeakView, WindowContext,
 };
 use highlight_matching_bracket::refresh_matching_bracket_highlights;
 use hover_popover::{hide_hover, HoverState};
@@ -100,7 +101,7 @@ use language::{
 };
 use linked_editing_ranges::refresh_linked_ranges;
 pub use proposed_changes_editor::{
-    ProposedChangeLocation, ProposedChangesEditor, ProposedChangesEditorToolbar,
+    ProposedChangesBuffer, ProposedChangesEditor, ProposedChangesEditorToolbar,
 };
 use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
@@ -171,7 +172,7 @@ use workspace::{Item as WorkspaceItem, OpenInTerminal, OpenTerminal, TabBarSetti
 use crate::hover_links::find_url;
 use crate::signature_help::{SignatureHelpHiddenBy, SignatureHelpState};
 
-pub const FILE_HEADER_HEIGHT: u32 = 2;
+pub const FILE_HEADER_HEIGHT: u32 = 1;
 pub const MULTI_BUFFER_EXCERPT_HEADER_HEIGHT: u32 = 1;
 pub const MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT: u32 = 1;
 pub const DEFAULT_MULTIBUFFER_CONTEXT: u32 = 2;
@@ -640,6 +641,7 @@ pub struct Editor {
     tasks: BTreeMap<(BufferId, BufferRow), RunnableTasks>,
     tasks_update_task: Option<Task<()>>,
     previous_search_ranges: Option<Arc<[Range<Anchor>]>>,
+    file_header_size: u32,
     breadcrumb_header: Option<String>,
     focused_block: Option<FocusedBlock>,
     next_scroll_position: NextScrollCursorCenterTopBottom,
@@ -1845,6 +1847,7 @@ impl Editor {
             }),
             merge_adjacent: true,
         };
+        let file_header_size = if show_excerpt_controls { 3 } else { 2 };
         let display_map = cx.new_model(|cx| {
             DisplayMap::new(
                 buffer.clone(),
@@ -1852,7 +1855,7 @@ impl Editor {
                 font_size,
                 None,
                 show_excerpt_controls,
-                FILE_HEADER_HEIGHT,
+                file_header_size,
                 MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
                 MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT,
                 fold_placeholder,
@@ -2036,6 +2039,7 @@ impl Editor {
                 .restore_unsaved_buffers,
             blame: None,
             blame_subscription: None,
+            file_header_size,
             tasks: Default::default(),
             _subscriptions: vec![
                 cx.observe(&buffer, Self::on_buffer_changed),
@@ -11484,8 +11488,11 @@ impl Editor {
         snapshot.line_len(buffer_row) == 0
     }
 
-    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<url::Url>> {
-        let buffer_and_selection = maybe!({
+    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Result<url::Url> {
+        let (path, selection, repo) = maybe!({
+            let project_handle = self.project.as_ref()?.clone();
+            let project = project_handle.read(cx);
+
             let selection = self.selections.newest::<Point>(cx);
             let selection_range = selection.range();
 
@@ -11509,58 +11516,64 @@ impl Editor {
                 (buffer.clone(), selection)
             };
 
-            Some((buffer, selection))
-        });
-
-        let Some((buffer, selection)) = buffer_and_selection else {
-            return Task::ready(Err(anyhow!("failed to determine buffer and selection")));
-        };
-
-        let Some(project) = self.project.as_ref() else {
-            return Task::ready(Err(anyhow!("editor does not have project")));
-        };
-
-        project.update(cx, |project, cx| {
-            project.get_permalink_to_line(&buffer, selection, cx)
+            let path = buffer
+                .read(cx)
+                .file()?
+                .as_local()?
+                .path()
+                .to_str()?
+                .to_string();
+            let repo = project.get_repo(&buffer.read(cx).project_path(cx)?, cx)?;
+            Some((path, selection, repo))
         })
+        .ok_or_else(|| anyhow!("unable to open git repository"))?;
+
+        const REMOTE_NAME: &str = "origin";
+        let origin_url = repo
+            .remote_url(REMOTE_NAME)
+            .ok_or_else(|| anyhow!("remote \"{REMOTE_NAME}\" not found"))?;
+        let sha = repo
+            .head_sha()
+            .ok_or_else(|| anyhow!("failed to read HEAD SHA"))?;
+
+        let (provider, remote) =
+            parse_git_remote_url(GitHostingProviderRegistry::default_global(cx), &origin_url)
+                .ok_or_else(|| anyhow!("failed to parse Git remote URL"))?;
+
+        Ok(provider.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: &sha,
+                path: &path,
+                selection: Some(selection),
+            },
+        ))
     }
 
     pub fn copy_permalink_to_line(&mut self, _: &CopyPermalinkToLine, cx: &mut ViewContext<Self>) {
-        let permalink_task = self.get_permalink_to_line(cx);
-        let workspace = self.workspace();
+        let permalink = self.get_permalink_to_line(cx);
 
-        cx.spawn(|_, mut cx| async move {
-            match permalink_task.await {
-                Ok(permalink) => {
-                    cx.update(|cx| {
-                        cx.write_to_clipboard(ClipboardItem::new_string(permalink.to_string()));
+        match permalink {
+            Ok(permalink) => {
+                cx.write_to_clipboard(ClipboardItem::new_string(permalink.to_string()));
+            }
+            Err(err) => {
+                let message = format!("Failed to copy permalink: {err}");
+
+                Err::<(), anyhow::Error>(err).log_err();
+
+                if let Some(workspace) = self.workspace() {
+                    workspace.update(cx, |workspace, cx| {
+                        struct CopyPermalinkToLine;
+
+                        workspace.show_toast(
+                            Toast::new(NotificationId::unique::<CopyPermalinkToLine>(), message),
+                            cx,
+                        )
                     })
-                    .ok();
-                }
-                Err(err) => {
-                    let message = format!("Failed to copy permalink: {err}");
-
-                    Err::<(), anyhow::Error>(err).log_err();
-
-                    if let Some(workspace) = workspace {
-                        workspace
-                            .update(&mut cx, |workspace, cx| {
-                                struct CopyPermalinkToLine;
-
-                                workspace.show_toast(
-                                    Toast::new(
-                                        NotificationId::unique::<CopyPermalinkToLine>(),
-                                        message,
-                                    ),
-                                    cx,
-                                )
-                            })
-                            .ok();
-                    }
                 }
             }
-        })
-        .detach();
+        }
     }
 
     pub fn copy_file_location(&mut self, _: &CopyFileLocation, cx: &mut ViewContext<Self>) {
@@ -11573,41 +11586,29 @@ impl Editor {
     }
 
     pub fn open_permalink_to_line(&mut self, _: &OpenPermalinkToLine, cx: &mut ViewContext<Self>) {
-        let permalink_task = self.get_permalink_to_line(cx);
-        let workspace = self.workspace();
+        let permalink = self.get_permalink_to_line(cx);
 
-        cx.spawn(|_, mut cx| async move {
-            match permalink_task.await {
-                Ok(permalink) => {
-                    cx.update(|cx| {
-                        cx.open_url(permalink.as_ref());
+        match permalink {
+            Ok(permalink) => {
+                cx.open_url(permalink.as_ref());
+            }
+            Err(err) => {
+                let message = format!("Failed to open permalink: {err}");
+
+                Err::<(), anyhow::Error>(err).log_err();
+
+                if let Some(workspace) = self.workspace() {
+                    workspace.update(cx, |workspace, cx| {
+                        struct OpenPermalinkToLine;
+
+                        workspace.show_toast(
+                            Toast::new(NotificationId::unique::<OpenPermalinkToLine>(), message),
+                            cx,
+                        )
                     })
-                    .ok();
-                }
-                Err(err) => {
-                    let message = format!("Failed to open permalink: {err}");
-
-                    Err::<(), anyhow::Error>(err).log_err();
-
-                    if let Some(workspace) = workspace {
-                        workspace
-                            .update(&mut cx, |workspace, cx| {
-                                struct OpenPermalinkToLine;
-
-                                workspace.show_toast(
-                                    Toast::new(
-                                        NotificationId::unique::<OpenPermalinkToLine>(),
-                                        message,
-                                    ),
-                                    cx,
-                                )
-                            })
-                            .ok();
-                    }
                 }
             }
-        })
-        .detach();
+        }
     }
 
     /// Adds a row highlight for the given range. If a row has multiple highlights, the
@@ -12360,15 +12361,10 @@ impl Editor {
 
         let proposed_changes_buffers = new_selections_by_buffer
             .into_iter()
-            .map(|(buffer, ranges)| ProposedChangeLocation { buffer, ranges })
+            .map(|(buffer, ranges)| ProposedChangesBuffer { buffer, ranges })
             .collect::<Vec<_>>();
         let proposed_changes_editor = cx.new_view(|cx| {
-            ProposedChangesEditor::new(
-                "Proposed changes",
-                proposed_changes_buffers,
-                self.project.clone(),
-                cx,
-            )
+            ProposedChangesEditor::new(proposed_changes_buffers, self.project.clone(), cx)
         });
 
         cx.window_context().defer(move |cx| {
@@ -12805,7 +12801,7 @@ impl Editor {
     }
 
     pub fn file_header_size(&self) -> u32 {
-        FILE_HEADER_HEIGHT
+        self.file_header_size
     }
 
     pub fn revert(
@@ -14117,7 +14113,7 @@ pub fn diagnostic_block_renderer(
 
         let multi_line_diagnostic = diagnostic.message.contains('\n');
 
-        let buttons = |diagnostic: &Diagnostic| {
+        let buttons = |diagnostic: &Diagnostic, block_id: BlockId| {
             if multi_line_diagnostic {
                 v_flex()
             } else {
@@ -14125,7 +14121,7 @@ pub fn diagnostic_block_renderer(
             }
             .when(allow_closing, |div| {
                 div.children(diagnostic.is_primary.then(|| {
-                    IconButton::new("close-block", IconName::XCircle)
+                    IconButton::new(("close-block", EntityId::from(block_id)), IconName::XCircle)
                         .icon_color(Color::Muted)
                         .size(ButtonSize::Compact)
                         .style(ButtonStyle::Transparent)
@@ -14135,7 +14131,7 @@ pub fn diagnostic_block_renderer(
                 }))
             })
             .child(
-                IconButton::new("copy-block", IconName::Copy)
+                IconButton::new(("copy-block", EntityId::from(block_id)), IconName::Copy)
                     .icon_color(Color::Muted)
                     .size(ButtonSize::Compact)
                     .style(ButtonStyle::Transparent)
@@ -14150,7 +14146,7 @@ pub fn diagnostic_block_renderer(
             )
         };
 
-        let icon_size = buttons(&diagnostic)
+        let icon_size = buttons(&diagnostic, cx.block_id)
             .into_any_element()
             .layout_as_root(AvailableSpace::min_size(), cx);
 
@@ -14167,7 +14163,7 @@ pub fn diagnostic_block_renderer(
                     .w(cx.anchor_x - cx.gutter_dimensions.width - icon_size.width)
                     .flex_shrink(),
             )
-            .child(buttons(&diagnostic))
+            .child(buttons(&diagnostic, cx.block_id))
             .child(div().flex().flex_shrink_0().child(
                 StyledText::new(text_without_backticks.clone()).with_highlights(
                     &text_style,

crates/editor/src/element.rs

@@ -21,8 +21,7 @@ use crate::{
     EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
     HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, LineDown, LineUp, OpenExcerpts, PageDown,
     PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
-    CURSORS_VISIBLE_FOR, FILE_HEADER_HEIGHT, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
-    MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
+    CURSORS_VISIBLE_FOR, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
 };
 use client::ParticipantIndex;
 use collections::{BTreeMap, HashMap};
@@ -32,7 +31,7 @@ use gpui::{
     anchored, deferred, div, fill, outline, point, px, quad, relative, size, svg,
     transparent_black, Action, AnchorCorner, AnyElement, AvailableSpace, Bounds, ClipboardItem,
     ContentMask, Corners, CursorStyle, DispatchPhase, Edges, Element, ElementInputHandler, Entity,
-    FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Length,
+    EntityId, FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Length,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, PaintQuad,
     ParentElement, Pixels, ScrollDelta, ScrollWheelEvent, ShapedLine, SharedString, Size,
     StatefulInteractiveElement, Style, Styled, TextRun, TextStyle, TextStyleRefinement, View,
@@ -47,7 +46,7 @@ use language::{
     ChunkRendererContext,
 };
 use lsp::DiagnosticSeverity;
-use multi_buffer::{Anchor, ExcerptId, ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow};
+use multi_buffer::{Anchor, MultiBufferPoint, MultiBufferRow};
 use project::{
     project_settings::{GitGutterSetting, ProjectSettings},
     ProjectPath,
@@ -1633,7 +1632,7 @@ impl EditorElement {
         let mut block_offset = 0;
         let mut found_excerpt_header = false;
         for (_, block) in snapshot.blocks_in_range(prev_line..row_range.start) {
-            if matches!(block, Block::ExcerptBoundary { .. }) {
+            if matches!(block, Block::ExcerptHeader { .. }) {
                 found_excerpt_header = true;
                 break;
             }
@@ -1650,7 +1649,7 @@ impl EditorElement {
         let mut block_height = 0;
         let mut found_excerpt_header = false;
         for (_, block) in snapshot.blocks_in_range(row_range.end..cons_line) {
-            if matches!(block, Block::ExcerptBoundary { .. }) {
+            if matches!(block, Block::ExcerptHeader { .. }) {
                 found_excerpt_header = true;
             }
             block_height += block.height();
@@ -2101,14 +2100,23 @@ impl EditorElement {
                     .into_any_element()
             }
 
-            Block::ExcerptBoundary {
-                prev_excerpt,
-                next_excerpt,
-                show_excerpt_controls,
+            Block::ExcerptHeader {
+                buffer,
+                range,
                 starts_new_buffer,
                 height,
+                id,
+                show_excerpt_controls,
                 ..
             } => {
+                let include_root = self
+                    .editor
+                    .read(cx)
+                    .project
+                    .as_ref()
+                    .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
+                    .unwrap_or_default();
+
                 #[derive(Clone)]
                 struct JumpData {
                     position: Point,
@@ -2117,227 +2125,233 @@ impl EditorElement {
                     line_offset_from_top: u32,
                 }
 
+                let jump_data = project::File::from_dyn(buffer.file()).map(|file| {
+                    let jump_path = ProjectPath {
+                        worktree_id: file.worktree_id(cx),
+                        path: file.path.clone(),
+                    };
+                    let jump_anchor = range
+                        .primary
+                        .as_ref()
+                        .map_or(range.context.start, |primary| primary.start);
+
+                    let excerpt_start = range.context.start;
+                    let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);
+                    let offset_from_excerpt_start = if jump_anchor == excerpt_start {
+                        0
+                    } else {
+                        let excerpt_start_row =
+                            language::ToPoint::to_point(&jump_anchor, buffer).row;
+                        jump_position.row - excerpt_start_row
+                    };
+
+                    let line_offset_from_top =
+                        block_row_start.0 + *height + offset_from_excerpt_start
+                            - snapshot
+                                .scroll_anchor
+                                .scroll_position(&snapshot.display_snapshot)
+                                .y as u32;
+
+                    JumpData {
+                        position: jump_position,
+                        anchor: jump_anchor,
+                        path: jump_path,
+                        line_offset_from_top,
+                    }
+                });
+
                 let icon_offset = gutter_dimensions.width
                     - (gutter_dimensions.left_padding + gutter_dimensions.margin);
 
-                let header_padding = px(6.0);
-
-                let mut result = v_flex().id(block_id).w_full();
-
-                if let Some(prev_excerpt) = prev_excerpt {
-                    if *show_excerpt_controls {
-                        result = result.child(
-                            h_flex()
-                                .w(icon_offset)
-                                .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
-                                .flex_none()
-                                .justify_end()
-                                .child(self.render_expand_excerpt_button(
-                                    prev_excerpt.id,
-                                    ExpandExcerptDirection::Down,
-                                    IconName::ArrowDownFromLine,
-                                    cx,
-                                )),
-                        );
+                let element = if *starts_new_buffer {
+                    let path = buffer.resolve_file_path(cx, include_root);
+                    let mut filename = None;
+                    let mut parent_path = None;
+                    // Can't use .and_then() because `.file_name()` and `.parent()` return references :(
+                    if let Some(path) = path {
+                        filename = path.file_name().map(|f| f.to_string_lossy().to_string());
+                        parent_path = path
+                            .parent()
+                            .map(|p| SharedString::from(p.to_string_lossy().to_string() + "/"));
                     }
-                }
 
-                if let Some(next_excerpt) = next_excerpt {
-                    let buffer = &next_excerpt.buffer;
-                    let range = &next_excerpt.range;
-                    let jump_data = project::File::from_dyn(buffer.file()).map(|file| {
-                        let jump_path = ProjectPath {
-                            worktree_id: file.worktree_id(cx),
-                            path: file.path.clone(),
-                        };
-                        let jump_anchor = range
-                            .primary
-                            .as_ref()
-                            .map_or(range.context.start, |primary| primary.start);
+                    let header_padding = px(6.0);
 
-                        let excerpt_start = range.context.start;
-                        let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);
-                        let offset_from_excerpt_start = if jump_anchor == excerpt_start {
-                            0
-                        } else {
-                            let excerpt_start_row =
-                                language::ToPoint::to_point(&jump_anchor, buffer).row;
-                            jump_position.row - excerpt_start_row
-                        };
-
-                        let line_offset_from_top =
-                            block_row_start.0 + *height + offset_from_excerpt_start
-                                - snapshot
-                                    .scroll_anchor
-                                    .scroll_position(&snapshot.display_snapshot)
-                                    .y as u32;
-
-                        JumpData {
-                            position: jump_position,
-                            anchor: jump_anchor,
-                            path: jump_path,
-                            line_offset_from_top,
-                        }
-                    });
-
-                    if *starts_new_buffer {
-                        let include_root = self
-                            .editor
-                            .read(cx)
-                            .project
-                            .as_ref()
-                            .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
-                            .unwrap_or_default();
-                        let path = buffer.resolve_file_path(cx, include_root);
-                        let filename = path
-                            .as_ref()
-                            .and_then(|path| Some(path.file_name()?.to_string_lossy().to_string()));
-                        let parent_path = path.as_ref().and_then(|path| {
-                            Some(path.parent()?.to_string_lossy().to_string() + "/")
-                        });
-
-                        result = result.child(
-                            div()
-                                .px(header_padding)
-                                .pt(header_padding)
-                                .w_full()
-                                .h(FILE_HEADER_HEIGHT as f32 * cx.line_height())
-                                .child(
-                                    h_flex()
-                                        .id("path header block")
-                                        .size_full()
-                                        .flex_basis(Length::Definite(DefiniteLength::Fraction(
-                                            0.667,
-                                        )))
-                                        .px(gpui::px(12.))
-                                        .rounded_md()
-                                        .shadow_md()
-                                        .border_1()
-                                        .border_color(cx.theme().colors().border)
-                                        .bg(cx.theme().colors().editor_subheader_background)
-                                        .justify_between()
-                                        .hover(|style| style.bg(cx.theme().colors().element_hover))
-                                        .child(
-                                            h_flex().gap_3().child(
-                                                h_flex()
-                                                    .gap_2()
-                                                    .child(
-                                                        filename
-                                                            .map(SharedString::from)
-                                                            .unwrap_or_else(|| "untitled".into()),
-                                                    )
-                                                    .when_some(parent_path, |then, path| {
-                                                        then.child(div().child(path).text_color(
-                                                            cx.theme().colors().text_muted,
-                                                        ))
-                                                    }),
-                                            ),
-                                        )
-                                        .when_some(jump_data, |el, jump_data| {
-                                            el.child(Icon::new(IconName::ArrowUpRight))
-                                                .cursor_pointer()
-                                                .tooltip(|cx| {
-                                                    Tooltip::for_action(
-                                                        "Jump to File",
-                                                        &OpenExcerpts,
-                                                        cx,
-                                                    )
-                                                })
-                                                .on_mouse_down(MouseButton::Left, |_, cx| {
-                                                    cx.stop_propagation()
-                                                })
-                                                .on_click(cx.listener_for(&self.editor, {
-                                                    move |editor, _, cx| {
-                                                        editor.jump(
-                                                            jump_data.path.clone(),
-                                                            jump_data.position,
-                                                            jump_data.anchor,
-                                                            jump_data.line_offset_from_top,
-                                                            cx,
-                                                        );
-                                                    }
-                                                }))
-                                        }),
-                                ),
-                        );
-                        if *show_excerpt_controls {
-                            result = result.child(
-                                h_flex()
-                                    .w(icon_offset)
-                                    .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
-                                    .flex_none()
-                                    .justify_end()
-                                    .child(self.render_expand_excerpt_button(
-                                        next_excerpt.id,
-                                        ExpandExcerptDirection::Up,
-                                        IconName::ArrowUpFromLine,
-                                        cx,
-                                    )),
-                            );
-                        }
-                    } else {
-                        result = result.child(
+                    v_flex()
+                        .id(("path excerpt header", EntityId::from(block_id)))
+                        .w_full()
+                        .px(header_padding)
+                        .pt(header_padding)
+                        .child(
                             h_flex()
-                                .id("excerpt header block")
-                                .group("excerpt-jump-action")
+                                .flex_basis(Length::Definite(DefiniteLength::Fraction(0.667)))
+                                .id("path header block")
+                                .h(2. * cx.line_height())
+                                .px(gpui::px(12.))
+                                .rounded_md()
+                                .shadow_md()
+                                .border_1()
+                                .border_color(cx.theme().colors().border)
+                                .bg(cx.theme().colors().editor_subheader_background)
+                                .justify_between()
+                                .hover(|style| style.bg(cx.theme().colors().element_hover))
+                                .child(
+                                    h_flex().gap_3().child(
+                                        h_flex()
+                                            .gap_2()
+                                            .child(
+                                                filename
+                                                    .map(SharedString::from)
+                                                    .unwrap_or_else(|| "untitled".into()),
+                                            )
+                                            .when_some(parent_path, |then, path| {
+                                                then.child(
+                                                    div()
+                                                        .child(path)
+                                                        .text_color(cx.theme().colors().text_muted),
+                                                )
+                                            }),
+                                    ),
+                                )
+                                .when_some(jump_data.clone(), |el, jump_data| {
+                                    el.child(Icon::new(IconName::ArrowUpRight))
+                                        .cursor_pointer()
+                                        .tooltip(|cx| {
+                                            Tooltip::for_action("Jump to File", &OpenExcerpts, cx)
+                                        })
+                                        .on_mouse_down(MouseButton::Left, |_, cx| {
+                                            cx.stop_propagation()
+                                        })
+                                        .on_click(cx.listener_for(&self.editor, {
+                                            move |editor, _, cx| {
+                                                editor.jump(
+                                                    jump_data.path.clone(),
+                                                    jump_data.position,
+                                                    jump_data.anchor,
+                                                    jump_data.line_offset_from_top,
+                                                    cx,
+                                                );
+                                            }
+                                        }))
+                                }),
+                        )
+                        .children(show_excerpt_controls.then(|| {
+                            h_flex()
+                                .flex_basis(Length::Definite(DefiniteLength::Fraction(0.333)))
+                                .h(1. * cx.line_height())
+                                .pt_1()
+                                .justify_end()
+                                .flex_none()
+                                .w(icon_offset - header_padding)
+                                .child(
+                                    ButtonLike::new("expand-icon")
+                                        .style(ButtonStyle::Transparent)
+                                        .child(
+                                            svg()
+                                                .path(IconName::ArrowUpFromLine.path())
+                                                .size(IconSize::XSmall.rems())
+                                                .text_color(cx.theme().colors().editor_line_number)
+                                                .group("")
+                                                .hover(|style| {
+                                                    style.text_color(
+                                                        cx.theme()
+                                                            .colors()
+                                                            .editor_active_line_number,
+                                                    )
+                                                }),
+                                        )
+                                        .on_click(cx.listener_for(&self.editor, {
+                                            let id = *id;
+                                            move |editor, _, cx| {
+                                                editor.expand_excerpt(
+                                                    id,
+                                                    multi_buffer::ExpandExcerptDirection::Up,
+                                                    cx,
+                                                );
+                                            }
+                                        }))
+                                        .tooltip({
+                                            move |cx| {
+                                                Tooltip::for_action(
+                                                    "Expand Excerpt",
+                                                    &ExpandExcerpts { lines: 0 },
+                                                    cx,
+                                                )
+                                            }
+                                        }),
+                                )
+                        }))
+                } else {
+                    v_flex()
+                        .id(("excerpt header", EntityId::from(block_id)))
+                        .w_full()
+                        .h(snapshot.excerpt_header_height() as f32 * cx.line_height())
+                        .child(
+                            div()
+                                .flex()
+                                .v_flex()
                                 .justify_start()
-                                .w_full()
-                                .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
-                                .relative()
+                                .id("jump to collapsed context")
+                                .w(relative(1.0))
+                                .h_full()
                                 .child(
                                     div()
-                                        .top(px(0.))
-                                        .absolute()
-                                        .w_full()
                                         .h_px()
+                                        .w_full()
                                         .bg(cx.theme().colors().border_variant)
                                         .group_hover("excerpt-jump-action", |style| {
                                             style.bg(cx.theme().colors().border)
                                         }),
-                                )
-                                .cursor_pointer()
-                                .when_some(jump_data.clone(), |this, jump_data| {
-                                    this.on_click(cx.listener_for(&self.editor, {
-                                        let path = jump_data.path.clone();
-                                        move |editor, _, cx| {
-                                            cx.stop_propagation();
-
-                                            editor.jump(
-                                                path.clone(),
-                                                jump_data.position,
-                                                jump_data.anchor,
-                                                jump_data.line_offset_from_top,
-                                                cx,
-                                            );
-                                        }
-                                    }))
-                                    .tooltip(move |cx| {
-                                        Tooltip::for_action(
-                                            format!(
-                                                "Jump to {}:L{}",
-                                                jump_data.path.path.display(),
-                                                jump_data.position.row + 1
-                                            ),
-                                            &OpenExcerpts,
-                                            cx,
-                                        )
-                                    })
-                                })
+                                ),
+                        )
+                        .child(
+                            h_flex()
+                                .justify_end()
+                                .flex_none()
+                                .w(icon_offset)
+                                .h_full()
                                 .child(
-                                    h_flex()
-                                        .w(icon_offset)
-                                        .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32
-                                            * cx.line_height())
-                                        .flex_none()
-                                        .justify_end()
-                                        .child(if *show_excerpt_controls {
-                                            self.render_expand_excerpt_button(
-                                                next_excerpt.id,
-                                                ExpandExcerptDirection::Up,
-                                                IconName::ArrowUpFromLine,
-                                                cx,
-                                            )
-                                        } else {
+                                    show_excerpt_controls
+                                        .then(|| {
+                                            ButtonLike::new("expand-icon")
+                                                .style(ButtonStyle::Transparent)
+                                                .child(
+                                                    svg()
+                                                        .path(IconName::ArrowUpFromLine.path())
+                                                        .size(IconSize::XSmall.rems())
+                                                        .text_color(
+                                                            cx.theme().colors().editor_line_number,
+                                                        )
+                                                        .group("")
+                                                        .hover(|style| {
+                                                            style.text_color(
+                                                                cx.theme()
+                                                                    .colors()
+                                                                    .editor_active_line_number,
+                                                            )
+                                                        }),
+                                                )
+                                                .on_click(cx.listener_for(&self.editor, {
+                                                    let id = *id;
+                                                    move |editor, _, cx| {
+                                                        editor.expand_excerpt(
+                                                        id,
+                                                        multi_buffer::ExpandExcerptDirection::Up,
+                                                        cx,
+                                                    );
+                                                    }
+                                                }))
+                                                .tooltip({
+                                                    move |cx| {
+                                                        Tooltip::for_action(
+                                                            "Expand Excerpt",
+                                                            &ExpandExcerpts { lines: 0 },
+                                                            cx,
+                                                        )
+                                                    }
+                                                })
+                                        })
+                                        .unwrap_or_else(|| {
                                             ButtonLike::new("jump-icon")
                                                 .style(ButtonStyle::Transparent)
                                                 .child(
@@ -2347,6 +2361,7 @@ impl EditorElement {
                                                         .text_color(
                                                             cx.theme().colors().border_variant,
                                                         )
+                                                        .group("excerpt-jump-action")
                                                         .group_hover(
                                                             "excerpt-jump-action",
                                                             |style| {
@@ -2356,13 +2371,118 @@ impl EditorElement {
                                                             },
                                                         ),
                                                 )
+                                                .when_some(jump_data.clone(), |this, jump_data| {
+                                                    this.on_click(cx.listener_for(&self.editor, {
+                                                        let path = jump_data.path.clone();
+                                                        move |editor, _, cx| {
+                                                            cx.stop_propagation();
+
+                                                            editor.jump(
+                                                                path.clone(),
+                                                                jump_data.position,
+                                                                jump_data.anchor,
+                                                                jump_data.line_offset_from_top,
+                                                                cx,
+                                                            );
+                                                        }
+                                                    }))
+                                                    .tooltip(move |cx| {
+                                                        Tooltip::for_action(
+                                                            format!(
+                                                                "Jump to {}:L{}",
+                                                                jump_data.path.path.display(),
+                                                                jump_data.position.row + 1
+                                                            ),
+                                                            &OpenExcerpts,
+                                                            cx,
+                                                        )
+                                                    })
+                                                })
                                         }),
                                 ),
-                        );
-                    }
-                }
+                        )
+                        .group("excerpt-jump-action")
+                        .cursor_pointer()
+                        .when_some(jump_data.clone(), |this, jump_data| {
+                            this.on_click(cx.listener_for(&self.editor, {
+                                let path = jump_data.path.clone();
+                                move |editor, _, cx| {
+                                    cx.stop_propagation();
 
-                result.into_any()
+                                    editor.jump(
+                                        path.clone(),
+                                        jump_data.position,
+                                        jump_data.anchor,
+                                        jump_data.line_offset_from_top,
+                                        cx,
+                                    );
+                                }
+                            }))
+                            .tooltip(move |cx| {
+                                Tooltip::for_action(
+                                    format!(
+                                        "Jump to {}:L{}",
+                                        jump_data.path.path.display(),
+                                        jump_data.position.row + 1
+                                    ),
+                                    &OpenExcerpts,
+                                    cx,
+                                )
+                            })
+                        })
+                };
+                element.into_any()
+            }
+
+            Block::ExcerptFooter { id, .. } => {
+                let element = v_flex()
+                    .id(("excerpt footer", EntityId::from(block_id)))
+                    .w_full()
+                    .h(snapshot.excerpt_footer_height() as f32 * cx.line_height())
+                    .child(
+                        h_flex()
+                            .justify_end()
+                            .flex_none()
+                            .w(gutter_dimensions.width
+                                - (gutter_dimensions.left_padding + gutter_dimensions.margin))
+                            .h_full()
+                            .child(
+                                ButtonLike::new("expand-icon")
+                                    .style(ButtonStyle::Transparent)
+                                    .child(
+                                        svg()
+                                            .path(IconName::ArrowDownFromLine.path())
+                                            .size(IconSize::XSmall.rems())
+                                            .text_color(cx.theme().colors().editor_line_number)
+                                            .group("")
+                                            .hover(|style| {
+                                                style.text_color(
+                                                    cx.theme().colors().editor_active_line_number,
+                                                )
+                                            }),
+                                    )
+                                    .on_click(cx.listener_for(&self.editor, {
+                                        let id = *id;
+                                        move |editor, _, cx| {
+                                            editor.expand_excerpt(
+                                                id,
+                                                multi_buffer::ExpandExcerptDirection::Down,
+                                                cx,
+                                            );
+                                        }
+                                    }))
+                                    .tooltip({
+                                        move |cx| {
+                                            Tooltip::for_action(
+                                                "Expand Excerpt",
+                                                &ExpandExcerpts { lines: 0 },
+                                                cx,
+                                            )
+                                        }
+                                    }),
+                            ),
+                    );
+                element.into_any()
             }
         };
 
@@ -2389,33 +2509,6 @@ impl EditorElement {
         (element, final_size)
     }
 
-    fn render_expand_excerpt_button(
-        &self,
-        excerpt_id: ExcerptId,
-        direction: ExpandExcerptDirection,
-        icon: IconName,
-        cx: &mut WindowContext,
-    ) -> ButtonLike {
-        ButtonLike::new("expand-icon")
-            .style(ButtonStyle::Transparent)
-            .child(
-                svg()
-                    .path(icon.path())
-                    .size(IconSize::XSmall.rems())
-                    .text_color(cx.theme().colors().editor_line_number)
-                    .group("")
-                    .hover(|style| style.text_color(cx.theme().colors().editor_active_line_number)),
-            )
-            .on_click(cx.listener_for(&self.editor, {
-                move |editor, _, cx| {
-                    editor.expand_excerpt(excerpt_id, direction, cx);
-                }
-            }))
-            .tooltip({
-                move |cx| Tooltip::for_action("Expand Excerpt", &ExpandExcerpts { lines: 0 }, cx)
-            })
-    }
-
     #[allow(clippy::too_many_arguments)]
     fn render_blocks(
         &self,
@@ -3274,7 +3367,7 @@ impl EditorElement {
                     let end_row_in_current_excerpt = snapshot
                         .blocks_in_range(start_row..end_row)
                         .find_map(|(start_row, block)| {
-                            if matches!(block, Block::ExcerptBoundary { .. }) {
+                            if matches!(block, Block::ExcerptHeader { .. }) {
                                 Some(start_row)
                             } else {
                                 None

crates/editor/src/movement.rs

@@ -952,7 +952,7 @@ mod tests {
                     px(14.0),
                     None,
                     true,
-                    0,
+                    2,
                     2,
                     0,
                     FoldPlaceholder::test(),

crates/editor/src/proposed_changes_editor.rs

@@ -16,24 +16,16 @@ use workspace::{
 
 pub struct ProposedChangesEditor {
     editor: View<Editor>,
-    multibuffer: Model<MultiBuffer>,
-    title: SharedString,
-    buffer_entries: Vec<BufferEntry>,
+    _subscriptions: Vec<Subscription>,
     _recalculate_diffs_task: Task<Option<()>>,
     recalculate_diffs_tx: mpsc::UnboundedSender<RecalculateDiff>,
 }
 
-pub struct ProposedChangeLocation<T> {
+pub struct ProposedChangesBuffer<T> {
     pub buffer: Model<Buffer>,
     pub ranges: Vec<Range<T>>,
 }
 
-struct BufferEntry {
-    base: Model<Buffer>,
-    branch: Model<Buffer>,
-    _subscription: Subscription,
-}
-
 pub struct ProposedChangesEditorToolbar {
     current_editor: Option<View<ProposedChangesEditor>>,
 }
@@ -51,14 +43,32 @@ struct BranchBufferSemanticsProvider(Rc<dyn SemanticsProvider>);
 
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
-        title: impl Into<SharedString>,
-        locations: Vec<ProposedChangeLocation<T>>,
+        buffers: Vec<ProposedChangesBuffer<T>>,
         project: Option<Model<Project>>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
+        let mut subscriptions = Vec::new();
         let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
+
+        for buffer in buffers {
+            let branch_buffer = buffer.buffer.update(cx, |buffer, cx| buffer.branch(cx));
+            subscriptions.push(cx.subscribe(&branch_buffer, Self::on_buffer_event));
+
+            multibuffer.update(cx, |multibuffer, cx| {
+                multibuffer.push_excerpts(
+                    branch_buffer,
+                    buffer.ranges.into_iter().map(|range| ExcerptRange {
+                        context: range,
+                        primary: None,
+                    }),
+                    cx,
+                );
+            });
+        }
+
         let (recalculate_diffs_tx, mut recalculate_diffs_rx) = mpsc::unbounded();
-        let mut this = Self {
+
+        Self {
             editor: cx.new_view(|cx| {
                 let mut editor = Editor::for_multibuffer(multibuffer.clone(), project, true, cx);
                 editor.set_expand_all_diff_hunks();
@@ -71,9 +81,6 @@ impl ProposedChangesEditor {
                 );
                 editor
             }),
-            multibuffer,
-            title: title.into(),
-            buffer_entries: Vec::new(),
             recalculate_diffs_tx,
             _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
                 let mut buffers_to_diff = HashSet::default();
@@ -105,100 +112,7 @@ impl ProposedChangesEditor {
                 }
                 None
             }),
-        };
-        this.reset_locations(locations, cx);
-        this
-    }
-
-    pub fn branch_buffer_for_base(&self, base_buffer: &Model<Buffer>) -> Option<Model<Buffer>> {
-        self.buffer_entries.iter().find_map(|entry| {
-            if &entry.base == base_buffer {
-                Some(entry.branch.clone())
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn set_title(&mut self, title: SharedString, cx: &mut ViewContext<Self>) {
-        self.title = title;
-        cx.notify();
-    }
-
-    pub fn reset_locations<T: ToOffset>(
-        &mut self,
-        locations: Vec<ProposedChangeLocation<T>>,
-        cx: &mut ViewContext<Self>,
-    ) {
-        // Undo all branch changes
-        for entry in &self.buffer_entries {
-            let base_version = entry.base.read(cx).version();
-            entry.branch.update(cx, |buffer, cx| {
-                let undo_counts = buffer
-                    .operations()
-                    .iter()
-                    .filter_map(|(timestamp, _)| {
-                        if !base_version.observed(*timestamp) {
-                            Some((*timestamp, u32::MAX))
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-                buffer.undo_operations(undo_counts, cx);
-            });
-        }
-
-        self.multibuffer.update(cx, |multibuffer, cx| {
-            multibuffer.clear(cx);
-        });
-
-        let mut buffer_entries = Vec::new();
-        for location in locations {
-            let branch_buffer;
-            if let Some(ix) = self
-                .buffer_entries
-                .iter()
-                .position(|entry| entry.base == location.buffer)
-            {
-                let entry = self.buffer_entries.remove(ix);
-                branch_buffer = entry.branch.clone();
-                buffer_entries.push(entry);
-            } else {
-                branch_buffer = location.buffer.update(cx, |buffer, cx| buffer.branch(cx));
-                buffer_entries.push(BufferEntry {
-                    branch: branch_buffer.clone(),
-                    base: location.buffer.clone(),
-                    _subscription: cx.subscribe(&branch_buffer, Self::on_buffer_event),
-                });
-            }
-
-            self.multibuffer.update(cx, |multibuffer, cx| {
-                multibuffer.push_excerpts(
-                    branch_buffer,
-                    location.ranges.into_iter().map(|range| ExcerptRange {
-                        context: range,
-                        primary: None,
-                    }),
-                    cx,
-                );
-            });
-        }
-
-        self.buffer_entries = buffer_entries;
-        self.editor.update(cx, |editor, cx| {
-            editor.change_selections(None, cx, |selections| selections.refresh())
-        });
-    }
-
-    pub fn recalculate_all_buffer_diffs(&self) {
-        for (ix, entry) in self.buffer_entries.iter().enumerate().rev() {
-            self.recalculate_diffs_tx
-                .unbounded_send(RecalculateDiff {
-                    buffer: entry.branch.clone(),
-                    debounce: ix > 0,
-                })
-                .ok();
+            _subscriptions: subscriptions,
         }
     }
 
@@ -248,11 +162,11 @@ impl Item for ProposedChangesEditor {
     type Event = EditorEvent;
 
     fn tab_icon(&self, _cx: &ui::WindowContext) -> Option<Icon> {
-        Some(Icon::new(IconName::Diff))
+        Some(Icon::new(IconName::Pencil))
     }
 
     fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
-        Some(self.title.clone())
+        Some("Proposed changes".into())
     }
 
     fn as_searchable(&self, _: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {

crates/gpui/src/app/entity_map.rs

@@ -434,10 +434,12 @@ impl<T> Clone for Model<T> {
 
 impl<T> std::fmt::Debug for Model<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Model")
-            .field("entity_id", &self.any_model.entity_id)
-            .field("entity_type", &type_name::<T>())
-            .finish()
+        write!(
+            f,
+            "Model {{ entity_id: {:?}, entity_type: {:?} }}",
+            self.any_model.entity_id,
+            type_name::<T>()
+        )
     }
 }
 
@@ -567,10 +569,7 @@ pub struct WeakModel<T> {
 
 impl<T> std::fmt::Debug for WeakModel<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct(&type_name::<Self>())
-            .field("entity_id", &self.any_model.entity_id)
-            .field("entity_type", &type_name::<T>())
-            .finish()
+        f.debug_struct(type_name::<WeakModel<T>>()).finish()
     }
 }
 

crates/image_viewer/src/image_viewer.rs

@@ -36,9 +36,7 @@ impl project::Item for ImageItem {
             .path
             .extension()
             .and_then(OsStr::to_str)
-            .map(str::to_lowercase)
             .unwrap_or_default();
-        let ext = ext.as_str();
 
         // Only open the item if it's a binary image (no SVGs, etc.)
         // Since we do not have a way to toggle to an editor

crates/language/src/buffer.rs

@@ -20,7 +20,6 @@ use anyhow::{anyhow, Context, Result};
 use async_watch as watch;
 use clock::Lamport;
 pub use clock::ReplicaId;
-use collections::HashMap;
 use futures::channel::oneshot;
 use gpui::{
     AnyElement, AppContext, Context as _, EventEmitter, HighlightStyle, Model, ModelContext,
@@ -911,8 +910,10 @@ impl Buffer {
         self.apply_ops([operation.clone()], cx);
 
         if let Some(timestamp) = operation_to_undo {
-            let counts = [(timestamp, u32::MAX)].into_iter().collect();
-            self.undo_operations(counts, cx);
+            let operation = self
+                .text
+                .undo_operations([(timestamp, u32::MAX)].into_iter().collect());
+            self.send_operation(Operation::Buffer(operation), true, cx);
         }
 
         self.diff_base_version += 1;
@@ -2330,18 +2331,6 @@ impl Buffer {
         undone
     }
 
-    pub fn undo_operations(
-        &mut self,
-        counts: HashMap<Lamport, u32>,
-        cx: &mut ModelContext<Buffer>,
-    ) {
-        let was_dirty = self.is_dirty();
-        let operation = self.text.undo_operations(counts);
-        let old_version = self.version.clone();
-        self.send_operation(Operation::Buffer(operation), true, cx);
-        self.did_edit(&old_version, was_dirty, cx);
-    }
-
     /// Manually redoes a specific transaction in the buffer's redo history.
     pub fn redo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
         let was_dirty = self.is_dirty();

crates/language_model/src/provider/cloud.rs

@@ -8,7 +8,7 @@ use crate::{
 use anthropic::AnthropicError;
 use anyhow::{anyhow, Result};
 use client::{
-    zed_urls, Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME,
+    Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME,
     MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME,
 };
 use collections::BTreeMap;
@@ -905,6 +905,7 @@ impl ConfigurationView {
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         const ZED_AI_URL: &str = "https://zed.dev/ai";
+        const ACCOUNT_SETTINGS_URL: &str = "https://zed.dev/account";
 
         let is_connected = !self.state.read(cx).is_signed_out();
         let plan = self.state.read(cx).user_store.read(cx).current_plan();
@@ -921,7 +922,7 @@ impl Render for ConfigurationView {
                 h_flex().child(
                     Button::new("manage_settings", "Manage Subscription")
                         .style(ButtonStyle::Tinted(TintColor::Accent))
-                        .on_click(cx.listener(|_, _, cx| cx.open_url(&zed_urls::account_url(cx)))),
+                        .on_click(cx.listener(|_, _, cx| cx.open_url(ACCOUNT_SETTINGS_URL))),
                 ),
             )
         } else if cx.has_flag::<ZedPro>() {
@@ -937,9 +938,7 @@ impl Render for ConfigurationView {
                         Button::new("upgrade", "Upgrade")
                             .style(ButtonStyle::Subtle)
                             .color(Color::Accent)
-                            .on_click(
-                                cx.listener(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))),
-                            ),
+                            .on_click(cx.listener(|_, _, cx| cx.open_url(ACCOUNT_SETTINGS_URL))),
                     ),
             )
         } else {

crates/languages/Cargo.toml

@@ -9,9 +9,7 @@ license = "GPL-3.0-or-later"
 workspace = true
 
 [features]
-test-support = [
-    "tree-sitter"
-]
+test-support = []
 load-grammars = [
     "tree-sitter-bash",
     "tree-sitter-c",
@@ -77,7 +75,6 @@ tree-sitter-yaml = { workspace = true, optional = true }
 util.workspace = true
 
 [dev-dependencies]
-tree-sitter.workspace = true
 text.workspace = true
 theme = { workspace = true, features = ["test-support"] }
 unindent.workspace = true

crates/languages/src/css/config.toml

@@ -1,6 +1,6 @@
 name = "CSS"
 grammar = "css"
-path_suffixes = ["css", "postcss"]
+path_suffixes = ["css"]
 autoclose_before = ";:.,=}])>"
 brackets = [
     { start = "{", end = "}", close = true, newline = true },

crates/multi_buffer/src/multi_buffer.rs

@@ -189,7 +189,6 @@ pub struct MultiBufferSnapshot {
     show_headers: bool,
 }
 
-#[derive(Clone)]
 pub struct ExcerptInfo {
     pub id: ExcerptId,
     pub buffer: BufferSnapshot,
@@ -202,7 +201,6 @@ impl std::fmt::Debug for ExcerptInfo {
         f.debug_struct(type_name::<Self>())
             .field("id", &self.id)
             .field("buffer_id", &self.buffer_id)
-            .field("path", &self.buffer.file().map(|f| f.path()))
             .field("range", &self.range)
             .finish()
     }

crates/paths/src/paths.rs

@@ -101,10 +101,10 @@ pub fn logs_dir() -> &'static PathBuf {
     })
 }
 
-/// Returns the path to the Zed server directory on this SSH host.
+/// Returns the path to the zed server directory on this ssh host.
 pub fn remote_server_state_dir() -> &'static PathBuf {
     static REMOTE_SERVER_STATE: OnceLock<PathBuf> = OnceLock::new();
-    REMOTE_SERVER_STATE.get_or_init(|| support_dir().join("server_state"))
+    REMOTE_SERVER_STATE.get_or_init(|| return support_dir().join("server_state"))
 }
 
 /// Returns the path to the `Zed.log` file.

crates/project/Cargo.toml

@@ -69,7 +69,6 @@ snippet_provider.workspace = true
 terminal.workspace = true
 text.workspace = true
 util.workspace = true
-url.workspace = true
 which.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]

crates/project/src/buffer_store.rs

@@ -3,7 +3,6 @@ use crate::{
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
     Item, NoRepositoryError, ProjectPath,
 };
-use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 use anyhow::{anyhow, Context as _, Result};
 use client::Client;
 use collections::{hash_map, HashMap, HashSet};
@@ -24,7 +23,7 @@ use language::{
 };
 use rpc::{proto, AnyProtoClient, ErrorExt as _, TypedEnvelope};
 use smol::channel::Receiver;
-use std::{io, ops::Range, path::Path, str::FromStr as _, sync::Arc, time::Instant};
+use std::{io, path::Path, str::FromStr as _, sync::Arc, time::Instant};
 use text::BufferId;
 use util::{debug_panic, maybe, ResultExt as _, TryFutureExt};
 use worktree::{File, PathChange, ProjectEntryId, UpdatedGitRepositoriesSet, Worktree, WorktreeId};
@@ -972,7 +971,6 @@ impl BufferStore {
         client.add_model_request_handler(Self::handle_save_buffer);
         client.add_model_request_handler(Self::handle_blame_buffer);
         client.add_model_request_handler(Self::handle_reload_buffers);
-        client.add_model_request_handler(Self::handle_get_permalink_to_line);
     }
 
     /// Creates a buffer store, optionally retaining its buffers.
@@ -1172,78 +1170,6 @@ impl BufferStore {
         }
     }
 
-    pub fn get_permalink_to_line(
-        &self,
-        buffer: &Model<Buffer>,
-        selection: Range<u32>,
-        cx: &AppContext,
-    ) -> Task<Result<url::Url>> {
-        let buffer = buffer.read(cx);
-        let Some(file) = File::from_dyn(buffer.file()) else {
-            return Task::ready(Err(anyhow!("buffer has no file")));
-        };
-
-        match file.worktree.clone().read(cx) {
-            Worktree::Local(worktree) => {
-                let Some(repo) = worktree.local_git_repo(file.path()) else {
-                    return Task::ready(Err(anyhow!("no repository for buffer found")));
-                };
-
-                let path = file.path().clone();
-
-                cx.spawn(|cx| async move {
-                    const REMOTE_NAME: &str = "origin";
-                    let origin_url = repo
-                        .remote_url(REMOTE_NAME)
-                        .ok_or_else(|| anyhow!("remote \"{REMOTE_NAME}\" not found"))?;
-
-                    let sha = repo
-                        .head_sha()
-                        .ok_or_else(|| anyhow!("failed to read HEAD SHA"))?;
-
-                    let provider_registry =
-                        cx.update(GitHostingProviderRegistry::default_global)?;
-
-                    let (provider, remote) =
-                        parse_git_remote_url(provider_registry, &origin_url)
-                            .ok_or_else(|| anyhow!("failed to parse Git remote URL"))?;
-
-                    let path = path
-                        .to_str()
-                        .context("failed to convert buffer path to string")?;
-
-                    Ok(provider.build_permalink(
-                        remote,
-                        BuildPermalinkParams {
-                            sha: &sha,
-                            path,
-                            selection: Some(selection),
-                        },
-                    ))
-                })
-            }
-            Worktree::Remote(worktree) => {
-                let buffer_id = buffer.remote_id();
-                let project_id = worktree.project_id();
-                let client = worktree.client();
-                cx.spawn(|_| async move {
-                    let response = client
-                        .request(proto::GetPermalinkToLine {
-                            project_id,
-                            buffer_id: buffer_id.into(),
-                            selection: Some(proto::Range {
-                                start: selection.start as u64,
-                                end: selection.end as u64,
-                            }),
-                        })
-                        .await?;
-
-                    url::Url::parse(&response.permalink).context("failed to parse permalink")
-                })
-            }
-        }
-    }
-
     fn add_buffer(&mut self, buffer: Model<Buffer>, cx: &mut ModelContext<Self>) -> Result<()> {
         let remote_id = buffer.read(cx).remote_id();
         let is_remote = buffer.read(cx).replica_id() != 0;
@@ -1849,31 +1775,6 @@ impl BufferStore {
         Ok(serialize_blame_buffer_response(blame))
     }
 
-    pub async fn handle_get_permalink_to_line(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::GetPermalinkToLine>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::GetPermalinkToLineResponse> {
-        let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
-        // let version = deserialize_version(&envelope.payload.version);
-        let selection = {
-            let proto_selection = envelope
-                .payload
-                .selection
-                .context("no selection to get permalink for defined")?;
-            proto_selection.start as u32..proto_selection.end as u32
-        };
-        let buffer = this.read_with(&cx, |this, _| this.get_existing(buffer_id))??;
-        let permalink = this
-            .update(&mut cx, |this, cx| {
-                this.get_permalink_to_line(&buffer, selection, cx)
-            })?
-            .await?;
-        Ok(proto::GetPermalinkToLineResponse {
-            permalink: permalink.to_string(),
-        })
-    }
-
     pub async fn wait_for_loading_buffer(
         mut receiver: postage::watch::Receiver<Option<Result<Model<Buffer>, Arc<anyhow::Error>>>>,
     ) -> Result<Model<Buffer>, Arc<anyhow::Error>> {

crates/project/src/lsp_store.rs

@@ -6057,16 +6057,6 @@ impl LspStore {
                                         );
                                     })?;
                                 }
-                                "textDocument/rename" => {
-                                    this.update(&mut cx, |this, _| {
-                                        if let Some(server) = this.language_server_for_id(server_id)
-                                        {
-                                            server.update_capabilities(|capabilities| {
-                                                capabilities.rename_provider = None
-                                            })
-                                        }
-                                    })?;
-                                }
                                 "textDocument/rangeFormatting" => {
                                     this.update(&mut cx, |this, _| {
                                         if let Some(server) = this.language_server_for_id(server_id)

crates/project/src/project.rs

@@ -3463,17 +3463,6 @@ impl Project {
         self.buffer_store.read(cx).blame_buffer(buffer, version, cx)
     }
 
-    pub fn get_permalink_to_line(
-        &self,
-        buffer: &Model<Buffer>,
-        selection: Range<u32>,
-        cx: &AppContext,
-    ) -> Task<Result<url::Url>> {
-        self.buffer_store
-            .read(cx)
-            .get_permalink_to_line(buffer, selection, cx)
-    }
-
     // RPC message handlers
 
     async fn handle_unshare_project(

crates/project_panel/src/project_panel.rs

@@ -2701,6 +2701,7 @@ impl ProjectPanel {
                 .cursor_default()
                 .when(self.width.is_some(), |this| {
                     this.children(Scrollbar::horizontal(
+                        //percentage as f32..end_offset as f32,
                         self.horizontal_scrollbar_state.clone(),
                     ))
                 }),
@@ -2917,9 +2918,7 @@ impl Render for ProjectPanel {
                     .track_scroll(self.scroll_handle.clone()),
                 )
                 .children(self.render_vertical_scrollbar(cx))
-                .when_some(self.render_horizontal_scrollbar(cx), |this, scrollbar| {
-                    this.pb_4().child(scrollbar)
-                })
+                .children(self.render_horizontal_scrollbar(cx))
                 .children(self.context_menu.as_ref().map(|(menu, position, _)| {
                     deferred(
                         anchored()

crates/proto/proto/zed.proto

@@ -292,10 +292,7 @@ message Envelope {
         Toast toast = 261;
         HideToast hide_toast = 262;
 
-        OpenServerSettings open_server_settings = 263;
-
-        GetPermalinkToLine get_permalink_to_line = 264;
-        GetPermalinkToLineResponse get_permalink_to_line_response = 265;  // current max
+        OpenServerSettings open_server_settings = 263; // current max
     }
 
     reserved 87 to 88;
@@ -2511,13 +2508,3 @@ message HideToast {
 message OpenServerSettings {
     uint64 project_id = 1;
 }
-
-message GetPermalinkToLine {
-    uint64 project_id = 1;
-    uint64 buffer_id = 2;
-    Range selection = 3;
-}
-
-message GetPermalinkToLineResponse {
-    string permalink = 1;
-}

crates/proto/src/proto.rs

@@ -370,8 +370,6 @@ messages!(
     (Toast, Background),
     (HideToast, Background),
     (OpenServerSettings, Foreground),
-    (GetPermalinkToLine, Foreground),
-    (GetPermalinkToLineResponse, Foreground),
 );
 
 request_messages!(
@@ -496,8 +494,7 @@ request_messages!(
     (CheckFileExists, CheckFileExistsResponse),
     (ShutdownRemoteServer, Ack),
     (RemoveWorktree, Ack),
-    (OpenServerSettings, OpenBufferResponse),
-    (GetPermalinkToLine, GetPermalinkToLineResponse),
+    (OpenServerSettings, OpenBufferResponse)
 );
 
 entity_messages!(
@@ -574,7 +571,7 @@ entity_messages!(
     Toast,
     HideToast,
     OpenServerSettings,
-    GetPermalinkToLine,
+
 );
 
 entity_messages!(

crates/recent_projects/Cargo.toml

@@ -22,7 +22,6 @@ file_finder.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
-itertools.workspace = true
 log.workspace = true
 menu.workspace = true
 ordered-float.workspace = true

crates/recent_projects/src/recent_projects.rs

@@ -13,7 +13,6 @@ use gpui::{
     Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView,
     Subscription, Task, View, ViewContext, WeakView,
 };
-use itertools::Itertools;
 use ordered_float::OrderedFloat;
 use picker::{
     highlighted_match_with_paths::{HighlightedMatchWithPaths, HighlightedText},
@@ -248,9 +247,8 @@ impl PickerDelegate for RecentProjectsDelegate {
                     SerializedWorkspaceLocation::Local(paths, order) => order
                         .order()
                         .iter()
-                        .zip(paths.paths().iter())
-                        .sorted_by_key(|(i, _)| *i)
-                        .map(|(_, path)| path.compact().to_string_lossy().into_owned())
+                        .filter_map(|i| paths.paths().get(*i))
+                        .map(|path| path.compact().to_string_lossy().into_owned())
                         .collect::<Vec<_>>()
                         .join(""),
                     SerializedWorkspaceLocation::DevServer(dev_server_project) => {
@@ -449,9 +447,8 @@ impl PickerDelegate for RecentProjectsDelegate {
                 order
                     .order()
                     .iter()
-                    .zip(paths.paths().iter())
-                    .sorted_by_key(|(i, _)| **i)
-                    .map(|(_, path)| path.compact())
+                    .filter_map(|i| paths.paths().get(*i).cloned())
+                    .map(|path| path.compact())
                     .collect(),
             ),
             SerializedWorkspaceLocation::Ssh(ssh_project) => Arc::new(ssh_project.ssh_urls()),

crates/recent_projects/src/ssh_connections.rs

@@ -175,7 +175,7 @@ impl Render for SshPrompt {
             .child(
                 h_flex()
                     .p_2()
-                    .flex()
+                    .flex_wrap()
                     .child(if self.error_message.is_some() {
                         Icon::new(IconName::XCircle)
                             .size(IconSize::Medium)
@@ -195,7 +195,6 @@ impl Render for SshPrompt {
                     })
                     .child(
                         div()
-                            .ml_1()
                             .text_ellipsis()
                             .overflow_x_hidden()
                             .when_some(self.error_message.as_ref(), |el, error| {
@@ -206,7 +205,7 @@ impl Render for SshPrompt {
                                 |el| {
                                     el.child(
                                         Label::new(format!(
-                                            "{}…",
+                                            "－{}…",
                                             self.status_message.clone().unwrap()
                                         ))
                                         .size(LabelSize::Small),

crates/remote/src/protocol.rs

@@ -2,6 +2,7 @@ use anyhow::Result;
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use prost::Message as _;
 use rpc::proto::Envelope;
+use std::mem::size_of;
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct MessageId(pub u32);
@@ -29,10 +30,8 @@ pub async fn read_message<S: AsyncRead + Unpin>(
 ) -> Result<Envelope> {
     buffer.resize(MESSAGE_LEN_SIZE, 0);
     stream.read_exact(buffer).await?;
-
     let len = message_len_from_buffer(buffer);
-    let result = read_message_with_len(stream, buffer, len).await;
-    result
+    read_message_with_len(stream, buffer, len).await
 }
 
 pub async fn write_message<S: AsyncWrite + Unpin>(

crates/remote/src/ssh_session.rs

@@ -13,7 +13,8 @@ use futures::{
         oneshot,
     },
     future::BoxFuture,
-    select_biased, AsyncReadExt as _, Future, FutureExt as _, SinkExt, StreamExt as _,
+    select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, SinkExt,
+    StreamExt as _,
 };
 use gpui::{
     AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, SemanticVersion, Task,
@@ -831,15 +832,7 @@ impl SshRemoteClient {
                                 log::warn!("ssh heartbeat: connection activity channel has been dropped. stopping.");
                                 return Ok(());
                             }
-
                             keepalive_timer.set(cx.background_executor().timer(HEARTBEAT_INTERVAL).fuse());
-
-                            if missed_heartbeats != 0 {
-                                missed_heartbeats = 0;
-                                this.update(&mut cx, |this, mut cx| {
-                                    this.handle_heartbeat_result(missed_heartbeats, &mut cx)
-                                })?;
-                            }
                         }
                         _ = keepalive_timer => {
                             log::debug!("Sending heartbeat to server...");
@@ -852,7 +845,6 @@ impl SshRemoteClient {
                                     ping_result
                                 }
                             };
-
                             if result.is_err() {
                                 missed_heartbeats += 1;
                                 log::warn!(
@@ -921,90 +913,92 @@ impl SshRemoteClient {
         let mut child_stdout = ssh_proxy_process.stdout.take().unwrap();
         let mut child_stdin = ssh_proxy_process.stdin.take().unwrap();
 
-        let mut stdin_buffer = Vec::new();
-        let mut stdout_buffer = Vec::new();
-        let mut stderr_buffer = Vec::new();
-        let mut stderr_offset = 0;
+        let io_task = cx.background_executor().spawn(async move {
+            let mut stdin_buffer = Vec::new();
+            let mut stdout_buffer = Vec::new();
+            let mut stderr_buffer = Vec::new();
+            let mut stderr_offset = 0;
 
-        let stdin_task = cx.background_executor().spawn(async move {
-            while let Some(outgoing) = outgoing_rx.next().await {
-                write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
-            }
-            anyhow::Ok(())
-        });
-
-        let stdout_task = cx.background_executor().spawn({
-            let mut connection_activity_tx = connection_activity_tx.clone();
-            async move {
-                loop {
-                    stdout_buffer.resize(MESSAGE_LEN_SIZE, 0);
-                    let len = child_stdout.read(&mut stdout_buffer).await?;
-
-                    if len == 0 {
-                        return anyhow::Ok(());
-                    }
-
-                    if len < MESSAGE_LEN_SIZE {
-                        child_stdout.read_exact(&mut stdout_buffer[len..]).await?;
-                    }
-
-                    let message_len = message_len_from_buffer(&stdout_buffer);
-                    let envelope =
-                        read_message_with_len(&mut child_stdout, &mut stdout_buffer, message_len)
-                            .await?;
-                    connection_activity_tx.try_send(()).ok();
-                    incoming_tx.unbounded_send(envelope).ok();
-                }
-            }
-        });
-
-        let stderr_task: Task<anyhow::Result<()>> = cx.background_executor().spawn(async move {
             loop {
+                stdout_buffer.resize(MESSAGE_LEN_SIZE, 0);
                 stderr_buffer.resize(stderr_offset + 1024, 0);
 
-                let len = child_stderr
-                    .read(&mut stderr_buffer[stderr_offset..])
-                    .await?;
+                select_biased! {
+                    outgoing = outgoing_rx.next().fuse() => {
+                        let Some(outgoing) = outgoing else {
+                            return anyhow::Ok(None);
+                        };
 
-                stderr_offset += len;
-                let mut start_ix = 0;
-                while let Some(ix) = stderr_buffer[start_ix..stderr_offset]
-                    .iter()
-                    .position(|b| b == &b'\n')
-                {
-                    let line_ix = start_ix + ix;
-                    let content = &stderr_buffer[start_ix..line_ix];
-                    start_ix = line_ix + 1;
-                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
-                        record.log(log::logger())
-                    } else {
-                        eprintln!("(remote) {}", String::from_utf8_lossy(content));
+                        write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
+                    }
+
+                    result = child_stdout.read(&mut stdout_buffer).fuse() => {
+                        match result {
+                            Ok(0) => {
+                                child_stdin.close().await?;
+                                outgoing_rx.close();
+                                let status = ssh_proxy_process.status().await?;
+                                // If we don't have a code, we assume process
+                                // has been killed and treat it as non-zero exit
+                                // code
+                                return Ok(status.code().or_else(|| Some(1)));
+                            }
+                            Ok(len) => {
+                                if len < stdout_buffer.len() {
+                                    child_stdout.read_exact(&mut stdout_buffer[len..]).await?;
+                                }
+
+                                let message_len = message_len_from_buffer(&stdout_buffer);
+                                match read_message_with_len(&mut child_stdout, &mut stdout_buffer, message_len).await {
+                                    Ok(envelope) => {
+                                        connection_activity_tx.try_send(()).ok();
+                                        incoming_tx.unbounded_send(envelope).ok();
+                                    }
+                                    Err(error) => {
+                                        log::error!("error decoding message {error:?}");
+                                    }
+                                }
+                            }
+                            Err(error) => {
+                                Err(anyhow!("error reading stdout: {error:?}"))?;
+                            }
+                        }
+                    }
+
+                    result = child_stderr.read(&mut stderr_buffer[stderr_offset..]).fuse() => {
+                        match result {
+                            Ok(len) => {
+                                stderr_offset += len;
+                                let mut start_ix = 0;
+                                while let Some(ix) = stderr_buffer[start_ix..stderr_offset].iter().position(|b| b == &b'\n') {
+                                    let line_ix = start_ix + ix;
+                                    let content = &stderr_buffer[start_ix..line_ix];
+                                    start_ix = line_ix + 1;
+                                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
+                                        record.log(log::logger())
+                                    } else {
+                                        eprintln!("(remote) {}", String::from_utf8_lossy(content));
+                                    }
+                                }
+                                stderr_buffer.drain(0..start_ix);
+                                stderr_offset -= start_ix;
+
+                                connection_activity_tx.try_send(()).ok();
+                            }
+                            Err(error) => {
+                                Err(anyhow!("error reading stderr: {error:?}"))?;
+                            }
+                        }
                     }
                 }
-                stderr_buffer.drain(0..start_ix);
-                stderr_offset -= start_ix;
-
-                connection_activity_tx.try_send(()).ok();
             }
         });
 
         cx.spawn(|mut cx| async move {
-            let result = futures::select! {
-                result = stdin_task.fuse() => {
-                    result.context("stdin")
-                }
-                result = stdout_task.fuse() => {
-                    result.context("stdout")
-                }
-                result = stderr_task.fuse() => {
-                    result.context("stderr")
-                }
-            };
+            let result = io_task.await;
 
             match result {
-                Ok(_) => {
-                    let exit_code = ssh_proxy_process.status().await?.code().unwrap_or(1);
-
+                Ok(Some(exit_code)) => {
                     if let Some(error) = ProxyLaunchError::from_exit_code(exit_code) {
                         match error {
                             ProxyLaunchError::ServerNotRunning => {
@@ -1022,6 +1016,7 @@ impl SshRemoteClient {
                         })?;
                     }
                 }
+                Ok(None) => {}
                 Err(error) => {
                     log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
                     this.update(&mut cx, |this, cx| {
@@ -1029,7 +1024,6 @@ impl SshRemoteClient {
                     })?;
                 }
             }
-
             Ok(())
         })
     }
@@ -1203,7 +1197,6 @@ impl SshRemoteConnection {
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Self> {
-        use futures::AsyncWriteExt as _;
         use futures::{io::BufReader, AsyncBufReadExt as _};
         use smol::{fs::unix::PermissionsExt as _, net::unix::UnixListener};
         use util::ResultExt as _;
@@ -1319,10 +1312,7 @@ impl SshRemoteConnection {
             let mut stderr = master_process.stderr.take().unwrap();
             stderr.read_to_end(&mut output).await?;
 
-            let error_message = format!(
-                "failed to connect: {}",
-                String::from_utf8_lossy(&output).trim()
-            );
+            let error_message = format!("failed to connect: {}", String::from_utf8_lossy(&output));
             delegate.set_error(error_message.clone(), cx);
             Err(anyhow!(error_message))?;
         }
@@ -1383,14 +1373,14 @@ impl SshRemoteConnection {
         let server_mode = 0o755;
 
         let t0 = Instant::now();
-        delegate.set_status(Some("Uploading remote development server"), cx);
+        delegate.set_status(Some("uploading remote development server"), cx);
         log::info!("uploading remote development server ({}kb)", size / 1024);
         self.upload_file(&src_path, &dst_path_gz)
             .await
             .context("failed to upload server binary")?;
         log::info!("uploaded remote development server in {:?}", t0.elapsed());
 
-        delegate.set_status(Some("Extracting remote development server"), cx);
+        delegate.set_status(Some("extracting remote development server"), cx);
         run_cmd(
             self.socket
                 .ssh_command("gunzip")
@@ -1399,7 +1389,7 @@ impl SshRemoteConnection {
         )
         .await?;
 
-        delegate.set_status(Some("Marking remote development server executable"), cx);
+        delegate.set_status(Some("unzipping remote development server"), cx);
         run_cmd(
             self.socket
                 .ssh_command("chmod")
@@ -1527,16 +1517,19 @@ impl ChannelClient {
                             cx.clone(),
                         ) {
                             log::debug!("ssh message received. name:{type_name}");
-                            match future.await {
-                                Ok(_) => {
-                                    log::debug!("ssh message handled. name:{type_name}");
+                            cx.foreground_executor().spawn(async move {
+                                match future.await {
+                                    Ok(_) => {
+                                        log::debug!("ssh message handled. name:{type_name}");
+                                    }
+                                    Err(error) => {
+                                        log::error!(
+                                            "error handling message. type:{type_name}, error:{error}",
+                                        );
+                                    }
                                 }
-                                Err(error) => {
-                                    log::error!(
-                                        "error handling message. type:{type_name}, error:{error}",
-                                    );
-                                }
-                            }
+                            }).detach();
+
                         } else {
                             log::error!("unhandled ssh message name:{type_name}");
                         }

crates/remote_server/Cargo.toml

@@ -30,8 +30,6 @@ client.workspace = true
 env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
-git.workspace = true
-git_hosting_providers.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 language.workspace = true

crates/remote_server/src/headless_project.rs

@@ -154,7 +154,6 @@ impl HeadlessProject {
         client.add_request_handler(cx.weak_model(), Self::handle_remove_worktree);
 
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
-        client.add_model_request_handler(Self::handle_open_new_buffer);
         client.add_model_request_handler(Self::handle_find_search_candidates);
         client.add_model_request_handler(Self::handle_open_server_settings);
 
@@ -364,32 +363,6 @@ impl HeadlessProject {
         })
     }
 
-    pub async fn handle_open_new_buffer(
-        this: Model<Self>,
-        _message: TypedEnvelope<proto::OpenNewBuffer>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::OpenBufferResponse> {
-        let (buffer_store, buffer) = this.update(&mut cx, |this, cx| {
-            let buffer_store = this.buffer_store.clone();
-            let buffer = this
-                .buffer_store
-                .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx));
-            anyhow::Ok((buffer_store, buffer))
-        })??;
-
-        let buffer = buffer.await?;
-        let buffer_id = buffer.read_with(&cx, |b, _| b.remote_id())?;
-        buffer_store.update(&mut cx, |buffer_store, cx| {
-            buffer_store
-                .create_buffer_for_peer(&buffer, SSH_PEER_ID, cx)
-                .detach_and_log_err(cx);
-        })?;
-
-        Ok(proto::OpenBufferResponse {
-            buffer_id: buffer_id.to_proto(),
-        })
-    }
-
     pub async fn handle_open_server_settings(
         this: Model<Self>,
         _: TypedEnvelope<proto::OpenServerSettings>,

crates/remote_server/src/unix.rs

@@ -5,14 +5,12 @@ use client::ProxySettings;
 use fs::{Fs, RealFs};
 use futures::channel::mpsc;
 use futures::{select, select_biased, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt, SinkExt};
-use git::GitHostingProviderRegistry;
 use gpui::{AppContext, Context as _, ModelContext, UpdateGlobal as _};
 use http_client::{read_proxy_from_env, Uri};
 use language::LanguageRegistry;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
 use paths::logs_dir;
 use project::project_settings::ProjectSettings;
-
 use remote::proxy::ProxyLaunchError;
 use remote::ssh_session::ChannelClient;
 use remote::{
@@ -214,27 +212,19 @@ fn start_server(
 
             let mut input_buffer = Vec::new();
             let mut output_buffer = Vec::new();
-
-            let (mut stdin_msg_tx, mut stdin_msg_rx) = mpsc::unbounded::<Envelope>();
-            cx.background_executor().spawn(async move {
-                while let Ok(msg) = read_message(&mut stdin_stream, &mut input_buffer).await {
-                    if let Err(_) = stdin_msg_tx.send(msg).await {
-                        break;
-                    }
-                }
-            }).detach();
-
             loop {
-
                 select_biased! {
                     _ = app_quit_rx.next().fuse() => {
                         return anyhow::Ok(());
                     }
 
-                    stdin_message = stdin_msg_rx.next().fuse() => {
-                        let Some(message) = stdin_message else {
-                            log::warn!("error reading message on stdin. exiting.");
-                            break;
+                    stdin_message = read_message(&mut stdin_stream, &mut input_buffer).fuse() => {
+                        let message = match stdin_message {
+                            Ok(message) => message,
+                            Err(error) => {
+                                log::warn!("error reading message on stdin: {}. exiting.", error);
+                                break;
+                            }
                         };
                         if let Err(error) = incoming_tx.unbounded_send(message) {
                             log::error!("failed to send message to application: {:?}. exiting.", error);
@@ -323,8 +313,6 @@ pub fn execute_run(
     let listeners = ServerListeners::new(stdin_socket, stdout_socket, stderr_socket)?;
 
     log::info!("starting headless gpui app");
-
-    let git_hosting_provider_registry = Arc::new(GitHostingProviderRegistry::new());
     gpui::App::headless().run(move |cx| {
         settings::init(cx);
         HeadlessProject::init(cx);
@@ -334,9 +322,6 @@ pub fn execute_run(
 
         client::init_settings(cx);
 
-        GitHostingProviderRegistry::set_global(git_hosting_provider_registry, cx);
-        git_hosting_providers::init(cx);
-
         let project = cx.new_model(|cx| {
             let fs = Arc::new(RealFs::new(Default::default(), None));
             let node_settings_rx = initialize_settings(session.clone(), fs.clone(), cx);

crates/repl/src/session.rs

@@ -17,7 +17,8 @@ use editor::{
 use futures::io::BufReader;
 use futures::{AsyncBufReadExt as _, FutureExt as _, StreamExt as _};
 use gpui::{
-    div, prelude::*, EventEmitter, Model, Render, Subscription, Task, View, ViewContext, WeakView,
+    div, prelude::*, EntityId, EventEmitter, Model, Render, Subscription, Task, View, ViewContext,
+    WeakView,
 };
 use language::Point;
 use project::Fs;
@@ -148,21 +149,23 @@ impl EditorBlock {
                 .w(text_line_height)
                 .h(text_line_height)
                 .child(
-                    IconButton::new("close_output_area", IconName::Close)
-                        .icon_size(IconSize::Small)
-                        .icon_color(Color::Muted)
-                        .size(ButtonSize::Compact)
-                        .shape(IconButtonShape::Square)
-                        .tooltip(|cx| Tooltip::text("Close output area", cx))
-                        .on_click(move |_, cx| {
-                            if let BlockId::Custom(block_id) = block_id {
-                                (on_close)(block_id, cx)
-                            }
-                        }),
+                    IconButton::new(
+                        ("close_output_area", EntityId::from(cx.block_id)),
+                        IconName::Close,
+                    )
+                    .icon_size(IconSize::Small)
+                    .icon_color(Color::Muted)
+                    .size(ButtonSize::Compact)
+                    .shape(IconButtonShape::Square)
+                    .tooltip(|cx| Tooltip::text("Close output area", cx))
+                    .on_click(move |_, cx| {
+                        if let BlockId::Custom(block_id) = block_id {
+                            (on_close)(block_id, cx)
+                        }
+                    }),
                 );
 
             div()
-                .id(cx.block_id)
                 .flex()
                 .items_start()
                 .min_h(text_line_height)

crates/reqwest_client/src/reqwest_client.rs

@@ -44,12 +44,8 @@ impl ReqwestClient {
         let mut client = reqwest::Client::builder()
             .use_rustls_tls()
             .default_headers(map);
-        if let Some(proxy) = proxy.clone().and_then(|proxy_uri| {
-            reqwest::Proxy::all(proxy_uri.to_string())
-                .inspect_err(|e| log::error!("Failed to parse proxy URI {}: {}", proxy_uri, e))
-                .ok()
-        }) {
-            client = client.proxy(proxy);
+        if let Some(proxy) = proxy.clone() {
+            client = client.proxy(reqwest::Proxy::all(proxy.to_string())?);
         }
         let client = client.build()?;
         let mut client: ReqwestClient = client.into();
@@ -236,47 +232,3 @@ impl http_client::HttpClient for ReqwestClient {
         .boxed()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use http_client::{http, HttpClient};
-
-    use crate::ReqwestClient;
-
-    #[test]
-    fn test_proxy_uri() {
-        let client = ReqwestClient::new();
-        assert_eq!(client.proxy(), None);
-
-        let proxy = http::Uri::from_static("http://localhost:10809");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-
-        let proxy = http::Uri::from_static("https://localhost:10809");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-
-        let proxy = http::Uri::from_static("socks4://localhost:10808");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-
-        let proxy = http::Uri::from_static("socks4a://localhost:10808");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-
-        let proxy = http::Uri::from_static("socks5://localhost:10808");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-
-        let proxy = http::Uri::from_static("socks5h://localhost:10808");
-        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
-        assert_eq!(client.proxy(), Some(&proxy));
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_invalid_proxy_uri() {
-        let proxy = http::Uri::from_static("file:///etc/hosts");
-        ReqwestClient::proxy_and_user_agent(Some(proxy), "test").unwrap();
-    }
-}

crates/terminal/src/terminal_settings.rs

@@ -151,7 +151,7 @@ pub struct TerminalSettingsContent {
     pub alternate_scroll: Option<AlternateScroll>,
     /// Sets whether the option key behaves as the meta key.
     ///
-    /// Default: false
+    /// Default: true
     pub option_as_meta: Option<bool>,
     /// Whether or not selecting text in the terminal will automatically
     /// copy to the system clipboard.

crates/text/src/text.rs

@@ -1427,7 +1427,7 @@ impl Buffer {
     fn undo_or_redo(&mut self, transaction: Transaction) -> Operation {
         let mut counts = HashMap::default();
         for edit_id in transaction.edit_ids {
-            counts.insert(edit_id, self.undo_map.undo_count(edit_id).saturating_add(1));
+            counts.insert(edit_id, self.undo_map.undo_count(edit_id) + 1);
         }
 
         let operation = self.undo_operations(counts);

crates/ui/src/components/icon.rs

@@ -170,7 +170,6 @@ pub enum IconName {
     Dash,
     DatabaseZap,
     Delete,
-    Diff,
     Disconnected,
     Download,
     Ellipsis,

crates/vim/src/normal/increment.rs

@@ -98,40 +98,32 @@ impl Vim {
     }
 }
 
-fn increment_decimal_string(num: &str, delta: i64) -> String {
-    let (negative, delta, num_str) = match num.strip_prefix('-') {
-        Some(n) => (true, -delta, n),
-        None => (false, delta, num),
-    };
-    let num_length = num_str.len();
-    let leading_zero = num_str.starts_with('0');
-
-    let (result, new_negative) = match u64::from_str_radix(num_str, 10) {
-        Ok(value) => {
-            let wrapped = value.wrapping_add_signed(delta);
-            if delta < 0 && wrapped > value {
-                ((u64::MAX - wrapped).wrapping_add(1), !negative)
-            } else if delta > 0 && wrapped < value {
-                (u64::MAX - wrapped, !negative)
-            } else {
-                (wrapped, negative)
-            }
+fn increment_decimal_string(mut num: &str, mut delta: i64) -> String {
+    let mut negative = false;
+    if num.chars().next() == Some('-') {
+        negative = true;
+        delta = 0 - delta;
+        num = &num[1..];
+    }
+    let result = if let Ok(value) = u64::from_str_radix(num, 10) {
+        let wrapped = value.wrapping_add_signed(delta);
+        if delta < 0 && wrapped > value {
+            negative = !negative;
+            (u64::MAX - wrapped).wrapping_add(1)
+        } else if delta > 0 && wrapped < value {
+            negative = !negative;
+            u64::MAX - wrapped
+        } else {
+            wrapped
         }
-        Err(_) => (u64::MAX, negative),
+    } else {
+        u64::MAX
     };
 
-    let formatted = format!("{}", result);
-    let new_significant_digits = formatted.len();
-    let padding = if leading_zero {
-        num_length.saturating_sub(new_significant_digits)
+    if result == 0 || !negative {
+        format!("{}", result)
     } else {
-        0
-    };
-
-    if new_negative && result != 0 {
-        format!("-{}{}", "0".repeat(padding), formatted)
-    } else {
-        format!("{}{}", "0".repeat(padding), formatted)
+        format!("-{}", result)
     }
 }
 
@@ -294,63 +286,6 @@ mod test {
             "});
     }
 
-    #[gpui::test]
-    async fn test_increment_with_leading_zeros(cx: &mut gpui::TestAppContext) {
-        let mut cx = NeovimBackedTestContext::new(cx).await;
-
-        cx.set_shared_state(indoc! {"
-            000ˇ9
-            "})
-            .await;
-
-        cx.simulate_shared_keystrokes("ctrl-a").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            001ˇ0
-            "});
-        cx.simulate_shared_keystrokes("2 ctrl-x").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            000ˇ8
-            "});
-    }
-
-    #[gpui::test]
-    async fn test_increment_with_leading_zeros_and_zero(cx: &mut gpui::TestAppContext) {
-        let mut cx = NeovimBackedTestContext::new(cx).await;
-
-        cx.set_shared_state(indoc! {"
-            01ˇ1
-            "})
-            .await;
-
-        cx.simulate_shared_keystrokes("ctrl-a").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            01ˇ2
-            "});
-        cx.simulate_shared_keystrokes("1 2 ctrl-x").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            00ˇ0
-            "});
-    }
-
-    #[gpui::test]
-    async fn test_increment_with_changing_leading_zeros(cx: &mut gpui::TestAppContext) {
-        let mut cx = NeovimBackedTestContext::new(cx).await;
-
-        cx.set_shared_state(indoc! {"
-            099ˇ9
-            "})
-            .await;
-
-        cx.simulate_shared_keystrokes("ctrl-a").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            100ˇ0
-            "});
-        cx.simulate_shared_keystrokes("2 ctrl-x").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-            99ˇ8
-            "});
-    }
-
     #[gpui::test]
     async fn test_increment_with_two_dots(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
@@ -387,27 +322,6 @@ mod test {
                 "});
     }
 
-    #[gpui::test]
-    async fn test_increment_sign_change_with_leading_zeros(cx: &mut gpui::TestAppContext) {
-        let mut cx = NeovimBackedTestContext::new(cx).await;
-        cx.set_shared_state(indoc! {"
-                00ˇ1
-                "})
-            .await;
-        cx.simulate_shared_keystrokes("ctrl-x").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-                00ˇ0
-                "});
-        cx.simulate_shared_keystrokes("ctrl-x").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-                -00ˇ1
-                "});
-        cx.simulate_shared_keystrokes("2 ctrl-a").await;
-        cx.shared_state().await.assert_eq(indoc! {"
-                00ˇ1
-                "});
-    }
-
     #[gpui::test]
     async fn test_increment_bin_wrapping_and_padding(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;

crates/vim/test_data/test_increment_sign_change_with_leading_zeros.json

@@ -1,8 +0,0 @@
-{"Put":{"state":"00ˇ1\n"}}
-{"Key":"ctrl-x"}
-{"Get":{"state":"00ˇ0\n","mode":"Normal"}}
-{"Key":"ctrl-x"}
-{"Get":{"state":"-00ˇ1\n","mode":"Normal"}}
-{"Key":"2"}
-{"Key":"ctrl-a"}
-{"Get":{"state":"00ˇ1\n","mode":"Normal"}}

crates/vim/test_data/test_increment_with_changing_leading_zeros.json

@@ -1,6 +0,0 @@
-{"Put":{"state":"099ˇ9\n"}}
-{"Key":"ctrl-a"}
-{"Get":{"state":"100ˇ0\n","mode":"Normal"}}
-{"Key":"2"}
-{"Key":"ctrl-x"}
-{"Get":{"state":"99ˇ8\n","mode":"Normal"}}

crates/vim/test_data/test_increment_with_leading_zeros.json

@@ -1,6 +0,0 @@
-{"Put":{"state":"000ˇ9\n"}}
-{"Key":"ctrl-a"}
-{"Get":{"state":"001ˇ0\n","mode":"Normal"}}
-{"Key":"2"}
-{"Key":"ctrl-x"}
-{"Get":{"state":"000ˇ8\n","mode":"Normal"}}

crates/vim/test_data/test_increment_with_leading_zeros_and_zero.json

@@ -1,7 +0,0 @@
-{"Put":{"state":"01ˇ1\n"}}
-{"Key":"ctrl-a"}
-{"Get":{"state":"01ˇ2\n","mode":"Normal"}}
-{"Key":"1"}
-{"Key":"2"}
-{"Key":"ctrl-x"}
-{"Get":{"state":"00ˇ0\n","mode":"Normal"}}

crates/vim/test_data/test_increment_zero_leading_zeros.json

@@ -1,4 +0,0 @@
-{"Put":{"state":"001ˇ0\n"}}
-{"Key":"10"}
-{"Key":"ctrl-x"}
-{"Get":{"state":"000ˇ9\n","mode":"Normal"}}

crates/workspace/src/persistence.rs

@@ -380,8 +380,6 @@ impl WorkspaceDb {
         &self,
         worktree_roots: &[P],
     ) -> Option<SerializedWorkspace> {
-        // paths are sorted before db interactions to ensure that the order of the paths
-        // doesn't affect the workspace selection for existing workspaces
         let local_paths = LocalPaths::new(worktree_roots);
 
         // Note that we re-assign the workspace_id here in case it's empty
@@ -835,8 +833,8 @@ impl WorkspaceDb {
     }
 
     query! {
-        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, LocalPathsOrder, Option<u64>, Option<u64>)>> {
-            SELECT local_paths, local_paths_order, window_id, ssh_project_id
+        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, Option<u64>, Option<u64>)>> {
+            SELECT local_paths, window_id, ssh_project_id
             FROM workspaces
             WHERE session_id = ?1 AND dev_server_project_id IS NULL
             ORDER BY timestamp DESC
@@ -973,7 +971,7 @@ impl WorkspaceDb {
     ) -> Result<Vec<SerializedWorkspaceLocation>> {
         let mut workspaces = Vec::new();
 
-        for (location, order, window_id, ssh_project_id) in
+        for (location, window_id, ssh_project_id) in
             self.session_workspaces(last_session_id.to_owned())?
         {
             if let Some(ssh_project_id) = ssh_project_id {
@@ -982,7 +980,8 @@ impl WorkspaceDb {
             } else if location.paths().iter().all(|path| path.exists())
                 && location.paths().iter().any(|path| path.is_dir())
             {
-                let location = SerializedWorkspaceLocation::Local(location, order);
+                let location =
+                    SerializedWorkspaceLocation::from_local_paths(location.paths().iter());
                 workspaces.push((location, window_id.map(WindowId::from)));
             }
         }
@@ -1604,56 +1603,27 @@ mod tests {
             window_id: Some(50),
         };
 
-        let workspace_6 = SerializedWorkspace {
-            id: WorkspaceId(6),
-            location: SerializedWorkspaceLocation::Local(
-                LocalPaths::new(["/tmp6a", "/tmp6b", "/tmp6c"]),
-                LocalPathsOrder::new([2, 1, 0]),
-            ),
-            center_group: Default::default(),
-            window_bounds: Default::default(),
-            display: Default::default(),
-            docks: Default::default(),
-            centered_layout: false,
-            session_id: Some("session-id-3".to_owned()),
-            window_id: Some(60),
-        };
-
         db.save_workspace(workspace_1.clone()).await;
         db.save_workspace(workspace_2.clone()).await;
         db.save_workspace(workspace_3.clone()).await;
         db.save_workspace(workspace_4.clone()).await;
         db.save_workspace(workspace_5.clone()).await;
-        db.save_workspace(workspace_6.clone()).await;
 
         let locations = db.session_workspaces("session-id-1".to_owned()).unwrap();
         assert_eq!(locations.len(), 2);
         assert_eq!(locations[0].0, LocalPaths::new(["/tmp1"]));
-        assert_eq!(locations[0].1, LocalPathsOrder::new([0]));
-        assert_eq!(locations[0].2, Some(10));
+        assert_eq!(locations[0].1, Some(10));
         assert_eq!(locations[1].0, LocalPaths::new(["/tmp2"]));
-        assert_eq!(locations[1].1, LocalPathsOrder::new([0]));
-        assert_eq!(locations[1].2, Some(20));
+        assert_eq!(locations[1].1, Some(20));
 
         let locations = db.session_workspaces("session-id-2".to_owned()).unwrap();
         assert_eq!(locations.len(), 2);
         assert_eq!(locations[0].0, LocalPaths::new(["/tmp3"]));
-        assert_eq!(locations[0].1, LocalPathsOrder::new([0]));
-        assert_eq!(locations[0].2, Some(30));
+        assert_eq!(locations[0].1, Some(30));
         let empty_paths: Vec<&str> = Vec::new();
         assert_eq!(locations[1].0, LocalPaths::new(empty_paths.iter()));
-        assert_eq!(locations[1].1, LocalPathsOrder::new([]));
-        assert_eq!(locations[1].2, Some(50));
-        assert_eq!(locations[1].3, Some(ssh_project.id.0));
-
-        let locations = db.session_workspaces("session-id-3".to_owned()).unwrap();
-        assert_eq!(locations.len(), 1);
-        assert_eq!(
-            locations[0].0,
-            LocalPaths::new(["/tmp6a", "/tmp6b", "/tmp6c"]),
-        );
-        assert_eq!(locations[0].1, LocalPathsOrder::new([2, 1, 0]));
-        assert_eq!(locations[0].2, Some(60));
+        assert_eq!(locations[1].1, Some(50));
+        assert_eq!(locations[1].2, Some(ssh_project.id.0));
     }
 
     fn default_workspace<P: AsRef<Path>>(
@@ -1684,30 +1654,15 @@ mod tests {
             WorkspaceDb(open_test_db("test_serializing_workspaces_last_session_workspaces").await);
 
         let workspaces = [
-            (1, vec![dir1.path()], vec![0], 9),
-            (2, vec![dir2.path()], vec![0], 5),
-            (3, vec![dir3.path()], vec![0], 8),
-            (4, vec![dir4.path()], vec![0], 2),
-            (
-                5,
-                vec![dir1.path(), dir2.path(), dir3.path()],
-                vec![0, 1, 2],
-                3,
-            ),
-            (
-                6,
-                vec![dir2.path(), dir3.path(), dir4.path()],
-                vec![2, 1, 0],
-                4,
-            ),
+            (1, dir1.path().to_str().unwrap(), 9),
+            (2, dir2.path().to_str().unwrap(), 5),
+            (3, dir3.path().to_str().unwrap(), 8),
+            (4, dir4.path().to_str().unwrap(), 2),
         ]
         .into_iter()
-        .map(|(id, locations, order, window_id)| SerializedWorkspace {
+        .map(|(id, location, window_id)| SerializedWorkspace {
             id: WorkspaceId(id),
-            location: SerializedWorkspaceLocation::Local(
-                LocalPaths::new(locations),
-                LocalPathsOrder::new(order),
-            ),
+            location: SerializedWorkspaceLocation::from_local_paths([location]),
             center_group: Default::default(),
             window_bounds: Default::default(),
             display: Default::default(),
@@ -1726,44 +1681,28 @@ mod tests {
             WindowId::from(2), // Top
             WindowId::from(8),
             WindowId::from(5),
-            WindowId::from(9),
-            WindowId::from(3),
-            WindowId::from(4), // Bottom
+            WindowId::from(9), // Bottom
         ]));
 
         let have = db
             .last_session_workspace_locations("one-session", stack)
             .unwrap();
-        assert_eq!(have.len(), 6);
+        assert_eq!(have.len(), 4);
         assert_eq!(
             have[0],
-            SerializedWorkspaceLocation::from_local_paths(&[dir4.path()])
+            SerializedWorkspaceLocation::from_local_paths(&[dir4.path().to_str().unwrap()])
         );
         assert_eq!(
             have[1],
-            SerializedWorkspaceLocation::from_local_paths([dir3.path()])
+            SerializedWorkspaceLocation::from_local_paths([dir3.path().to_str().unwrap()])
         );
         assert_eq!(
             have[2],
-            SerializedWorkspaceLocation::from_local_paths([dir2.path()])
+            SerializedWorkspaceLocation::from_local_paths([dir2.path().to_str().unwrap()])
         );
         assert_eq!(
             have[3],
-            SerializedWorkspaceLocation::from_local_paths([dir1.path()])
-        );
-        assert_eq!(
-            have[4],
-            SerializedWorkspaceLocation::Local(
-                LocalPaths::new([dir1.path(), dir2.path(), dir3.path()]),
-                LocalPathsOrder::new([0, 1, 2]),
-            ),
-        );
-        assert_eq!(
-            have[5],
-            SerializedWorkspaceLocation::Local(
-                LocalPaths::new([dir2.path(), dir3.path(), dir4.path()]),
-                LocalPathsOrder::new([2, 1, 0]),
-            ),
+            SerializedWorkspaceLocation::from_local_paths([dir1.path().to_str().unwrap()])
         );
     }
 

crates/workspace/src/workspace.rs

@@ -1103,28 +1103,20 @@ impl Workspace {
 
             let mut paths_to_open = abs_paths;
 
-            let workspace_location = serialized_workspace
+            let paths_order = serialized_workspace
                 .as_ref()
                 .map(|ws| &ws.location)
                 .and_then(|loc| match loc {
-                    SerializedWorkspaceLocation::Local(paths, order) => {
-                        Some((paths.paths(), order.order()))
-                    }
+                    SerializedWorkspaceLocation::Local(_, order) => Some(order.order()),
                     _ => None,
                 });
 
-            if let Some((paths, order)) = workspace_location {
-                // todo: should probably move this logic to a method on the SerializedWorkspaceLocation
-                // it's only valid for Local and would be more clear there and be able to be tested
-                // and reused elsewhere
-                paths_to_open = order
+            if let Some(paths_order) = paths_order {
+                paths_to_open = paths_order
                     .iter()
-                    .zip(paths.iter())
-                    .sorted_by_key(|(i, _)| *i)
-                    .map(|(_, path)| path.clone())
-                    .collect();
-
-                if order.iter().enumerate().any(|(i, &j)| i != j) {
+                    .filter_map(|i| paths_to_open.get(*i).cloned())
+                    .collect::<Vec<_>>();
+                if paths_order.iter().enumerate().any(|(i, &j)| i != j) {
                     project_handle
                         .update(&mut cx, |project, cx| {
                             project.set_worktrees_reordered(true, cx);
@@ -1897,7 +1889,11 @@ impl Workspace {
                 directories: true,
                 multiple: true,
             },
-            DirectoryLister::Local(self.app_state.fs.clone()),
+            if self.project.read(cx).is_via_ssh() {
+                DirectoryLister::Project(self.project.clone())
+            } else {
+                DirectoryLister::Local(self.app_state.fs.clone())
+            },
             cx,
         );
 

crates/zed/src/zed.rs

@@ -11,7 +11,7 @@ pub(crate) mod windows_only_instance;
 pub use app_menus::*;
 use assistant::PromptBuilder;
 use breadcrumbs::Breadcrumbs;
-use client::{zed_urls, ZED_URL_SCHEME};
+use client::ZED_URL_SCHEME;
 use collections::VecDeque;
 use command_palette_hooks::CommandPaletteFilter;
 use editor::ProposedChangesEditorToolbar;
@@ -419,7 +419,8 @@ pub fn initialize_workspace(
             )
             .register_action(
                 |_: &mut Workspace, _: &OpenAccountSettings, cx: &mut ViewContext<Workspace>| {
-                    cx.open_url(&zed_urls::account_url(cx));
+                    let server_url = &client::ClientSettings::get_global(cx).server_url;
+                    cx.open_url(&format!("{server_url}/account"));
                 },
             )
             .register_action(

docs/src/configuring-zed.md

@@ -1498,13 +1498,13 @@ List of `integer` column numbers
         "directories": [".env", "env", ".venv", "venv"],
         "activate_script": "default"
       }
-    },
+    }
     "env": {},
     "font_family": null,
     "font_features": null,
     "font_size": null,
     "line_height": "comfortable",
-    "option_as_meta": false,
+    "option_as_meta": true,
     "button": false,
     "shell": {},
     "toolbar": {
@@ -1732,7 +1732,7 @@ See Buffer Font Features
 
 - Description: Re-interprets the option keys to act like a 'meta' key, like in Emacs.
 - Setting: `option_as_meta`
-- Default: `false`
+- Default: `true`
 
 **Options**
 

docs/src/languages.md

@@ -32,7 +32,6 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [JavaScript](./languages/javascript.md)
 - [Julia](./languages/julia.md)
 - [JSON](./languages/json.md)
-- [Jsonnet](./languages/jsonnet.md)
 - [Kotlin](./languages/kotlin.md)
 - [Lua](./languages/lua.md)
 - [Luau](./languages/luau.md)
@@ -105,6 +104,7 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [Groq](https://github.com/juice49/zed-groq)
 - [INI](https://github.com/bajrangCoder/zed-ini)
 - [Java](https://github.com/zed-extensions/java)
+- [Jsonnet](https://github.com/narqo/zed-jsonnet)
 - [Justfiles](https://github.com/jackTabsCode/zed-just)
 - [LaTeX](https://github.com/rzukic/zed-latex)
 - [Ledger](https://github.com/mrkstwrt/zed-ledger)

docs/src/languages/java.md

@@ -10,9 +10,11 @@ Both use:
 - Tree Sitter: [tree-sitter/tree-sitter-java](https://github.com/tree-sitter/tree-sitter-java)
 - Language Server: [eclipse-jdtls/eclipse.jdt.ls](https://github.com/eclipse-jdtls/eclipse.jdt.ls)
 
-## Install OpenJDK
+## Pre-requisites
 
-You will need to install a Java runtime (OpenJDK).
+You will need to install both a Java runtime (OpenJDK) and Eclipse JDT Language Server (`eclipse.jdt.ls`).
+
+### Install OpenJDK
 
 - MacOS: `brew install openjdk`
 - Ubuntu: `sudo add-apt-repository ppa:openjdk-23 && sudo apt-get install openjdk-23`
@@ -21,19 +23,26 @@ You will need to install a Java runtime (OpenJDK).
 
 Or manually download and install [OpenJDK 23](https://jdk.java.net/23/).
 
+### Install JDTLS
+
+- MacOS: `brew install jdtls`
+- Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
+
+Or manually download install:
+
+- [JDTLS Milestone Builds](http://download.eclipse.org/jdtls/milestones/) (updated every two weeks)
+- [JDTLS Snapshot Builds](https://download.eclipse.org/jdtls/snapshots/) (frequent updates)
+
 ## Extension Install
 
 You can install either by opening {#action zed::Extensions}({#kb zed::Extensions}) and searching for `java`.
-
 We recommend you install one or the other and not both.
 
 ## Settings / Initialization Options
 
-Both extensions will automatically download the language server, see: [Manual JDTLS Install](#manual-jdts-install) below if you'd prefer to manage that yourself.
+See [JDTLS Language Server Settings & Capabilities](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Language-Server-Settings-&-Capabilities) for a complete list of options.
 
-For available `initialization_options` please see the [Initialize Request section of the Eclipse.jdt.ls Wiki](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Running-the-JAVA-LS-server-from-the-command-line#initialize-request).
-
-You can add these customizations to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}) or by using a `.zed/setting.json` inside your project.
+Add the following to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}).
 
 ### Zed Java Settings
 
@@ -41,11 +50,9 @@ You can add these customizations to your Zed Settings by launching {#action zed:
 {
   "lsp": {
     "jdtls": {
-      "settings": {
-        "version": "1.40.0", // jdtls version to download and use
-        "classpath": "/path/to/classes.jar:/path/to/more/classes/"
-      },
+      "settings": {},
       "initialization_options": {}
+      }
     }
   }
 }
@@ -64,9 +71,37 @@ You can add these customizations to your Zed Settings by launching {#action zed:
 }
 ```
 
+## See also
+
+- [Zed Java Readme](https://github.com/zed-extensions/java)
+- [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
+
+### Support
+
+If you have issues with either of these plugins, please open issues on their respective repositories:
+
+- [Zed Java Issues](https://github.com/zed-extensions/java/issues)
+- [Java with Eclipse JDTLS Issues](https://github.com/ABckh/zed-java-eclipse-jdtls/issues)
+
 ## Example Configs
 
-### Zed Java Initialization Options
+### Zed Java Classpath
+
+You can optionally configure the class path that JDTLS uses with:
+
+```json
+{
+  "lsp": {
+    "jdtls": {
+      "settings": {
+        "classpath": "/path/to/classes.jar:/path/to/more/classes/"
+      }
+    }
+  }
+}
+```
+
+#### Zed Java Initialization Options
 
 There are also many more options you can pass directly to the language server, for example:
 
@@ -149,7 +184,7 @@ There are also many more options you can pass directly to the language server, f
 }
 ```
 
-### Java with Eclipse JTDLS Configuration {#zed-java-eclipse-configuration}
+## Java with Eclipse JTDLS Configuration {#zed-java-eclipse-configuration}
 
 Configuration options match those provided in the [redhat-developer/vscode-java extension](https://github.com/redhat-developer/vscode-java#supported-vs-code-settings).
 
@@ -166,27 +201,3 @@ For example, to enable [Lombok Support](https://github.com/redhat-developer/vsco
   }
 }
 ```
-
-## Manual JDTLS Install
-
-If you prefer, you can install JDTLS yourself and both extensions can be configured to use that instead.
-
-- MacOS: `brew install jdtls`
-- Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
-
-Or manually download install:
-
-- [JDTLS Milestone Builds](http://download.eclipse.org/jdtls/milestones/) (updated every two weeks)
-- [JDTLS Snapshot Builds](https://download.eclipse.org/jdtls/snapshots/) (frequent updates)
-
-## See also
-
-- [Zed Java Readme](https://github.com/zed-extensions/java)
-- [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
-
-## Support
-
-If you have issues with either of these plugins, please open issues on their respective repositories:
-
-- [Zed Java Issues](https://github.com/zed-extensions/java/issues)
-- [Java with Eclipse JDTLS Issues](https://github.com/ABckh/zed-java-eclipse-jdtls/issues)

docs/src/languages/jsonnet.md

@@ -1,24 +0,0 @@
-# Jsonnet
-
-Jsonnet language support in Zed is provided by the community-maintained [Jsonnet extension](https://github.com/narqo/zed-jsonnet).
-
-- Tree Sitter: [sourcegraph/tree-sitter-jsonnet](https://github.com/sourcegraph/tree-sitter-jsonnet)
-- Language Server: [grafana/jsonnet-language-server](https://github.com/grafana/jsonnet-language-server)
-
-## Configuration
-
-Workspace configuration options can be passed to the language server via the `lsp` settings of the `settings.json`.
-
-The following example enables support for resolving [tanka](https://tanka.dev) import paths in `jsonnet-language-server`:
-
-```json
-{
-  "lsp": {
-    "jsonnet-language-server": {
-      "settings": {
-        "resolve_paths_with_tanka": true
-      }
-    }
-  }
-}
-```

extensions/elixir/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zed_elixir"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"

extensions/elixir/extension.toml

@@ -1,7 +1,7 @@
 id = "elixir"
 name = "Elixir"
 description = "Elixir support."
-version = "0.1.1"
+version = "0.1.0"
 schema_version = 1
 authors = ["Marshall Bowers <elliott.codes@gmail.com>"]
 repository = "https://github.com/zed-industries/zed"

extensions/elixir/languages/elixir/outline.scm

@@ -3,16 +3,6 @@
   (arguments (alias) @name)
   (#match? @context "^(defmodule|defprotocol)$")) @item
 
-(call
-  target: (identifier) @context
-  (arguments (_) @name)?
-  (#match? @context "^(setup|setup_all)$")) @item
-
-(call
-  target: (identifier) @context
-  (arguments (string) @name)
-  (#match? @context "^(describe|test)$")) @item
-
 (unary_operator
   operator: "@" @name
   operand: (call

extensions/svelte/.gitignore

@@ -0,0 +1,3 @@
+target
+*.wasm
+grammars

extensions/svelte/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "zed_svelte"
+version = "0.2.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/svelte.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.1.0"

extensions/svelte/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-APACHE

extensions/svelte/extension.toml

@@ -0,0 +1,15 @@
+id = "svelte"
+name = "Svelte"
+description = "Svelte support"
+version = "0.2.0"
+schema_version = 1
+authors = []
+repository = "https://github.com/zed-extensions/svelte"
+
+[language_servers.svelte-language-server]
+name = "Svelte Language Server"
+language = "Svelte"
+
+[grammars.svelte]
+repository = "https://github.com/tree-sitter-grammars/tree-sitter-svelte"
+commit = "3f06f705410683adb17d146b5eca28c62fe81ba6"

extensions/svelte/languages/svelte/brackets.scm

@@ -0,0 +1,7 @@
+("<" @open ">" @close)
+("{" @open "}" @close)
+("'" @open "'" @close)
+("\"" @open "\"" @close)
+("(" @open ")" @close)
+; ("[" @open "]" @close)
+; ("`" @open "`" @close)

extensions/svelte/languages/svelte/config.toml

@@ -0,0 +1,22 @@
+name = "Svelte"
+grammar = "svelte"
+path_suffixes = ["svelte"]
+block_comment = ["<!-- ", " -->"]
+autoclose_before = ":\"'}]>"
+brackets = [
+    { start = "{", end = "}", close = true, newline = true },
+    { start = "<", end = ">", close = true, newline = true, not_in = ["string"] },
+    { start = "[", end = "]", close = true, newline = true },
+    { start = "(", end = ")", close = true, newline = true },
+    { start = "!--", end = " --", close = true, newline = true },
+    { start = "\"", end = "\"", close = true, newline = true, not_in = ["string"] },
+    { start = "'", end = "'", close = true, newline = true, not_in = ["string"] },
+    { start = "`", end = "`", close = true, newline = true, not_in = ["string"] },
+]
+scope_opt_in_language_servers = ["tailwindcss-language-server"]
+prettier_parser_name = "svelte"
+prettier_plugins = ["prettier-plugin-svelte"]
+
+[overrides.string]
+word_characters = ["-"]
+opt_into_language_servers = ["tailwindcss-language-server"]

extensions/svelte/languages/svelte/highlights.scm

@@ -0,0 +1,107 @@
+
+; comments
+(comment) @comment
+
+; property attribute
+(attribute_directive) @attribute.function
+(attribute_identifier) @attribute
+(attribute_modifier) @attribute.special
+
+; Style component attributes as @property
+(start_tag
+    (
+        (tag_name) @_tag_name
+        (#match? @_tag_name "^[A-Z]")
+    )
+    (attribute
+        (attribute_name
+            (attribute_identifier) @tag.property
+        )
+    )
+)
+
+(self_closing_tag
+    (
+        (tag_name) @_tag_name
+        (#match? @_tag_name "^[A-Z]")
+    )
+    (attribute
+        (attribute_name
+            (attribute_identifier) @tag.property
+        )
+    )
+)
+
+
+; style elements starting with lowercase letters as tags
+(
+    (tag_name) @tag
+    (#match? @tag "^[a-z]")
+)
+
+; style elements starting with uppercase letters as components (types)
+; Also valid might be to treat them as constructors
+(
+    (tag_name) @tag @tag.component.type.constructor
+    (#match? @tag "^[A-Z]")
+)
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+] @tag.punctuation.bracket
+
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+    "|"
+] @punctuation.delimiter
+
+
+[
+  "@"
+  "#"
+  ":"
+  "/"
+] @tag.punctuation.special
+
+"=" @operator
+
+
+; Treating (if, each, ...) as a keyword inside of blocks
+; like {#if ...} or {#each ...}
+(block_start_tag
+    tag: _ @tag.keyword
+)
+
+(block_tag
+    tag: _ @tag.keyword
+)
+
+(block_end_tag
+    tag: _ @tag.keyword
+)
+
+(expression_tag
+    tag: _ @tag.keyword
+)
+
+; Style quoted string attribute values
+(quoted_attribute_value) @string
+
+
+; Highlight the `as` keyword in each blocks
+(each_start
+    ("as") @tag.keyword
+)
+
+
+; Highlight the snippet name as a function
+; (e.g. {#snippet foo(bar)}
+(snippet_name) @function

extensions/svelte/languages/svelte/indents.scm

@@ -0,0 +1,9 @@
+[
+  (element)
+  (if_statement)
+  (each_statement)
+  (await_statement)
+  (snippet_statement)
+  (script_element)
+  (style_element)
+] @indent

extensions/svelte/languages/svelte/injections.scm

@@ -0,0 +1,86 @@
+; ; injections.scm
+; ; --------------
+
+; Match script tags with a lang attribute
+(script_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+            (#eq? @_attr_name "lang")
+            (quoted_attribute_value
+                (attribute_value) @language
+            )
+        )
+    )
+    (raw_text) @content
+)
+
+; Match script tags without a lang attribute
+(script_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+        )*
+    )
+    (raw_text) @content
+    (#not-any-of? @_attr_name "lang")
+    (#set! language "javascript")
+)
+
+; Match the contents of the script's generics="T extends string" as typescript code
+;
+; Disabled for the time-being because tree-sitter is treating the generics
+; attribute as a top-level typescript statement, where `T extends string` is
+; not a valid top-level typescript statement.
+;
+; (script_element
+;     (start_tag
+;         (attribute
+;             (attribute_name) @_attr_name
+;             (#eq? @_attr_name "generics")
+;             (quoted_attribute_value
+;                 (attribute_value) @content
+;             )
+;         )
+;     )
+; 	(#set! language "typescript")
+; )
+
+
+; Mark everything as typescript because it's
+; a more generic superset of javascript
+; Not sure if it's possible to somehow refer to the
+; script's language attribute here.
+((svelte_raw_text) @content
+    (#set! "language" "ts")
+)
+
+; Match style tags with a lang attribute
+(style_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+            (#eq? @_attr_name "lang")
+            (quoted_attribute_value
+                (attribute_value) @language
+            )
+        )
+    )
+    (raw_text) @content
+)
+
+; Match style tags without a lang attribute
+(style_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+        )*
+    )
+    (raw_text) @content
+    (#not-any-of? @_attr_name "lang")
+    (#set! language "css")
+)
+
+
+; Downstream TODO: Style highlighting for `style:background="red"` and `style="background: red"` strings
+; Downstream TODO: Style component comments as markdown

extensions/svelte/languages/svelte/outline.scm

@@ -0,0 +1,69 @@
+
+(script_element
+    (start_tag) @name
+    (raw_text) @context @item
+)
+
+(script_element
+    (end_tag) @name @item
+)
+
+(style_element
+    (start_tag) @name
+    (raw_text) @context
+) @item
+
+
+(document) @item
+
+(comment) @annotation
+
+(if_statement
+    (if_start) @name
+) @item
+
+(else_block
+    (else_start) @name
+) @item
+
+(else_if_block
+    (else_if_start) @name
+) @item
+
+(element
+    (start_tag) @name
+) @item
+
+(element
+    (self_closing_tag) @name
+) @item
+
+
+; (if_end) @name @item
+
+(each_statement
+    (each_start) @name
+) @item
+
+
+(snippet_statement
+    (snippet_start) @name
+) @item
+
+(snippet_end) @name @item
+
+(html_tag) @name @item
+
+(const_tag) @name @item
+
+(await_statement
+    (await_start) @name
+) @item
+
+(then_block
+    (then_start) @name
+) @item
+
+(catch_block
+    (catch_start) @name
+) @item

extensions/svelte/languages/svelte/overrides.scm

@@ -0,0 +1,7 @@
+(comment) @comment
+
+[
+  (raw_text)
+  (attribute_value)
+  (quoted_attribute_value)
+] @string

extensions/svelte/src/svelte.rs

@@ -0,0 +1,124 @@
+use std::{env, fs};
+use zed_extension_api::{self as zed, serde_json, Result};
+
+struct SvelteExtension {
+    did_find_server: bool,
+}
+
+const SERVER_PATH: &str = "node_modules/svelte-language-server/bin/server.js";
+const PACKAGE_NAME: &str = "svelte-language-server";
+
+impl SvelteExtension {
+    fn server_exists(&self) -> bool {
+        fs::metadata(SERVER_PATH).map_or(false, |stat| stat.is_file())
+    }
+
+    fn server_script_path(&mut self, id: &zed::LanguageServerId) -> Result<String> {
+        let server_exists = self.server_exists();
+        if self.did_find_server && server_exists {
+            return Ok(SERVER_PATH.to_string());
+        }
+
+        zed::set_language_server_installation_status(
+            id,
+            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
+        );
+        let version = zed::npm_package_latest_version(PACKAGE_NAME)?;
+
+        if !server_exists
+            || zed::npm_package_installed_version(PACKAGE_NAME)?.as_ref() != Some(&version)
+        {
+            zed::set_language_server_installation_status(
+                id,
+                &zed::LanguageServerInstallationStatus::Downloading,
+            );
+            let result = zed::npm_install_package(PACKAGE_NAME, &version);
+            match result {
+                Ok(()) => {
+                    if !self.server_exists() {
+                        Err(format!(
+                            "installed package '{PACKAGE_NAME}' did not contain expected path '{SERVER_PATH}'",
+                        ))?;
+                    }
+                }
+                Err(error) => {
+                    if !self.server_exists() {
+                        Err(error)?;
+                    }
+                }
+            }
+        }
+
+        self.did_find_server = true;
+        Ok(SERVER_PATH.to_string())
+    }
+}
+
+impl zed::Extension for SvelteExtension {
+    fn new() -> Self {
+        Self {
+            did_find_server: false,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        id: &zed::LanguageServerId,
+        _: &zed::Worktree,
+    ) -> Result<zed::Command> {
+        let server_path = self.server_script_path(id)?;
+        Ok(zed::Command {
+            command: zed::node_binary_path()?,
+            args: vec![
+                env::current_dir()
+                    .unwrap()
+                    .join(&server_path)
+                    .to_string_lossy()
+                    .to_string(),
+                "--stdio".to_string(),
+            ],
+            env: Default::default(),
+        })
+    }
+
+    fn language_server_initialization_options(
+        &mut self,
+        _: &zed::LanguageServerId,
+        _: &zed::Worktree,
+    ) -> Result<Option<serde_json::Value>> {
+        let config = serde_json::json!({
+          "inlayHints": {
+            "parameterNames": {
+              "enabled": "all",
+              "suppressWhenArgumentMatchesName": false
+            },
+            "parameterTypes": {
+              "enabled": true
+            },
+            "variableTypes": {
+              "enabled": true,
+              "suppressWhenTypeMatchesName": false
+            },
+            "propertyDeclarationTypes": {
+              "enabled": true
+            },
+            "functionLikeReturnTypes": {
+              "enabled": true
+            },
+            "enumMemberValues": {
+              "enabled": true
+            }
+          }
+        });
+
+        Ok(Some(serde_json::json!({
+            "provideFormatter": true,
+            "configuration": {
+                "typescript": config,
+                "javascript": config
+            }
+        })))
+    }
+}
+
+zed::register_extension!(SvelteExtension);

extensions/vue/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "zed_vue"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/vue.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+zed_extension_api = "0.1.0"

extensions/vue/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-APACHE